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