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