?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ole32/tests: Test creation of a storage on an ILockBytes containing data.
[wine.git] / dlls / wininet / ftp.c
blob1b0a46b6a1ad7c6e983f94d712eada7ef6ba4719
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 NULL,
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 if(lpwh)
1430 WININET_Release( &lpwh->hdr );
1431 return FALSE;
1432 }
1433
1434 return lpwh->hdr.hInternet;
1435 }
1436
1437
1438 /***********************************************************************
1439 * FtpOpenFileA (WININET.@)
1440 *
1441 * Open a remote file for writing or reading
1442 *
1443 * RETURNS
1444 * HINTERNET handle on success
1445 * NULL on failure
1446 *
1447 */
1448 HINTERNET WINAPI FtpOpenFileA(HINTERNET hFtpSession,
1449 LPCSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
1450 DWORD_PTR dwContext)
1451 {
1452 LPWSTR lpwzFileName;
1453 HINTERNET ret;
1454
1455 lpwzFileName = heap_strdupAtoW(lpszFileName);
1456 ret = FtpOpenFileW(hFtpSession, lpwzFileName, fdwAccess, dwFlags, dwContext);
1457 heap_free(lpwzFileName);
1458 return ret;
1459 }
1460
1461
1462 static void AsyncFtpOpenFileProc(WORKREQUEST *workRequest)
1463 {
1464 struct WORKREQ_FTPOPENFILEW const *req = &workRequest->u.FtpOpenFileW;
1465 ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
1466
1467 TRACE("%p\n", lpwfs);
1468
1469 FTP_FtpOpenFileW(lpwfs, req->lpszFilename,
1470 req->dwAccess, req->dwFlags, req->dwContext);
1471 heap_free(req->lpszFilename);
1472 }
1473
1474 /***********************************************************************
1475 * FtpOpenFileW (WININET.@)
1476 *
1477 * Open a remote file for writing or reading
1478 *
1479 * RETURNS
1480 * HINTERNET handle on success
1481 * NULL on failure
1482 *
1483 */
1484 HINTERNET WINAPI FtpOpenFileW(HINTERNET hFtpSession,
1485 LPCWSTR lpszFileName, DWORD fdwAccess, DWORD dwFlags,
1486 DWORD_PTR dwContext)
1487 {
1488 ftp_session_t *lpwfs;
1489 appinfo_t *hIC = NULL;
1490 HINTERNET r = NULL;
1491
1492 TRACE("(%p,%s,0x%08x,0x%08x,0x%08lx)\n", hFtpSession,
1493 debugstr_w(lpszFileName), fdwAccess, dwFlags, dwContext);
1494
1495 lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
1496 if (!lpwfs)
1497 {
1498 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1499 return FALSE;
1500 }
1501
1502 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1503 {
1504 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1505 goto lend;
1506 }
1507
1508 if ((!lpszFileName) ||
1509 ((fdwAccess != GENERIC_READ) && (fdwAccess != GENERIC_WRITE)) ||
1510 ((dwFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY))
1511 {
1512 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1513 goto lend;
1514 }
1515
1516 if (lpwfs->download_in_progress != NULL)
1517 {
1518 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1519 goto lend;
1520 }
1521
1522 hIC = lpwfs->lpAppInfo;
1523 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1524 {
1525 WORKREQUEST workRequest;
1526 struct WORKREQ_FTPOPENFILEW *req;
1527
1528 workRequest.asyncproc = AsyncFtpOpenFileProc;
1529 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1530 req = &workRequest.u.FtpOpenFileW;
1531 req->lpszFilename = heap_strdupW(lpszFileName);
1532 req->dwAccess = fdwAccess;
1533 req->dwFlags = dwFlags;
1534 req->dwContext = dwContext;
1535
1536 INTERNET_AsyncCall(&workRequest);
1537 r = NULL;
1538 }
1539 else
1540 {
1541 r = FTP_FtpOpenFileW(lpwfs, lpszFileName, fdwAccess, dwFlags, dwContext);
1542 }
1543
1544 lend:
1545 WININET_Release( &lpwfs->hdr );
1546
1547 return r;
1548 }
1549
1550
1551 /***********************************************************************
1552 * FtpGetFileA (WININET.@)
1553 *
1554 * Retrieve file from the FTP server
1555 *
1556 * RETURNS
1557 * TRUE on success
1558 * FALSE on failure
1559 *
1560 */
1561 BOOL WINAPI FtpGetFileA(HINTERNET hInternet, LPCSTR lpszRemoteFile, LPCSTR lpszNewFile,
1562 BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
1563 DWORD_PTR dwContext)
1564 {
1565 LPWSTR lpwzRemoteFile;
1566 LPWSTR lpwzNewFile;
1567 BOOL ret;
1568
1569 lpwzRemoteFile = heap_strdupAtoW(lpszRemoteFile);
1570 lpwzNewFile = heap_strdupAtoW(lpszNewFile);
1571 ret = FtpGetFileW(hInternet, lpwzRemoteFile, lpwzNewFile, fFailIfExists,
1572 dwLocalFlagsAttribute, dwInternetFlags, dwContext);
1573 heap_free(lpwzRemoteFile);
1574 heap_free(lpwzNewFile);
1575 return ret;
1576 }
1577
1578
1579 static void AsyncFtpGetFileProc(WORKREQUEST *workRequest)
1580 {
1581 struct WORKREQ_FTPGETFILEW const *req = &workRequest->u.FtpGetFileW;
1582 ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
1583
1584 TRACE("%p\n", lpwfs);
1585
1586 FTP_FtpGetFileW(lpwfs, req->lpszRemoteFile,
1587 req->lpszNewFile, req->fFailIfExists,
1588 req->dwLocalFlagsAttribute, req->dwFlags, req->dwContext);
1589 heap_free(req->lpszRemoteFile);
1590 heap_free(req->lpszNewFile);
1591 }
1592
1593
1594 /***********************************************************************
1595 * FtpGetFileW (WININET.@)
1596 *
1597 * Retrieve file from the FTP server
1598 *
1599 * RETURNS
1600 * TRUE on success
1601 * FALSE on failure
1602 *
1603 */
1604 BOOL WINAPI FtpGetFileW(HINTERNET hInternet, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile,
1605 BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
1606 DWORD_PTR dwContext)
1607 {
1608 ftp_session_t *lpwfs;
1609 appinfo_t *hIC = NULL;
1610 BOOL r = FALSE;
1611
1612 if (!lpszRemoteFile || !lpszNewFile)
1613 {
1614 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1615 return FALSE;
1616 }
1617
1618 lpwfs = (ftp_session_t*) get_handle_object( hInternet );
1619 if (!lpwfs)
1620 {
1621 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1622 return FALSE;
1623 }
1624
1625 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1626 {
1627 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1628 goto lend;
1629 }
1630
1631 if ((dwInternetFlags & FTP_CONDITION_MASK) > FTP_TRANSFER_TYPE_BINARY)
1632 {
1633 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1634 goto lend;
1635 }
1636
1637 if (lpwfs->download_in_progress != NULL)
1638 {
1639 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1640 goto lend;
1641 }
1642
1643 hIC = lpwfs->lpAppInfo;
1644 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1645 {
1646 WORKREQUEST workRequest;
1647 struct WORKREQ_FTPGETFILEW *req;
1648
1649 workRequest.asyncproc = AsyncFtpGetFileProc;
1650 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1651 req = &workRequest.u.FtpGetFileW;
1652 req->lpszRemoteFile = heap_strdupW(lpszRemoteFile);
1653 req->lpszNewFile = heap_strdupW(lpszNewFile);
1654 req->dwLocalFlagsAttribute = dwLocalFlagsAttribute;
1655 req->fFailIfExists = fFailIfExists;
1656 req->dwFlags = dwInternetFlags;
1657 req->dwContext = dwContext;
1658
1659 r = res_to_le(INTERNET_AsyncCall(&workRequest));
1660 }
1661 else
1662 {
1663 r = FTP_FtpGetFileW(lpwfs, lpszRemoteFile, lpszNewFile,
1664 fFailIfExists, dwLocalFlagsAttribute, dwInternetFlags, dwContext);
1665 }
1666
1667 lend:
1668 WININET_Release( &lpwfs->hdr );
1669
1670 return r;
1671 }
1672
1673
1674 /***********************************************************************
1675 * FTP_FtpGetFileW (Internal)
1676 *
1677 * Retrieve file from the FTP server
1678 *
1679 * RETURNS
1680 * TRUE on success
1681 * FALSE on failure
1682 *
1683 */
1684 static BOOL FTP_FtpGetFileW(ftp_session_t *lpwfs, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile,
1685 BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
1686 DWORD_PTR dwContext)
1687 {
1688 BOOL bSuccess = FALSE;
1689 HANDLE hFile;
1690 appinfo_t *hIC = NULL;
1691
1692 TRACE("lpszRemoteFile(%s) lpszNewFile(%s)\n", debugstr_w(lpszRemoteFile), debugstr_w(lpszNewFile));
1693
1694 /* Clear any error information */
1695 INTERNET_SetLastError(0);
1696
1697 /* Ensure we can write to lpszNewfile by opening it */
1698 hFile = CreateFileW(lpszNewFile, GENERIC_WRITE, 0, 0, fFailIfExists ?
1699 CREATE_NEW : CREATE_ALWAYS, dwLocalFlagsAttribute, 0);
1700 if (INVALID_HANDLE_VALUE == hFile)
1701 return FALSE;
1702
1703 /* Set up socket to retrieve data */
1704 if (FTP_SendRetrieve(lpwfs, lpszRemoteFile, dwInternetFlags))
1705 {
1706 INT nDataSocket;
1707
1708 /* Get data socket to server */
1709 if (FTP_GetDataSocket(lpwfs, &nDataSocket))
1710 {
1711 INT nResCode;
1712
1713 /* Receive data */
1714 FTP_RetrieveFileData(lpwfs, nDataSocket, hFile);
1715 closesocket(nDataSocket);
1716
1717 nResCode = FTP_ReceiveResponse(lpwfs, dwContext);
1718 if (nResCode)
1719 {
1720 if (nResCode == 226)
1721 bSuccess = TRUE;
1722 else
1723 FTP_SetResponseError(nResCode);
1724 }
1725 }
1726 }
1727
1728 if (lpwfs->lstnSocket != -1)
1729 {
1730 closesocket(lpwfs->lstnSocket);
1731 lpwfs->lstnSocket = -1;
1732 }
1733
1734 CloseHandle(hFile);
1735
1736 hIC = lpwfs->lpAppInfo;
1737 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1738 {
1739 INTERNET_ASYNC_RESULT iar;
1740
1741 iar.dwResult = (DWORD)bSuccess;
1742 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1743 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1744 &iar, sizeof(INTERNET_ASYNC_RESULT));
1745 }
1746
1747 if (!bSuccess) DeleteFileW(lpszNewFile);
1748 return bSuccess;
1749 }
1750
1751 /***********************************************************************
1752 * FtpGetFileSize (WININET.@)
1753 */
1754 DWORD WINAPI FtpGetFileSize( HINTERNET hFile, LPDWORD lpdwFileSizeHigh )
1755 {
1756 FIXME("(%p, %p)\n", hFile, lpdwFileSizeHigh);
1757
1758 if (lpdwFileSizeHigh)
1759 *lpdwFileSizeHigh = 0;
1760
1761 return 0;
1762 }
1763
1764 /***********************************************************************
1765 * FtpDeleteFileA (WININET.@)
1766 *
1767 * Delete a file on the ftp server
1768 *
1769 * RETURNS
1770 * TRUE on success
1771 * FALSE on failure
1772 *
1773 */
1774 BOOL WINAPI FtpDeleteFileA(HINTERNET hFtpSession, LPCSTR lpszFileName)
1775 {
1776 LPWSTR lpwzFileName;
1777 BOOL ret;
1778
1779 lpwzFileName = heap_strdupAtoW(lpszFileName);
1780 ret = FtpDeleteFileW(hFtpSession, lpwzFileName);
1781 heap_free(lpwzFileName);
1782 return ret;
1783 }
1784
1785 static void AsyncFtpDeleteFileProc(WORKREQUEST *workRequest)
1786 {
1787 struct WORKREQ_FTPDELETEFILEW const *req = &workRequest->u.FtpDeleteFileW;
1788 ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
1789
1790 TRACE("%p\n", lpwfs);
1791
1792 FTP_FtpDeleteFileW(lpwfs, req->lpszFilename);
1793 heap_free(req->lpszFilename);
1794 }
1795
1796 /***********************************************************************
1797 * FtpDeleteFileW (WININET.@)
1798 *
1799 * Delete a file on the ftp server
1800 *
1801 * RETURNS
1802 * TRUE on success
1803 * FALSE on failure
1804 *
1805 */
1806 BOOL WINAPI FtpDeleteFileW(HINTERNET hFtpSession, LPCWSTR lpszFileName)
1807 {
1808 ftp_session_t *lpwfs;
1809 appinfo_t *hIC = NULL;
1810 BOOL r = FALSE;
1811
1812 lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
1813 if (!lpwfs)
1814 {
1815 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1816 return FALSE;
1817 }
1818
1819 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1820 {
1821 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1822 goto lend;
1823 }
1824
1825 if (lpwfs->download_in_progress != NULL)
1826 {
1827 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1828 goto lend;
1829 }
1830
1831 if (!lpszFileName)
1832 {
1833 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1834 goto lend;
1835 }
1836
1837 hIC = lpwfs->lpAppInfo;
1838 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1839 {
1840 WORKREQUEST workRequest;
1841 struct WORKREQ_FTPDELETEFILEW *req;
1842
1843 workRequest.asyncproc = AsyncFtpDeleteFileProc;
1844 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1845 req = &workRequest.u.FtpDeleteFileW;
1846 req->lpszFilename = heap_strdupW(lpszFileName);
1847
1848 r = res_to_le(INTERNET_AsyncCall(&workRequest));
1849 }
1850 else
1851 {
1852 r = FTP_FtpDeleteFileW(lpwfs, lpszFileName);
1853 }
1854
1855 lend:
1856 WININET_Release( &lpwfs->hdr );
1857
1858 return r;
1859 }
1860
1861 /***********************************************************************
1862 * FTP_FtpDeleteFileW (Internal)
1863 *
1864 * Delete a file on the ftp server
1865 *
1866 * RETURNS
1867 * TRUE on success
1868 * FALSE on failure
1869 *
1870 */
1871 BOOL FTP_FtpDeleteFileW(ftp_session_t *lpwfs, LPCWSTR lpszFileName)
1872 {
1873 INT nResCode;
1874 BOOL bSuccess = FALSE;
1875 appinfo_t *hIC = NULL;
1876
1877 TRACE("%p\n", lpwfs);
1878
1879 /* Clear any error information */
1880 INTERNET_SetLastError(0);
1881
1882 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_DELE, lpszFileName, 0, 0, 0))
1883 goto lend;
1884
1885 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
1886 if (nResCode)
1887 {
1888 if (nResCode == 250)
1889 bSuccess = TRUE;
1890 else
1891 FTP_SetResponseError(nResCode);
1892 }
1893 lend:
1894 hIC = lpwfs->lpAppInfo;
1895 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1896 {
1897 INTERNET_ASYNC_RESULT iar;
1898
1899 iar.dwResult = (DWORD)bSuccess;
1900 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
1901 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
1902 &iar, sizeof(INTERNET_ASYNC_RESULT));
1903 }
1904
1905 return bSuccess;
1906 }
1907
1908
1909 /***********************************************************************
1910 * FtpRemoveDirectoryA (WININET.@)
1911 *
1912 * Remove a directory on the ftp server
1913 *
1914 * RETURNS
1915 * TRUE on success
1916 * FALSE on failure
1917 *
1918 */
1919 BOOL WINAPI FtpRemoveDirectoryA(HINTERNET hFtpSession, LPCSTR lpszDirectory)
1920 {
1921 LPWSTR lpwzDirectory;
1922 BOOL ret;
1923
1924 lpwzDirectory = heap_strdupAtoW(lpszDirectory);
1925 ret = FtpRemoveDirectoryW(hFtpSession, lpwzDirectory);
1926 heap_free(lpwzDirectory);
1927 return ret;
1928 }
1929
1930 static void AsyncFtpRemoveDirectoryProc(WORKREQUEST *workRequest)
1931 {
1932 struct WORKREQ_FTPREMOVEDIRECTORYW const *req = &workRequest->u.FtpRemoveDirectoryW;
1933 ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
1934
1935 TRACE("%p\n", lpwfs);
1936
1937 FTP_FtpRemoveDirectoryW(lpwfs, req->lpszDirectory);
1938 heap_free(req->lpszDirectory);
1939 }
1940
1941 /***********************************************************************
1942 * FtpRemoveDirectoryW (WININET.@)
1943 *
1944 * Remove a directory on the ftp server
1945 *
1946 * RETURNS
1947 * TRUE on success
1948 * FALSE on failure
1949 *
1950 */
1951 BOOL WINAPI FtpRemoveDirectoryW(HINTERNET hFtpSession, LPCWSTR lpszDirectory)
1952 {
1953 ftp_session_t *lpwfs;
1954 appinfo_t *hIC = NULL;
1955 BOOL r = FALSE;
1956
1957 lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
1958 if (!lpwfs)
1959 {
1960 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
1961 return FALSE;
1962 }
1963
1964 if (WH_HFTPSESSION != lpwfs->hdr.htype)
1965 {
1966 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
1967 goto lend;
1968 }
1969
1970 if (lpwfs->download_in_progress != NULL)
1971 {
1972 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
1973 goto lend;
1974 }
1975
1976 if (!lpszDirectory)
1977 {
1978 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1979 goto lend;
1980 }
1981
1982 hIC = lpwfs->lpAppInfo;
1983 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
1984 {
1985 WORKREQUEST workRequest;
1986 struct WORKREQ_FTPREMOVEDIRECTORYW *req;
1987
1988 workRequest.asyncproc = AsyncFtpRemoveDirectoryProc;
1989 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
1990 req = &workRequest.u.FtpRemoveDirectoryW;
1991 req->lpszDirectory = heap_strdupW(lpszDirectory);
1992
1993 r = res_to_le(INTERNET_AsyncCall(&workRequest));
1994 }
1995 else
1996 {
1997 r = FTP_FtpRemoveDirectoryW(lpwfs, lpszDirectory);
1998 }
1999
2000 lend:
2001 WININET_Release( &lpwfs->hdr );
2002
2003 return r;
2004 }
2005
2006 /***********************************************************************
2007 * FTP_FtpRemoveDirectoryW (Internal)
2008 *
2009 * Remove a directory on the ftp server
2010 *
2011 * RETURNS
2012 * TRUE on success
2013 * FALSE on failure
2014 *
2015 */
2016 BOOL FTP_FtpRemoveDirectoryW(ftp_session_t *lpwfs, LPCWSTR lpszDirectory)
2017 {
2018 INT nResCode;
2019 BOOL bSuccess = FALSE;
2020 appinfo_t *hIC = NULL;
2021
2022 TRACE("\n");
2023
2024 /* Clear any error information */
2025 INTERNET_SetLastError(0);
2026
2027 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RMD, lpszDirectory, 0, 0, 0))
2028 goto lend;
2029
2030 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2031 if (nResCode)
2032 {
2033 if (nResCode == 250)
2034 bSuccess = TRUE;
2035 else
2036 FTP_SetResponseError(nResCode);
2037 }
2038
2039 lend:
2040 hIC = lpwfs->lpAppInfo;
2041 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
2042 {
2043 INTERNET_ASYNC_RESULT iar;
2044
2045 iar.dwResult = (DWORD)bSuccess;
2046 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
2047 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
2048 &iar, sizeof(INTERNET_ASYNC_RESULT));
2049 }
2050
2051 return bSuccess;
2052 }
2053
2054
2055 /***********************************************************************
2056 * FtpRenameFileA (WININET.@)
2057 *
2058 * Rename a file on the ftp server
2059 *
2060 * RETURNS
2061 * TRUE on success
2062 * FALSE on failure
2063 *
2064 */
2065 BOOL WINAPI FtpRenameFileA(HINTERNET hFtpSession, LPCSTR lpszSrc, LPCSTR lpszDest)
2066 {
2067 LPWSTR lpwzSrc;
2068 LPWSTR lpwzDest;
2069 BOOL ret;
2070
2071 lpwzSrc = heap_strdupAtoW(lpszSrc);
2072 lpwzDest = heap_strdupAtoW(lpszDest);
2073 ret = FtpRenameFileW(hFtpSession, lpwzSrc, lpwzDest);
2074 heap_free(lpwzSrc);
2075 heap_free(lpwzDest);
2076 return ret;
2077 }
2078
2079 static void AsyncFtpRenameFileProc(WORKREQUEST *workRequest)
2080 {
2081 struct WORKREQ_FTPRENAMEFILEW const *req = &workRequest->u.FtpRenameFileW;
2082 ftp_session_t *lpwfs = (ftp_session_t*) workRequest->hdr;
2083
2084 TRACE("%p\n", lpwfs);
2085
2086 FTP_FtpRenameFileW(lpwfs, req->lpszSrcFile, req->lpszDestFile);
2087 heap_free(req->lpszSrcFile);
2088 heap_free(req->lpszDestFile);
2089 }
2090
2091 /***********************************************************************
2092 * FtpRenameFileW (WININET.@)
2093 *
2094 * Rename a file on the ftp server
2095 *
2096 * RETURNS
2097 * TRUE on success
2098 * FALSE on failure
2099 *
2100 */
2101 BOOL WINAPI FtpRenameFileW(HINTERNET hFtpSession, LPCWSTR lpszSrc, LPCWSTR lpszDest)
2102 {
2103 ftp_session_t *lpwfs;
2104 appinfo_t *hIC = NULL;
2105 BOOL r = FALSE;
2106
2107 lpwfs = (ftp_session_t*) get_handle_object( hFtpSession );
2108 if (!lpwfs)
2109 {
2110 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
2111 return FALSE;
2112 }
2113
2114 if (WH_HFTPSESSION != lpwfs->hdr.htype)
2115 {
2116 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
2117 goto lend;
2118 }
2119
2120 if (lpwfs->download_in_progress != NULL)
2121 {
2122 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
2123 goto lend;
2124 }
2125
2126 if (!lpszSrc || !lpszDest)
2127 {
2128 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2129 goto lend;
2130 }
2131
2132 hIC = lpwfs->lpAppInfo;
2133 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
2134 {
2135 WORKREQUEST workRequest;
2136 struct WORKREQ_FTPRENAMEFILEW *req;
2137
2138 workRequest.asyncproc = AsyncFtpRenameFileProc;
2139 workRequest.hdr = WININET_AddRef( &lpwfs->hdr );
2140 req = &workRequest.u.FtpRenameFileW;
2141 req->lpszSrcFile = heap_strdupW(lpszSrc);
2142 req->lpszDestFile = heap_strdupW(lpszDest);
2143
2144 r = res_to_le(INTERNET_AsyncCall(&workRequest));
2145 }
2146 else
2147 {
2148 r = FTP_FtpRenameFileW(lpwfs, lpszSrc, lpszDest);
2149 }
2150
2151 lend:
2152 WININET_Release( &lpwfs->hdr );
2153
2154 return r;
2155 }
2156
2157 /***********************************************************************
2158 * FTP_FtpRenameFileW (Internal)
2159 *
2160 * Rename a file on the ftp server
2161 *
2162 * RETURNS
2163 * TRUE on success
2164 * FALSE on failure
2165 *
2166 */
2167 BOOL FTP_FtpRenameFileW(ftp_session_t *lpwfs, LPCWSTR lpszSrc, LPCWSTR lpszDest)
2168 {
2169 INT nResCode;
2170 BOOL bSuccess = FALSE;
2171 appinfo_t *hIC = NULL;
2172
2173 TRACE("\n");
2174
2175 /* Clear any error information */
2176 INTERNET_SetLastError(0);
2177
2178 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNFR, lpszSrc, 0, 0, 0))
2179 goto lend;
2180
2181 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2182 if (nResCode == 350)
2183 {
2184 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RNTO, lpszDest, 0, 0, 0))
2185 goto lend;
2186
2187 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2188 }
2189
2190 if (nResCode == 250)
2191 bSuccess = TRUE;
2192 else
2193 FTP_SetResponseError(nResCode);
2194
2195 lend:
2196 hIC = lpwfs->lpAppInfo;
2197 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
2198 {
2199 INTERNET_ASYNC_RESULT iar;
2200
2201 iar.dwResult = (DWORD)bSuccess;
2202 iar.dwError = bSuccess ? ERROR_SUCCESS : INTERNET_GetLastError();
2203 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext, INTERNET_STATUS_REQUEST_COMPLETE,
2204 &iar, sizeof(INTERNET_ASYNC_RESULT));
2205 }
2206
2207 return bSuccess;
2208 }
2209
2210 /***********************************************************************
2211 * FtpCommandA (WININET.@)
2212 */
2213 BOOL WINAPI FtpCommandA( HINTERNET hConnect, BOOL fExpectResponse, DWORD dwFlags,
2214 LPCSTR lpszCommand, DWORD_PTR dwContext, HINTERNET* phFtpCommand )
2215 {
2216 BOOL r;
2217 WCHAR *cmdW;
2218
2219 TRACE("%p %d 0x%08x %s 0x%08lx %p\n", hConnect, fExpectResponse, dwFlags,
2220 debugstr_a(lpszCommand), dwContext, phFtpCommand);
2221
2222 if (fExpectResponse)
2223 {
2224 FIXME("data connection not supported\n");
2225 return FALSE;
2226 }
2227
2228 if (!lpszCommand || !lpszCommand[0])
2229 {
2230 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2231 return FALSE;
2232 }
2233
2234 if (!(cmdW = heap_strdupAtoW(lpszCommand)))
2235 {
2236 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2237 return FALSE;
2238 }
2239
2240 r = FtpCommandW(hConnect, fExpectResponse, dwFlags, cmdW, dwContext, phFtpCommand);
2241
2242 heap_free(cmdW);
2243 return r;
2244 }
2245
2246 /***********************************************************************
2247 * FtpCommandW (WININET.@)
2248 */
2249 BOOL WINAPI FtpCommandW( HINTERNET hConnect, BOOL fExpectResponse, DWORD dwFlags,
2250 LPCWSTR lpszCommand, DWORD_PTR dwContext, HINTERNET* phFtpCommand )
2251 {
2252 BOOL r = FALSE;
2253 ftp_session_t *lpwfs;
2254 LPSTR cmd = NULL;
2255 DWORD len, nBytesSent= 0;
2256 INT nResCode, nRC = 0;
2257
2258 TRACE("%p %d 0x%08x %s 0x%08lx %p\n", hConnect, fExpectResponse, dwFlags,
2259 debugstr_w(lpszCommand), dwContext, phFtpCommand);
2260
2261 if (!lpszCommand || !lpszCommand[0])
2262 {
2263 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2264 return FALSE;
2265 }
2266
2267 if (fExpectResponse)
2268 {
2269 FIXME("data connection not supported\n");
2270 return FALSE;
2271 }
2272
2273 lpwfs = (ftp_session_t*) get_handle_object( hConnect );
2274 if (!lpwfs)
2275 {
2276 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
2277 return FALSE;
2278 }
2279
2280 if (WH_HFTPSESSION != lpwfs->hdr.htype)
2281 {
2282 INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
2283 goto lend;
2284 }
2285
2286 if (lpwfs->download_in_progress != NULL)
2287 {
2288 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
2289 goto lend;
2290 }
2291
2292 len = WideCharToMultiByte(CP_ACP, 0, lpszCommand, -1, NULL, 0, NULL, NULL) + strlen(szCRLF);
2293 if ((cmd = heap_alloc(len)))
2294 WideCharToMultiByte(CP_ACP, 0, lpszCommand, -1, cmd, len, NULL, NULL);
2295 else
2296 {
2297 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2298 goto lend;
2299 }
2300
2301 strcat(cmd, szCRLF);
2302 len--;
2303
2304 TRACE("Sending (%s) len(%d)\n", cmd, len);
2305 while ((nBytesSent < len) && (nRC != -1))
2306 {
2307 nRC = send(lpwfs->sndSocket, cmd + nBytesSent, len - nBytesSent, 0);
2308 if (nRC != -1)
2309 {
2310 nBytesSent += nRC;
2311 TRACE("Sent %d bytes\n", nRC);
2312 }
2313 }
2314
2315 if (nBytesSent)
2316 {
2317 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2318 if (nResCode > 0 && nResCode < 400)
2319 r = TRUE;
2320 else
2321 FTP_SetResponseError(nResCode);
2322 }
2323
2324 lend:
2325 WININET_Release( &lpwfs->hdr );
2326 heap_free( cmd );
2327 return r;
2328 }
2329
2330
2331 /***********************************************************************
2332 * FTPSESSION_Destroy (internal)
2333 *
2334 * Deallocate session handle
2335 */
2336 static void FTPSESSION_Destroy(object_header_t *hdr)
2337 {
2338 ftp_session_t *lpwfs = (ftp_session_t*) hdr;
2339
2340 TRACE("\n");
2341
2342 WININET_Release(&lpwfs->lpAppInfo->hdr);
2343
2344 heap_free(lpwfs->lpszPassword);
2345 heap_free(lpwfs->lpszUserName);
2346 heap_free(lpwfs->servername);
2347 }
2348
2349 static void FTPSESSION_CloseConnection(object_header_t *hdr)
2350 {
2351 ftp_session_t *lpwfs = (ftp_session_t*) hdr;
2352
2353 TRACE("\n");
2354
2355 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext,
2356 INTERNET_STATUS_CLOSING_CONNECTION, 0, 0);
2357
2358 if (lpwfs->download_in_progress != NULL)
2359 lpwfs->download_in_progress->session_deleted = TRUE;
2360
2361 if (lpwfs->sndSocket != -1)
2362 closesocket(lpwfs->sndSocket);
2363
2364 if (lpwfs->lstnSocket != -1)
2365 closesocket(lpwfs->lstnSocket);
2366
2367 if (lpwfs->pasvSocket != -1)
2368 closesocket(lpwfs->pasvSocket);
2369
2370 SendAsyncCallback(&lpwfs->hdr, lpwfs->hdr.dwContext,
2371 INTERNET_STATUS_CONNECTION_CLOSED, 0, 0);
2372 }
2373
2374 static DWORD FTPSESSION_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
2375 {
2376 switch(option) {
2377 case INTERNET_OPTION_HANDLE_TYPE:
2378 TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
2379
2380 if (*size < sizeof(ULONG))
2381 return ERROR_INSUFFICIENT_BUFFER;
2382
2383 *size = sizeof(DWORD);
2384 *(DWORD*)buffer = INTERNET_HANDLE_TYPE_CONNECT_FTP;
2385 return ERROR_SUCCESS;
2386 }
2387
2388 return INET_QueryOption(hdr, option, buffer, size, unicode);
2389 }
2390
2391 static const object_vtbl_t FTPSESSIONVtbl = {
2392 FTPSESSION_Destroy,
2393 FTPSESSION_CloseConnection,
2394 FTPSESSION_QueryOption,
2395 NULL,
2396 NULL,
2397 NULL,
2398 NULL,
2399 NULL,
2400 NULL
2401 };
2402
2403
2404 /***********************************************************************
2405 * FTP_Connect (internal)
2406 *
2407 * Connect to a ftp server
2408 *
2409 * RETURNS
2410 * HINTERNET a session handle on success
2411 * NULL on failure
2412 *
2413 * NOTES:
2414 *
2415 * Windows uses 'anonymous' as the username, when given a NULL username
2416 * and a NULL password. The password is first looked up in:
2417 *
2418 * HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings\EmailName
2419 *
2420 * If this entry is not present it uses the current username as the password.
2421 *
2422 */
2423
2424 HINTERNET FTP_Connect(appinfo_t *hIC, LPCWSTR lpszServerName,
2425 INTERNET_PORT nServerPort, LPCWSTR lpszUserName,
2426 LPCWSTR lpszPassword, DWORD dwFlags, DWORD_PTR dwContext,
2427 DWORD dwInternalFlags)
2428 {
2429 static const WCHAR szKey[] = {'S','o','f','t','w','a','r','e','\\',
2430 'M','i','c','r','o','s','o','f','t','\\',
2431 'W','i','n','d','o','w','s','\\',
2432 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2433 'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s',0};
2434 static const WCHAR szValue[] = {'E','m','a','i','l','N','a','m','e',0};
2435 static const WCHAR szDefaultUsername[] = {'a','n','o','n','y','m','o','u','s','\0'};
2436 static const WCHAR szEmpty[] = {'\0'};
2437 struct sockaddr_in socketAddr;
2438 INT nsocket = -1;
2439 UINT sock_namelen;
2440 BOOL bSuccess = FALSE;
2441 ftp_session_t *lpwfs = NULL;
2442 char szaddr[INET_ADDRSTRLEN];
2443
2444 TRACE("%p Server(%s) Port(%d) User(%s) Paswd(%s)\n",
2445 hIC, debugstr_w(lpszServerName),
2446 nServerPort, debugstr_w(lpszUserName), debugstr_w(lpszPassword));
2447
2448 assert( hIC->hdr.htype == WH_HINIT );
2449
2450 if ((!lpszUserName || !*lpszUserName) && lpszPassword && *lpszPassword)
2451 {
2452 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2453 return NULL;
2454 }
2455
2456 lpwfs = alloc_object(&hIC->hdr, &FTPSESSIONVtbl, sizeof(ftp_session_t));
2457 if (NULL == lpwfs)
2458 {
2459 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2460 return NULL;
2461 }
2462
2463 if (nServerPort == INTERNET_INVALID_PORT_NUMBER)
2464 lpwfs->serverport = INTERNET_DEFAULT_FTP_PORT;
2465 else
2466 lpwfs->serverport = nServerPort;
2467
2468 lpwfs->hdr.htype = WH_HFTPSESSION;
2469 lpwfs->hdr.dwFlags = dwFlags;
2470 lpwfs->hdr.dwContext = dwContext;
2471 lpwfs->hdr.dwInternalFlags |= dwInternalFlags;
2472 lpwfs->download_in_progress = NULL;
2473 lpwfs->sndSocket = -1;
2474 lpwfs->lstnSocket = -1;
2475 lpwfs->pasvSocket = -1;
2476
2477 WININET_AddRef( &hIC->hdr );
2478 lpwfs->lpAppInfo = hIC;
2479 list_add_head( &hIC->hdr.children, &lpwfs->hdr.entry );
2480
2481 if(hIC->proxy && hIC->accessType == INTERNET_OPEN_TYPE_PROXY) {
2482 if(strchrW(hIC->proxy, ' '))
2483 FIXME("Several proxies not implemented.\n");
2484 if(hIC->proxyBypass)
2485 FIXME("Proxy bypass is ignored.\n");
2486 }
2487 if (!lpszUserName || !strlenW(lpszUserName)) {
2488 HKEY key;
2489 WCHAR szPassword[MAX_PATH];
2490 DWORD len = sizeof(szPassword);
2491
2492 lpwfs->lpszUserName = heap_strdupW(szDefaultUsername);
2493
2494 RegOpenKeyW(HKEY_CURRENT_USER, szKey, &key);
2495 if (RegQueryValueExW(key, szValue, NULL, NULL, (LPBYTE)szPassword, &len)) {
2496 /* Nothing in the registry, get the username and use that as the password */
2497 if (!GetUserNameW(szPassword, &len)) {
2498 /* Should never get here, but use an empty password as failsafe */
2499 strcpyW(szPassword, szEmpty);
2500 }
2501 }
2502 RegCloseKey(key);
2503
2504 TRACE("Password used for anonymous ftp : (%s)\n", debugstr_w(szPassword));
2505 lpwfs->lpszPassword = heap_strdupW(szPassword);
2506 }
2507 else {
2508 lpwfs->lpszUserName = heap_strdupW(lpszUserName);
2509 lpwfs->lpszPassword = heap_strdupW(lpszPassword ? lpszPassword : szEmpty);
2510 }
2511 lpwfs->servername = heap_strdupW(lpszServerName);
2512
2513 /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
2514 if (!(lpwfs->hdr.dwInternalFlags & INET_OPENURL))
2515 {
2516 INTERNET_ASYNC_RESULT iar;
2517
2518 iar.dwResult = (DWORD_PTR)lpwfs->hdr.hInternet;
2519 iar.dwError = ERROR_SUCCESS;
2520
2521 SendAsyncCallback(&hIC->hdr, dwContext,
2522 INTERNET_STATUS_HANDLE_CREATED, &iar,
2523 sizeof(INTERNET_ASYNC_RESULT));
2524 }
2525
2526 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_RESOLVING_NAME,
2527 (LPWSTR) lpszServerName, (strlenW(lpszServerName)+1) * sizeof(WCHAR));
2528
2529 sock_namelen = sizeof(socketAddr);
2530 if (!GetAddress(lpszServerName, lpwfs->serverport, (struct sockaddr *)&socketAddr, &sock_namelen))
2531 {
2532 INTERNET_SetLastError(ERROR_INTERNET_NAME_NOT_RESOLVED);
2533 goto lerror;
2534 }
2535
2536 if (socketAddr.sin_family != AF_INET)
2537 {
2538 WARN("unsupported address family %d\n", socketAddr.sin_family);
2539 INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
2540 goto lerror;
2541 }
2542
2543 inet_ntop(socketAddr.sin_family, &socketAddr.sin_addr, szaddr, sizeof(szaddr));
2544 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_NAME_RESOLVED,
2545 szaddr, strlen(szaddr)+1);
2546
2547 nsocket = socket(AF_INET,SOCK_STREAM,0);
2548 if (nsocket == -1)
2549 {
2550 INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
2551 goto lerror;
2552 }
2553
2554 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTING_TO_SERVER,
2555 szaddr, strlen(szaddr)+1);
2556
2557 if (connect(nsocket, (struct sockaddr *)&socketAddr, sock_namelen) < 0)
2558 {
2559 ERR("Unable to connect (%s)\n", strerror(errno));
2560 INTERNET_SetLastError(ERROR_INTERNET_CANNOT_CONNECT);
2561 closesocket(nsocket);
2562 }
2563 else
2564 {
2565 TRACE("Connected to server\n");
2566 lpwfs->sndSocket = nsocket;
2567 SendAsyncCallback(&hIC->hdr, dwContext, INTERNET_STATUS_CONNECTED_TO_SERVER,
2568 szaddr, strlen(szaddr)+1);
2569
2570 sock_namelen = sizeof(lpwfs->socketAddress);
2571 getsockname(nsocket, (struct sockaddr *) &lpwfs->socketAddress, &sock_namelen);
2572
2573 if (FTP_ConnectToHost(lpwfs))
2574 {
2575 TRACE("Successfully logged into server\n");
2576 bSuccess = TRUE;
2577 }
2578 }
2579
2580 lerror:
2581 if (!bSuccess)
2582 {
2583 if(lpwfs)
2584 WININET_Release( &lpwfs->hdr );
2585 return NULL;
2586 }
2587
2588 return lpwfs->hdr.hInternet;
2589 }
2590
2591
2592 /***********************************************************************
2593 * FTP_ConnectToHost (internal)
2594 *
2595 * Connect to a ftp server
2596 *
2597 * RETURNS
2598 * TRUE on success
2599 * NULL on failure
2600 *
2601 */
2602 static BOOL FTP_ConnectToHost(ftp_session_t *lpwfs)
2603 {
2604 INT nResCode;
2605 BOOL bSuccess = FALSE;
2606
2607 TRACE("\n");
2608 FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2609
2610 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_USER, lpwfs->lpszUserName, 0, 0, 0))
2611 goto lend;
2612
2613 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2614 if (nResCode)
2615 {
2616 /* Login successful... */
2617 if (nResCode == 230)
2618 bSuccess = TRUE;
2619 /* User name okay, need password... */
2620 else if (nResCode == 331)
2621 bSuccess = FTP_SendPassword(lpwfs);
2622 /* Need account for login... */
2623 else if (nResCode == 332)
2624 bSuccess = FTP_SendAccount(lpwfs);
2625 else
2626 FTP_SetResponseError(nResCode);
2627 }
2628
2629 TRACE("Returning %d\n", bSuccess);
2630 lend:
2631 return bSuccess;
2632 }
2633
2634
2635 /***********************************************************************
2636 * FTP_SendCommandA (internal)
2637 *
2638 * Send command to server
2639 *
2640 * RETURNS
2641 * TRUE on success
2642 * NULL on failure
2643 *
2644 */
2645 static BOOL FTP_SendCommandA(INT nSocket, FTP_COMMAND ftpCmd, LPCSTR lpszParam,
2646 INTERNET_STATUS_CALLBACK lpfnStatusCB, object_header_t *hdr, DWORD_PTR dwContext)
2647 {
2648 DWORD len;
2649 CHAR *buf;
2650 DWORD nBytesSent = 0;
2651 int nRC = 0;
2652 DWORD dwParamLen;
2653
2654 TRACE("%d: (%s) %d\n", ftpCmd, lpszParam, nSocket);
2655
2656 if (lpfnStatusCB)
2657 {
2658 lpfnStatusCB(hdr->hInternet, dwContext, INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
2659 }
2660
2661 dwParamLen = lpszParam?strlen(lpszParam)+1:0;
2662 len = dwParamLen + strlen(szFtpCommands[ftpCmd]) + strlen(szCRLF);
2663 if (NULL == (buf = heap_alloc(len+1)))
2664 {
2665 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
2666 return FALSE;
2667 }
2668 sprintf(buf, "%s%s%s%s", szFtpCommands[ftpCmd], dwParamLen ? " " : "",
2669 dwParamLen ? lpszParam : "", szCRLF);
2670
2671 TRACE("Sending (%s) len(%d)\n", buf, len);
2672 while((nBytesSent < len) && (nRC != -1))
2673 {
2674 nRC = send(nSocket, buf+nBytesSent, len - nBytesSent, 0);
2675 nBytesSent += nRC;
2676 }
2677 heap_free(buf);
2678
2679 if (lpfnStatusCB)
2680 {
2681 lpfnStatusCB(hdr->hInternet, dwContext, INTERNET_STATUS_REQUEST_SENT,
2682 &nBytesSent, sizeof(DWORD));
2683 }
2684
2685 TRACE("Sent %d bytes\n", nBytesSent);
2686 return (nRC != -1);
2687 }
2688
2689 /***********************************************************************
2690 * FTP_SendCommand (internal)
2691 *
2692 * Send command to server
2693 *
2694 * RETURNS
2695 * TRUE on success
2696 * NULL on failure
2697 *
2698 */
2699 static BOOL FTP_SendCommand(INT nSocket, FTP_COMMAND ftpCmd, LPCWSTR lpszParam,
2700 INTERNET_STATUS_CALLBACK lpfnStatusCB, object_header_t *hdr, DWORD_PTR dwContext)
2701 {
2702 BOOL ret;
2703 LPSTR lpszParamA = heap_strdupWtoA(lpszParam);
2704 ret = FTP_SendCommandA(nSocket, ftpCmd, lpszParamA, lpfnStatusCB, hdr, dwContext);
2705 heap_free(lpszParamA);
2706 return ret;
2707 }
2708
2709 /***********************************************************************
2710 * FTP_ReceiveResponse (internal)
2711 *
2712 * Receive response from server
2713 *
2714 * RETURNS
2715 * Reply code on success
2716 * 0 on failure
2717 *
2718 */
2719 INT FTP_ReceiveResponse(ftp_session_t *lpwfs, DWORD_PTR dwContext)
2720 {
2721 LPSTR lpszResponse = INTERNET_GetResponseBuffer();
2722 DWORD nRecv;
2723 INT rc = 0;
2724 char firstprefix[5];
2725 BOOL multiline = FALSE;
2726
2727 TRACE("socket(%d)\n", lpwfs->sndSocket);
2728
2729 SendAsyncCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
2730
2731 while(1)
2732 {
2733 if (!INTERNET_GetNextLine(lpwfs->sndSocket, &nRecv))
2734 goto lerror;
2735
2736 if (nRecv >= 3)
2737 {
2738 if(!multiline)
2739 {
2740 if(lpszResponse[3] != '-')
2741 break;
2742 else
2743 { /* Start of multiline response. Loop until we get "nnn " */
2744 multiline = TRUE;
2745 memcpy(firstprefix, lpszResponse, 3);
2746 firstprefix[3] = ' ';
2747 firstprefix[4] = '\0';
2748 }
2749 }
2750 else
2751 {
2752 if(!memcmp(firstprefix, lpszResponse, 4))
2753 break;
2754 }
2755 }
2756 }
2757
2758 if (nRecv >= 3)
2759 {
2760 rc = atoi(lpszResponse);
2761
2762 SendAsyncCallback(&lpwfs->hdr, dwContext, INTERNET_STATUS_RESPONSE_RECEIVED,
2763 &nRecv, sizeof(DWORD));
2764 }
2765
2766 lerror:
2767 TRACE("return %d\n", rc);
2768 return rc;
2769 }
2770
2771
2772 /***********************************************************************
2773 * FTP_SendPassword (internal)
2774 *
2775 * Send password to ftp server
2776 *
2777 * RETURNS
2778 * TRUE on success
2779 * NULL on failure
2780 *
2781 */
2782 static BOOL FTP_SendPassword(ftp_session_t *lpwfs)
2783 {
2784 INT nResCode;
2785 BOOL bSuccess = FALSE;
2786
2787 TRACE("\n");
2788 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASS, lpwfs->lpszPassword, 0, 0, 0))
2789 goto lend;
2790
2791 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2792 if (nResCode)
2793 {
2794 TRACE("Received reply code %d\n", nResCode);
2795 /* Login successful... */
2796 if (nResCode == 230)
2797 bSuccess = TRUE;
2798 /* Command not implemented, superfluous at the server site... */
2799 /* Need account for login... */
2800 else if (nResCode == 332)
2801 bSuccess = FTP_SendAccount(lpwfs);
2802 else
2803 FTP_SetResponseError(nResCode);
2804 }
2805
2806 lend:
2807 TRACE("Returning %d\n", bSuccess);
2808 return bSuccess;
2809 }
2810
2811
2812 /***********************************************************************
2813 * FTP_SendAccount (internal)
2814 *
2815 *
2816 *
2817 * RETURNS
2818 * TRUE on success
2819 * FALSE on failure
2820 *
2821 */
2822 static BOOL FTP_SendAccount(ftp_session_t *lpwfs)
2823 {
2824 INT nResCode;
2825 BOOL bSuccess = FALSE;
2826
2827 TRACE("\n");
2828 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_ACCT, szNoAccount, 0, 0, 0))
2829 goto lend;
2830
2831 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2832 if (nResCode)
2833 bSuccess = TRUE;
2834 else
2835 FTP_SetResponseError(nResCode);
2836
2837 lend:
2838 return bSuccess;
2839 }
2840
2841
2842 /***********************************************************************
2843 * FTP_SendStore (internal)
2844 *
2845 * Send request to upload file to ftp server
2846 *
2847 * RETURNS
2848 * TRUE on success
2849 * FALSE on failure
2850 *
2851 */
2852 static BOOL FTP_SendStore(ftp_session_t *lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType)
2853 {
2854 INT nResCode;
2855 BOOL bSuccess = FALSE;
2856
2857 TRACE("\n");
2858 if (!FTP_InitListenSocket(lpwfs))
2859 goto lend;
2860
2861 if (!FTP_SendType(lpwfs, dwType))
2862 goto lend;
2863
2864 if (!FTP_SendPortOrPasv(lpwfs))
2865 goto lend;
2866
2867 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_STOR, lpszRemoteFile, 0, 0, 0))
2868 goto lend;
2869 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
2870 if (nResCode)
2871 {
2872 if (nResCode == 150 || nResCode == 125)
2873 bSuccess = TRUE;
2874 else
2875 FTP_SetResponseError(nResCode);
2876 }
2877
2878 lend:
2879 if (!bSuccess && lpwfs->lstnSocket != -1)
2880 {
2881 closesocket(lpwfs->lstnSocket);
2882 lpwfs->lstnSocket = -1;
2883 }
2884
2885 return bSuccess;
2886 }
2887
2888
2889 /***********************************************************************
2890 * FTP_InitListenSocket (internal)
2891 *
2892 * Create a socket to listen for server response
2893 *
2894 * RETURNS
2895 * TRUE on success
2896 * FALSE on failure
2897 *
2898 */
2899 static BOOL FTP_InitListenSocket(ftp_session_t *lpwfs)
2900 {
2901 BOOL bSuccess = FALSE;
2902 socklen_t namelen = sizeof(lpwfs->lstnSocketAddress);
2903
2904 TRACE("\n");
2905
2906 lpwfs->lstnSocket = socket(PF_INET, SOCK_STREAM, 0);
2907 if (lpwfs->lstnSocket == -1)
2908 {
2909 TRACE("Unable to create listening socket\n");
2910 goto lend;
2911 }
2912
2913 /* We obtain our ip addr from the name of the command channel socket */
2914 lpwfs->lstnSocketAddress = lpwfs->socketAddress;
2915
2916 /* and get the system to assign us a port */
2917 lpwfs->lstnSocketAddress.sin_port = htons(0);
2918
2919 if (bind(lpwfs->lstnSocket,(struct sockaddr *) &lpwfs->lstnSocketAddress, sizeof(lpwfs->lstnSocketAddress)) == -1)
2920 {
2921 TRACE("Unable to bind socket\n");
2922 goto lend;
2923 }
2924
2925 if (listen(lpwfs->lstnSocket, MAX_BACKLOG) == -1)
2926 {
2927 TRACE("listen failed\n");
2928 goto lend;
2929 }
2930
2931 if (getsockname(lpwfs->lstnSocket, (struct sockaddr *) &lpwfs->lstnSocketAddress, &namelen) != -1)
2932 bSuccess = TRUE;
2933
2934 lend:
2935 if (!bSuccess && lpwfs->lstnSocket != -1)
2936 {
2937 closesocket(lpwfs->lstnSocket);
2938 lpwfs->lstnSocket = -1;
2939 }
2940
2941 return bSuccess;
2942 }
2943
2944
2945 /***********************************************************************
2946 * FTP_SendType (internal)
2947 *
2948 * Tell server type of data being transferred
2949 *
2950 * RETURNS
2951 * TRUE on success
2952 * FALSE on failure
2953 *
2954 * W98SE doesn't cache the type that's currently set
2955 * (i.e. it sends it always),
2956 * so we probably don't want to do that either.
2957 */
2958 static BOOL FTP_SendType(ftp_session_t *lpwfs, DWORD dwType)
2959 {
2960 INT nResCode;
2961 WCHAR type[] = { 'I','\0' };
2962 BOOL bSuccess = FALSE;
2963
2964 TRACE("\n");
2965 if (dwType & INTERNET_FLAG_TRANSFER_ASCII)
2966 type[0] = 'A';
2967
2968 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_TYPE, type, 0, 0, 0))
2969 goto lend;
2970
2971 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext)/100;
2972 if (nResCode)
2973 {
2974 if (nResCode == 2)
2975 bSuccess = TRUE;
2976 else
2977 FTP_SetResponseError(nResCode);
2978 }
2979
2980 lend:
2981 return bSuccess;
2982 }
2983
2984
2985 #if 0 /* FIXME: should probably be used for FtpGetFileSize */
2986 /***********************************************************************
2987 * FTP_GetFileSize (internal)
2988 *
2989 * Retrieves from the server the size of the given file
2990 *
2991 * RETURNS
2992 * TRUE on success
2993 * FALSE on failure
2994 *
2995 */
2996 static BOOL FTP_GetFileSize(ftp_session_t *lpwfs, LPCWSTR lpszRemoteFile, DWORD *dwSize)
2997 {
2998 INT nResCode;
2999 BOOL bSuccess = FALSE;
3000
3001 TRACE("\n");
3002
3003 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_SIZE, lpszRemoteFile, 0, 0, 0))
3004 goto lend;
3005
3006 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
3007 if (nResCode)
3008 {
3009 if (nResCode == 213) {
3010 /* Now parses the output to get the actual file size */
3011 int i;
3012 LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
3013
3014 for (i = 0; (lpszResponseBuffer[i] != ' ') && (lpszResponseBuffer[i] != '\0'); i++) ;
3015 if (lpszResponseBuffer[i] == '\0') return FALSE;
3016 *dwSize = atol(&(lpszResponseBuffer[i + 1]));
3017
3018 bSuccess = TRUE;
3019 } else {
3020 FTP_SetResponseError(nResCode);
3021 }
3022 }
3023
3024 lend:
3025 return bSuccess;
3026 }
3027 #endif
3028
3029
3030 /***********************************************************************
3031 * FTP_SendPort (internal)
3032 *
3033 * Tell server which port to use
3034 *
3035 * RETURNS
3036 * TRUE on success
3037 * FALSE on failure
3038 *
3039 */
3040 static BOOL FTP_SendPort(ftp_session_t *lpwfs)
3041 {
3042 static const WCHAR szIPFormat[] = {'%','d',',','%','d',',','%','d',',','%','d',',','%','d',',','%','d','\0'};
3043 INT nResCode;
3044 WCHAR szIPAddress[64];
3045 BOOL bSuccess = FALSE;
3046 TRACE("\n");
3047
3048 sprintfW(szIPAddress, szIPFormat,
3049 lpwfs->lstnSocketAddress.sin_addr.s_addr&0x000000FF,
3050 (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x0000FF00)>>8,
3051 (lpwfs->lstnSocketAddress.sin_addr.s_addr&0x00FF0000)>>16,
3052 (lpwfs->lstnSocketAddress.sin_addr.s_addr&0xFF000000)>>24,
3053 lpwfs->lstnSocketAddress.sin_port & 0xFF,
3054 (lpwfs->lstnSocketAddress.sin_port & 0xFF00)>>8);
3055
3056 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PORT, szIPAddress, 0, 0, 0))
3057 goto lend;
3058
3059 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
3060 if (nResCode)
3061 {
3062 if (nResCode == 200)
3063 bSuccess = TRUE;
3064 else
3065 FTP_SetResponseError(nResCode);
3066 }
3067
3068 lend:
3069 return bSuccess;
3070 }
3071
3072
3073 /***********************************************************************
3074 * FTP_DoPassive (internal)
3075 *
3076 * Tell server that we want to do passive transfers
3077 * and connect data socket
3078 *
3079 * RETURNS
3080 * TRUE on success
3081 * FALSE on failure
3082 *
3083 */
3084 static BOOL FTP_DoPassive(ftp_session_t *lpwfs)
3085 {
3086 INT nResCode;
3087 BOOL bSuccess = FALSE;
3088
3089 TRACE("\n");
3090 if (!FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_PASV, NULL, 0, 0, 0))
3091 goto lend;
3092
3093 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
3094 if (nResCode)
3095 {
3096 if (nResCode == 227)
3097 {
3098 LPSTR lpszResponseBuffer = INTERNET_GetResponseBuffer();
3099 LPSTR p;
3100 int f[6];
3101 int i;
3102 char *pAddr, *pPort;
3103 INT nsocket = -1;
3104 struct sockaddr_in dataSocketAddress;
3105
3106 p = lpszResponseBuffer+4; /* skip status code */
3107 while (*p != '\0' && (*p < '0' || *p > '9')) p++;
3108
3109 if (*p == '\0')
3110 {
3111 ERR("no address found in response, aborting\n");
3112 goto lend;
3113 }
3114
3115 if (sscanf(p, "%d,%d,%d,%d,%d,%d", &f[0], &f[1], &f[2], &f[3],
3116 &f[4], &f[5]) != 6)
3117 {
3118 ERR("unknown response address format '%s', aborting\n", p);
3119 goto lend;
3120 }
3121 for (i=0; i < 6; i++)
3122 f[i] = f[i] & 0xff;
3123
3124 dataSocketAddress = lpwfs->socketAddress;
3125 pAddr = (char *)&(dataSocketAddress.sin_addr.s_addr);
3126 pPort = (char *)&(dataSocketAddress.sin_port);
3127 pAddr[0] = f[0];
3128 pAddr[1] = f[1];
3129 pAddr[2] = f[2];
3130 pAddr[3] = f[3];
3131 pPort[0] = f[4];
3132 pPort[1] = f[5];
3133
3134 nsocket = socket(AF_INET,SOCK_STREAM,0);
3135 if (nsocket == -1)
3136 goto lend;
3137
3138 if (connect(nsocket, (struct sockaddr *)&dataSocketAddress, sizeof(dataSocketAddress)))
3139 {
3140 ERR("can't connect passive FTP data port.\n");
3141 closesocket(nsocket);
3142 goto lend;
3143 }
3144 lpwfs->pasvSocket = nsocket;
3145 bSuccess = TRUE;
3146 }
3147 else
3148 FTP_SetResponseError(nResCode);
3149 }
3150
3151 lend:
3152 return bSuccess;
3153 }
3154
3155
3156 static BOOL FTP_SendPortOrPasv(ftp_session_t *lpwfs)
3157 {
3158 if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
3159 {
3160 if (!FTP_DoPassive(lpwfs))
3161 return FALSE;
3162 }
3163 else
3164 {
3165 if (!FTP_SendPort(lpwfs))
3166 return FALSE;
3167 }
3168 return TRUE;
3169 }
3170
3171
3172 /***********************************************************************
3173 * FTP_GetDataSocket (internal)
3174 *
3175 * Either accepts an incoming data socket connection from the server
3176 * or just returns the already opened socket after a PASV command
3177 * in case of passive FTP.
3178 *
3179 *
3180 * RETURNS
3181 * TRUE on success
3182 * FALSE on failure
3183 *
3184 */
3185 static BOOL FTP_GetDataSocket(ftp_session_t *lpwfs, LPINT nDataSocket)
3186 {
3187 struct sockaddr_in saddr;
3188 socklen_t addrlen = sizeof(struct sockaddr);
3189
3190 TRACE("\n");
3191 if (lpwfs->hdr.dwFlags & INTERNET_FLAG_PASSIVE)
3192 {
3193 *nDataSocket = lpwfs->pasvSocket;
3194 lpwfs->pasvSocket = -1;
3195 }
3196 else
3197 {
3198 *nDataSocket = accept(lpwfs->lstnSocket, (struct sockaddr *) &saddr, &addrlen);
3199 closesocket(lpwfs->lstnSocket);
3200 lpwfs->lstnSocket = -1;
3201 }
3202 return *nDataSocket != -1;
3203 }
3204
3205
3206 /***********************************************************************
3207 * FTP_SendData (internal)
3208 *
3209 * Send data to the server
3210 *
3211 * RETURNS
3212 * TRUE on success
3213 * FALSE on failure
3214 *
3215 */
3216 static BOOL FTP_SendData(ftp_session_t *lpwfs, INT nDataSocket, HANDLE hFile)
3217 {
3218 BY_HANDLE_FILE_INFORMATION fi;
3219 DWORD nBytesRead = 0;
3220 DWORD nBytesSent = 0;
3221 DWORD nTotalSent = 0;
3222 DWORD nBytesToSend, nLen;
3223 int nRC = 1;
3224 time_t s_long_time, e_long_time;
3225 LONG nSeconds;
3226 CHAR *lpszBuffer;
3227
3228 TRACE("\n");
3229 lpszBuffer = heap_alloc_zero(sizeof(CHAR)*DATA_PACKET_SIZE);
3230
3231 /* Get the size of the file. */
3232 GetFileInformationByHandle(hFile, &fi);
3233 time(&s_long_time);
3234
3235 do
3236 {
3237 nBytesToSend = nBytesRead - nBytesSent;
3238
3239 if (nBytesToSend <= 0)
3240 {
3241 /* Read data from file. */
3242 nBytesSent = 0;
3243 if (!ReadFile(hFile, lpszBuffer, DATA_PACKET_SIZE, &nBytesRead, 0))
3244 ERR("Failed reading from file\n");
3245
3246 if (nBytesRead > 0)
3247 nBytesToSend = nBytesRead;
3248 else
3249 break;
3250 }
3251
3252 nLen = DATA_PACKET_SIZE < nBytesToSend ?
3253 DATA_PACKET_SIZE : nBytesToSend;
3254 nRC = send(nDataSocket, lpszBuffer, nLen, 0);
3255
3256 if (nRC != -1)
3257 {
3258 nBytesSent += nRC;
3259 nTotalSent += nRC;
3260 }
3261
3262 /* Do some computation to display the status. */
3263 time(&e_long_time);
3264 nSeconds = e_long_time - s_long_time;
3265 if( nSeconds / 60 > 0 )
3266 {
3267 TRACE( "%d bytes of %d bytes (%d%%) in %d min %d sec estimated remaining time %d sec\n",
3268 nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds / 60,
3269 nSeconds % 60, (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent );
3270 }
3271 else
3272 {
3273 TRACE( "%d bytes of %d bytes (%d%%) in %d sec estimated remaining time %d sec\n",
3274 nTotalSent, fi.nFileSizeLow, nTotalSent*100/fi.nFileSizeLow, nSeconds,
3275 (fi.nFileSizeLow - nTotalSent) * nSeconds / nTotalSent);
3276 }
3277 } while (nRC != -1);
3278
3279 TRACE("file transfer complete!\n");
3280
3281 heap_free(lpszBuffer);
3282 return nTotalSent;
3283 }
3284
3285
3286 /***********************************************************************
3287 * FTP_SendRetrieve (internal)
3288 *
3289 * Send request to retrieve a file
3290 *
3291 * RETURNS
3292 * Number of bytes to be received on success
3293 * 0 on failure
3294 *
3295 */
3296 static BOOL FTP_SendRetrieve(ftp_session_t *lpwfs, LPCWSTR lpszRemoteFile, DWORD dwType)
3297 {
3298 INT nResCode;
3299 BOOL ret;
3300
3301 TRACE("\n");
3302 if (!(ret = FTP_InitListenSocket(lpwfs)))
3303 goto lend;
3304
3305 if (!(ret = FTP_SendType(lpwfs, dwType)))
3306 goto lend;
3307
3308 if (!(ret = FTP_SendPortOrPasv(lpwfs)))
3309 goto lend;
3310
3311 if (!(ret = FTP_SendCommand(lpwfs->sndSocket, FTP_CMD_RETR, lpszRemoteFile, 0, 0, 0)))
3312 goto lend;
3313
3314 nResCode = FTP_ReceiveResponse(lpwfs, lpwfs->hdr.dwContext);
3315 if ((nResCode != 125) && (nResCode != 150)) {
3316 /* That means that we got an error getting the file. */
3317 FTP_SetResponseError(nResCode);
3318 ret = FALSE;
3319 }
3320
3321 lend:
3322 if (!ret && lpwfs->lstnSocket != -1)
3323 {
3324 closesocket(lpwfs->lstnSocket);
3325 lpwfs->lstnSocket = -1;
3326 }
3327
3328 return ret;
3329 }
3330
3331
3332 /***********************************************************************
3333 * FTP_RetrieveData (internal)
3334 *
3335 * Retrieve data from server
3336 *
3337 * RETURNS
3338 * TRUE on success
3339 * FALSE on failure
3340 *
3341 */
3342 static BOOL FTP_RetrieveFileData(ftp_session_t *lpwfs, INT nDataSocket, HANDLE hFile)
3343 {
3344 DWORD nBytesWritten;
3345 INT nRC = 0;
3346 CHAR *lpszBuffer;
3347
3348 TRACE("\n");
3349
3350 lpszBuffer = heap_alloc_zero(sizeof(CHAR)*DATA_PACKET_SIZE);
3351 if (NULL == lpszBuffer)
3352 {
3353 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
3354 return FALSE;
3355 }
3356
3357 while (nRC != -1)
3358 {
3359 nRC = recv(nDataSocket, lpszBuffer, DATA_PACKET_SIZE, 0);
3360 if (nRC != -1)
3361 {
3362 /* other side closed socket. */
3363 if (nRC == 0)
3364 goto recv_end;
3365 WriteFile(hFile, lpszBuffer, nRC, &nBytesWritten, NULL);
3366 }
3367 }
3368
3369 TRACE("Data transfer complete\n");
3370
3371 recv_end:
3372 heap_free(lpszBuffer);
3373 return (nRC != -1);
3374 }
3375
3376 /***********************************************************************
3377 * FTPFINDNEXT_Destroy (internal)
3378 *
3379 * Deallocate session handle
3380 */
3381 static void FTPFINDNEXT_Destroy(object_header_t *hdr)
3382 {
3383 LPWININETFTPFINDNEXTW lpwfn = (LPWININETFTPFINDNEXTW) hdr;
3384 DWORD i;
3385
3386 TRACE("\n");
3387
3388 WININET_Release(&lpwfn->lpFtpSession->hdr);
3389
3390 for (i = 0; i < lpwfn->size; i++)
3391 {
3392 heap_free(lpwfn->lpafp[i].lpszName);
3393 }
3394 heap_free(lpwfn->lpafp);
3395 }
3396
3397 static DWORD FTPFINDNEXT_FindNextFileProc(WININETFTPFINDNEXTW *find, LPVOID data)
3398 {
3399 WIN32_FIND_DATAW *find_data = data;
3400 DWORD res = ERROR_SUCCESS;
3401
3402 TRACE("index(%d) size(%d)\n", find->index, find->size);
3403
3404 ZeroMemory(find_data, sizeof(WIN32_FIND_DATAW));
3405
3406 if (find->index < find->size) {
3407 FTP_ConvertFileProp(&find->lpafp[find->index], find_data);
3408 find->index++;
3409
3410 TRACE("Name: %s\nSize: %d\n", debugstr_w(find_data->cFileName), find_data->nFileSizeLow);
3411 }else {
3412 res = ERROR_NO_MORE_FILES;
3413 }
3414
3415 if (find->hdr.dwFlags & INTERNET_FLAG_ASYNC)
3416 {
3417 INTERNET_ASYNC_RESULT iar;
3418
3419 iar.dwResult = (res == ERROR_SUCCESS);
3420 iar.dwError = res;
3421
3422 INTERNET_SendCallback(&find->hdr, find->hdr.dwContext,
3423 INTERNET_STATUS_REQUEST_COMPLETE, &iar,
3424 sizeof(INTERNET_ASYNC_RESULT));
3425 }
3426
3427 return res;
3428 }
3429
3430 static void FTPFINDNEXT_AsyncFindNextFileProc(WORKREQUEST *workRequest)
3431 {
3432 struct WORKREQ_FTPFINDNEXTW *req = &workRequest->u.FtpFindNextW;
3433
3434 FTPFINDNEXT_FindNextFileProc((WININETFTPFINDNEXTW*)workRequest->hdr, req->lpFindFileData);
3435 }
3436
3437 static DWORD FTPFINDNEXT_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
3438 {
3439 switch(option) {
3440 case INTERNET_OPTION_HANDLE_TYPE:
3441 TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
3442
3443 if (*size < sizeof(ULONG))
3444 return ERROR_INSUFFICIENT_BUFFER;
3445
3446 *size = sizeof(DWORD);
3447 *(DWORD*)buffer = INTERNET_HANDLE_TYPE_FTP_FIND;
3448 return ERROR_SUCCESS;
3449 }
3450
3451 return INET_QueryOption(hdr, option, buffer, size, unicode);
3452 }
3453
3454 static DWORD FTPFINDNEXT_FindNextFileW(object_header_t *hdr, void *data)
3455 {
3456 WININETFTPFINDNEXTW *find = (WININETFTPFINDNEXTW*)hdr;
3457
3458 if (find->lpFtpSession->lpAppInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC)
3459 {
3460 WORKREQUEST workRequest;
3461 struct WORKREQ_FTPFINDNEXTW *req;
3462
3463 workRequest.asyncproc = FTPFINDNEXT_AsyncFindNextFileProc;
3464 workRequest.hdr = WININET_AddRef( &find->hdr );
3465 req = &workRequest.u.FtpFindNextW;
3466 req->lpFindFileData = data;
3467
3468 INTERNET_AsyncCall(&workRequest);
3469
3470 return ERROR_SUCCESS;
3471 }
3472
3473 return FTPFINDNEXT_FindNextFileProc(find, data);
3474 }
3475
3476 static const object_vtbl_t FTPFINDNEXTVtbl = {
3477 FTPFINDNEXT_Destroy,
3478 NULL,
3479 FTPFINDNEXT_QueryOption,
3480 NULL,
3481 NULL,
3482 NULL,
3483 NULL,
3484 NULL,
3485 NULL,
3486 FTPFINDNEXT_FindNextFileW
3487 };
3488
3489 /***********************************************************************
3490 * FTP_ReceiveFileList (internal)
3491 *
3492 * Read file list from server
3493 *
3494 * RETURNS
3495 * Handle to file list on success
3496 * NULL on failure
3497 *
3498 */
3499 static HINTERNET FTP_ReceiveFileList(ftp_session_t *lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
3500 LPWIN32_FIND_DATAW lpFindFileData, DWORD_PTR dwContext)
3501 {
3502 DWORD dwSize = 0;
3503 LPFILEPROPERTIESW lpafp = NULL;
3504 LPWININETFTPFINDNEXTW lpwfn = NULL;
3505
3506 TRACE("(%p,%d,%s,%p,%08lx)\n", lpwfs, nSocket, debugstr_w(lpszSearchFile), lpFindFileData, dwContext);
3507
3508 if (FTP_ParseDirectory(lpwfs, nSocket, lpszSearchFile, &lpafp, &dwSize))
3509 {
3510 if(lpFindFileData)
3511 FTP_ConvertFileProp(lpafp, lpFindFileData);
3512
3513 lpwfn = alloc_object(&lpwfs->hdr, &FTPFINDNEXTVtbl, sizeof(WININETFTPFINDNEXTW));
3514 if (lpwfn)
3515 {
3516 lpwfn->hdr.htype = WH_HFTPFINDNEXT;
3517 lpwfn->hdr.dwContext = dwContext;
3518 lpwfn->index = 1; /* Next index is 1 since we return index 0 */
3519 lpwfn->size = dwSize;
3520 lpwfn->lpafp = lpafp;
3521
3522 WININET_AddRef( &lpwfs->hdr );
3523 lpwfn->lpFtpSession = lpwfs;
3524 list_add_head( &lpwfs->hdr.children, &lpwfn->hdr.entry );
3525 }
3526 }
3527
3528 TRACE("Matched %d files\n", dwSize);
3529 return lpwfn ? lpwfn->hdr.hInternet : NULL;
3530 }
3531
3532
3533 /***********************************************************************
3534 * FTP_ConvertFileProp (internal)
3535 *
3536 * Converts FILEPROPERTIESW struct to WIN32_FIND_DATAA
3537 *
3538 * RETURNS
3539 * TRUE on success
3540 * FALSE on failure
3541 *
3542 */
3543 static BOOL FTP_ConvertFileProp(LPFILEPROPERTIESW lpafp, LPWIN32_FIND_DATAW lpFindFileData)
3544 {
3545 BOOL bSuccess = FALSE;
3546
3547 ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAW));
3548
3549 if (lpafp)
3550 {
3551 SystemTimeToFileTime( &lpafp->tmLastModified, &lpFindFileData->ftLastAccessTime );
3552 lpFindFileData->ftLastWriteTime = lpFindFileData->ftLastAccessTime;
3553 lpFindFileData->ftCreationTime = lpFindFileData->ftLastAccessTime;
3554
3555 /* Not all fields are filled in */
3556 lpFindFileData->nFileSizeHigh = 0; /* We do not handle files bigger than 0xFFFFFFFF bytes yet :-) */
3557 lpFindFileData->nFileSizeLow = lpafp->nSize;
3558
3559 if (lpafp->bIsDirectory)
3560 lpFindFileData->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
3561
3562 if (lpafp->lpszName)
3563 lstrcpynW(lpFindFileData->cFileName, lpafp->lpszName, MAX_PATH);
3564
3565 bSuccess = TRUE;
3566 }
3567
3568 return bSuccess;
3569 }
3570
3571 /***********************************************************************
3572 * FTP_ParseNextFile (internal)
3573 *
3574 * Parse the next line in file listing
3575 *
3576 * RETURNS
3577 * TRUE on success
3578 * FALSE on failure
3579 */
3580 static BOOL FTP_ParseNextFile(INT nSocket, LPCWSTR lpszSearchFile, LPFILEPROPERTIESW lpfp)
3581 {
3582 static const char szSpace[] = " \t";
3583 DWORD nBufLen;
3584 char *pszLine;
3585 char *pszToken;
3586 char *pszTmp;
3587 BOOL found = FALSE;
3588 int i;
3589
3590 lpfp->lpszName = NULL;
3591 do {
3592 if(!(pszLine = INTERNET_GetNextLine(nSocket, &nBufLen)))
3593 return FALSE;
3594
3595 pszToken = strtok(pszLine, szSpace);
3596 /* ls format
3597 * <Permissions> <NoLinks> <owner> <group> <size> <date> <time or year> <filename>
3598 *
3599 * For instance:
3600 * drwx--s--- 2 pcarrier ens 512 Sep 28 1995 pcarrier
3601 */
3602 if(!isdigit(pszToken[0]) && 10 == strlen(pszToken)) {
3603 if(!FTP_ParsePermission(pszToken, lpfp))
3604 lpfp->bIsDirectory = FALSE;
3605 for(i=0; i<=3; i++) {
3606 if(!(pszToken = strtok(NULL, szSpace)))
3607 break;
3608 }
3609 if(!pszToken) continue;
3610 if(lpfp->bIsDirectory) {
3611 TRACE("Is directory\n");
3612 lpfp->nSize = 0;
3613 }
3614 else {
3615 TRACE("Size: %s\n", pszToken);
3616 lpfp->nSize = atol(pszToken);
3617 }
3618
3619 lpfp->tmLastModified.wSecond = 0;
3620 lpfp->tmLastModified.wMinute = 0;
3621 lpfp->tmLastModified.wHour = 0;
3622 lpfp->tmLastModified.wDay = 0;
3623 lpfp->tmLastModified.wMonth = 0;
3624 lpfp->tmLastModified.wYear = 0;
3625
3626 /* Determine month */
3627 pszToken = strtok(NULL, szSpace);
3628 if(!pszToken) continue;
3629 if(strlen(pszToken) >= 3) {
3630 pszToken[3] = 0;
3631 if((pszTmp = StrStrIA(szMonths, pszToken)))
3632 lpfp->tmLastModified.wMonth = ((pszTmp - szMonths) / 3)+1;
3633 }
3634 /* Determine day */
3635 pszToken = strtok(NULL, szSpace);
3636 if(!pszToken) continue;
3637 lpfp->tmLastModified.wDay = atoi(pszToken);
3638 /* Determine time or year */
3639 pszToken = strtok(NULL, szSpace);
3640 if(!pszToken) continue;
3641 if((pszTmp = strchr(pszToken, ':'))) {
3642 SYSTEMTIME curr_time;
3643 *pszTmp = 0;
3644 pszTmp++;
3645 lpfp->tmLastModified.wMinute = atoi(pszTmp);
3646 lpfp->tmLastModified.wHour = atoi(pszToken);
3647 GetLocalTime( &curr_time );
3648 lpfp->tmLastModified.wYear = curr_time.wYear;
3649 }
3650 else {
3651 lpfp->tmLastModified.wYear = atoi(pszToken);
3652 lpfp->tmLastModified.wHour = 12;
3653 }
3654 TRACE("Mod time: %02d:%02d:%02d %04d/%02d/%02d\n",
3655 lpfp->tmLastModified.wHour, lpfp->tmLastModified.wMinute, lpfp->tmLastModified.wSecond,
3656 lpfp->tmLastModified.wYear, lpfp->tmLastModified.wMonth, lpfp->tmLastModified.wDay);
3657
3658 pszToken = strtok(NULL, szSpace);
3659 if(!pszToken) continue;
3660 lpfp->lpszName = heap_strdupAtoW(pszToken);
3661 TRACE("File: %s\n", debugstr_w(lpfp->lpszName));
3662 }
3663 /* NT way of parsing ... :
3664
3665 07-13-03 08:55PM <DIR> sakpatch
3666 05-09-03 06:02PM 12656686 2003-04-21bgm_cmd_e.rgz
3667 */
3668 else if(isdigit(pszToken[0]) && 8 == strlen(pszToken)) {
3669 int mon, mday, year, hour, min;
3670 lpfp->permissions = 0xFFFF; /* No idea, put full permission :-) */
3671
3672 sscanf(pszToken, "%d-%d-%d", &mon, &mday, &year);
3673 lpfp->tmLastModified.wDay = mday;
3674 lpfp->tmLastModified.wMonth = mon;
3675 lpfp->tmLastModified.wYear = year;
3676
3677 /* Hacky and bad Y2K protection :-) */
3678 if (lpfp->tmLastModified.wYear < 70) lpfp->tmLastModified.wYear += 2000;
3679
3680 pszToken = strtok(NULL, szSpace);
3681 if(!pszToken) continue;
3682 sscanf(pszToken, "%d:%d", &hour, &min);
3683 lpfp->tmLastModified.wHour = hour;
3684 lpfp->tmLastModified.wMinute = min;
3685 if((pszToken[5] == 'P') && (pszToken[6] == 'M')) {
3686 lpfp->tmLastModified.wHour += 12;
3687 }
3688 lpfp->tmLastModified.wSecond = 0;
3689
3690 TRACE("Mod time: %02d:%02d:%02d %04d/%02d/%02d\n",
3691 lpfp->tmLastModified.wHour, lpfp->tmLastModified.wMinute, lpfp->tmLastModified.wSecond,
3692 lpfp->tmLastModified.wYear, lpfp->tmLastModified.wMonth, lpfp->tmLastModified.wDay);
3693
3694 pszToken = strtok(NULL, szSpace);
3695 if(!pszToken) continue;
3696 if(!strcasecmp(pszToken, "<DIR>")) {
3697 lpfp->bIsDirectory = TRUE;
3698 lpfp->nSize = 0;
3699 TRACE("Is directory\n");
3700 }
3701 else {
3702 lpfp->bIsDirectory = FALSE;
3703 lpfp->nSize = atol(pszToken);
3704 TRACE("Size: %d\n", lpfp->nSize);
3705 }
3706
3707 pszToken = strtok(NULL, szSpace);
3708 if(!pszToken) continue;
3709 lpfp->lpszName = heap_strdupAtoW(pszToken);
3710 TRACE("Name: %s\n", debugstr_w(lpfp->lpszName));
3711 }
3712 /* EPLF format - http://cr.yp.to/ftp/list/eplf.html */
3713 else if(pszToken[0] == '+') {
3714 FIXME("EPLF Format not implemented\n");
3715 }
3716
3717 if(lpfp->lpszName) {
3718 if((lpszSearchFile == NULL) ||
3719 (PathMatchSpecW(lpfp->lpszName, lpszSearchFile))) {
3720 found = TRUE;
3721 TRACE("Matched: %s\n", debugstr_w(lpfp->lpszName));
3722 }
3723 else {
3724 heap_free(lpfp->lpszName);
3725 lpfp->lpszName = NULL;
3726 }
3727 }
3728 } while(!found);
3729 return TRUE;
3730 }
3731
3732 /***********************************************************************
3733 * FTP_ParseDirectory (internal)
3734 *
3735 * Parse string of directory information
3736 *
3737 * RETURNS
3738 * TRUE on success
3739 * FALSE on failure
3740 */
3741 static BOOL FTP_ParseDirectory(ftp_session_t *lpwfs, INT nSocket, LPCWSTR lpszSearchFile,
3742 LPFILEPROPERTIESW *lpafp, LPDWORD dwfp)
3743 {
3744 BOOL bSuccess = TRUE;
3745 INT sizeFilePropArray = 500;/*20; */
3746 INT indexFilePropArray = -1;
3747
3748 TRACE("\n");
3749
3750 /* Allocate initial file properties array */
3751 *lpafp = heap_alloc_zero(sizeof(FILEPROPERTIESW)*(sizeFilePropArray));
3752 if (!*lpafp)
3753 return FALSE;
3754
3755 do {
3756 if (indexFilePropArray+1 >= sizeFilePropArray)
3757 {
3758 LPFILEPROPERTIESW tmpafp;
3759
3760 sizeFilePropArray *= 2;
3761 tmpafp = heap_realloc_zero(*lpafp, sizeof(FILEPROPERTIESW)*sizeFilePropArray);
3762 if (NULL == tmpafp)
3763 {
3764 bSuccess = FALSE;
3765 break;
3766 }
3767
3768 *lpafp = tmpafp;
3769 }
3770 indexFilePropArray++;
3771 } while (FTP_ParseNextFile(nSocket, lpszSearchFile, &(*lpafp)[indexFilePropArray]));
3772
3773 if (bSuccess && indexFilePropArray)
3774 {
3775 if (indexFilePropArray < sizeFilePropArray - 1)
3776 {
3777 LPFILEPROPERTIESW tmpafp;
3778
3779 tmpafp = heap_realloc(*lpafp, sizeof(FILEPROPERTIESW)*indexFilePropArray);
3780 if (NULL != tmpafp)
3781 *lpafp = tmpafp;
3782 }
3783 *dwfp = indexFilePropArray;
3784 }
3785 else
3786 {
3787 heap_free(*lpafp);
3788 INTERNET_SetLastError(ERROR_NO_MORE_FILES);
3789 bSuccess = FALSE;
3790 }
3791
3792 return bSuccess;
3793 }
3794
3795
3796 /***********************************************************************
3797 * FTP_ParsePermission (internal)
3798 *
3799 * Parse permission string of directory information
3800 *
3801 * RETURNS
3802 * TRUE on success
3803 * FALSE on failure
3804 *
3805 */
3806 static BOOL FTP_ParsePermission(LPCSTR lpszPermission, LPFILEPROPERTIESW lpfp)
3807 {
3808 BOOL bSuccess = TRUE;
3809 unsigned short nPermission = 0;
3810 INT nPos = 1;
3811 INT nLast = 9;
3812
3813 TRACE("\n");
3814 if ((*lpszPermission != 'd') && (*lpszPermission != '-') && (*lpszPermission != 'l'))
3815 {
3816 bSuccess = FALSE;
3817 return bSuccess;
3818 }
3819
3820 lpfp->bIsDirectory = (*lpszPermission == 'd');
3821 do
3822 {
3823 switch (nPos)
3824 {
3825 case 1:
3826 nPermission |= (*(lpszPermission+1) == 'r' ? 1 : 0) << 8;
3827 break;
3828 case 2:
3829 nPermission |= (*(lpszPermission+2) == 'w' ? 1 : 0) << 7;
3830 break;
3831 case 3:
3832 nPermission |= (*(lpszPermission+3) == 'x' ? 1 : 0) << 6;
3833 break;
3834 case 4:
3835 nPermission |= (*(lpszPermission+4) == 'r' ? 1 : 0) << 5;
3836 break;
3837 case 5:
3838 nPermission |= (*(lpszPermission+5) == 'w' ? 1 : 0) << 4;
3839 break;
3840 case 6:
3841 nPermission |= (*(lpszPermission+6) == 'x' ? 1 : 0) << 3;
3842 break;
3843 case 7:
3844 nPermission |= (*(lpszPermission+7) == 'r' ? 1 : 0) << 2;
3845 break;
3846 case 8:
3847 nPermission |= (*(lpszPermission+8) == 'w' ? 1 : 0) << 1;
3848 break;
3849 case 9:
3850 nPermission |= (*(lpszPermission+9) == 'x' ? 1 : 0);
3851 break;
3852 }
3853 nPos++;
3854 }while (nPos <= nLast);
3855
3856 lpfp->permissions = nPermission;
3857 return bSuccess;
3858 }
3859
3860
3861 /***********************************************************************
3862 * FTP_SetResponseError (internal)
3863 *
3864 * Set the appropriate error code for a given response from the server
3865 *
3866 * RETURNS
3867 *
3868 */
3869 static DWORD FTP_SetResponseError(DWORD dwResponse)
3870 {
3871 DWORD dwCode = 0;
3872
3873 switch(dwResponse)
3874 {
3875 case 425: /* Cannot open data connection. */
3876 dwCode = ERROR_INTERNET_CANNOT_CONNECT;
3877 break;
3878
3879 case 426: /* Connection closed, transer aborted. */
3880 dwCode = ERROR_INTERNET_CONNECTION_ABORTED;
3881 break;
3882
3883 case 530: /* Not logged in. Login incorrect. */
3884 dwCode = ERROR_INTERNET_LOGIN_FAILURE;
3885 break;
3886
3887 case 421: /* Service not available - Server may be shutting down. */
3888 case 450: /* File action not taken. File may be busy. */
3889 case 451: /* Action aborted. Server error. */
3890 case 452: /* Action not taken. Insufficient storage space on server. */
3891 case 500: /* Syntax error. Command unrecognized. */
3892 case 501: /* Syntax error. Error in parameters or arguments. */
3893 case 502: /* Command not implemented. */
3894 case 503: /* Bad sequence of commands. */
3895 case 504: /* Command not implemented for that parameter. */
3896 case 532: /* Need account for storing files */
3897 case 550: /* File action not taken. File not found or no access. */
3898 case 551: /* Requested action aborted. Page type unknown */
3899 case 552: /* Action aborted. Exceeded storage allocation */
3900 case 553: /* Action not taken. File name not allowed. */
3901
3902 default:
3903 dwCode = ERROR_INTERNET_EXTENDED_ERROR;
3904 break;
3905 }
3906
3907 INTERNET_SetLastError(dwCode);
3908 return dwCode;
3909 }
Windows API implementation