xref: /reactos/base/applications/network/dwnl/dwnl.c (revision 4567e13e) 
1 #define COBJMACROS
2 #include <urlmon.h>
3 #include <wininet.h>
4 #include <wchar.h>
5 #include <strsafe.h>
6 #include <conutils.h>
7 
8 #include "resource.h"
9 
10 /* FIXME: add correct definitions to urlmon.idl */
11 #ifdef UNICODE
12 #define URLDownloadToFile URLDownloadToFileW
13 #else
14 #define URLDownloadToFile URLDownloadToFileA
15 #endif
16 
17 #define DWNL_E_LASTERROR    0
18 #define DWNL_E_NEEDTARGETFILENAME   -1
19 #define DWNL_E_UNSUPPORTEDSCHEME    -2
20 
21 typedef struct
22 {
23     const IBindStatusCallbackVtbl* lpIBindStatusCallbackVtbl;
24     LONG ref;
25     WCHAR szHostName[INTERNET_MAX_HOST_NAME_LENGTH + 1];
26     WCHAR szMimeType[128];
27     UINT64 Size;
28     UINT64 Progress;
29     UINT bResolving : 1;
30     UINT bConnecting : 1;
31     UINT bSendingReq : 1;
32     UINT bBeginTransfer : 1;
33 } CBindStatusCallback;
34 
35 #define impl_to_interface(impl,iface) (struct iface *)(&(impl)->lp##iface##Vtbl)
36 #define interface_to_impl(instance,iface) ((CBindStatusCallback*)((ULONG_PTR)instance - FIELD_OFFSET(CBindStatusCallback,lp##iface##Vtbl)))
37 
38 static void
39 CBindStatusCallback_Destroy(CBindStatusCallback *This)
40 {
41     return;
42 }
43 
44 static void
45 write_status(LPCWSTR lpFmt, ...)
46 {
47     va_list args;
48     WCHAR szTxt[128];
49     CONSOLE_SCREEN_BUFFER_INFO csbi;
50 
51     va_start(args, lpFmt);
52     StringCbVPrintf(szTxt, sizeof(szTxt), lpFmt, args);
53     va_end(args);
54 
55     if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
56     {
57         ConPrintf(StdOut, L"\r%*.*s", -(csbi.dwSize.X - 1), csbi.dwSize.X - 1, szTxt);
58     }
59     else
60     {
61         ConPuts(StdOut, szTxt);
62     }
63 }
64 
65 static void
66 CBindStatusCallback_UpdateProgress(CBindStatusCallback *This)
67 {
68     WCHAR szMessage[MAX_PATH];
69 
70     /* FIXME: better output */
71     if (This->Size != 0)
72     {
73         UINT Percentage;
74 
75         Percentage = (UINT)((This->Progress * 100) / This->Size);
76         if (Percentage > 99)
77             Percentage = 99;
78 
79         LoadStringW(NULL, IDS_BYTES_DOWNLOADED_FULL, szMessage, ARRAYSIZE(szMessage));
80 
81         write_status(szMessage, Percentage, This->Progress);
82     }
83     else
84     {
85         LoadStringW(NULL, IDS_BYTES_DOWNLOADED, szMessage, ARRAYSIZE(szMessage));
86 
87         /* Unknown size */
88         write_status(szMessage, This->Progress);
89     }
90 }
91 
92 static ULONG STDMETHODCALLTYPE
93 CBindStatusCallback_AddRef(IBindStatusCallback *iface)
94 {
95     CBindStatusCallback *This = interface_to_impl(iface, IBindStatusCallback);
96     ULONG ret;
97 
98     ret = InterlockedIncrement((PLONG)&This->ref);
99     return ret;
100 }
101 
102 static ULONG STDMETHODCALLTYPE
103 CBindStatusCallback_Release(IBindStatusCallback *iface)
104 {
105     CBindStatusCallback *This = interface_to_impl(iface, IBindStatusCallback);
106     ULONG ret;
107 
108     ret = InterlockedDecrement((PLONG)&This->ref);
109     if (ret == 0)
110     {
111         CBindStatusCallback_Destroy(This);
112 
113         HeapFree(GetProcessHeap(),
114                  0,
115                  This);
116     }
117 
118     return ret;
119 }
120 
121 static HRESULT STDMETHODCALLTYPE
122 CBindStatusCallback_QueryInterface(IBindStatusCallback *iface,
123                                    REFIID iid,
124                                    PVOID *pvObject)
125 {
126     CBindStatusCallback *This = interface_to_impl(iface, IBindStatusCallback);
127 
128     *pvObject = NULL;
129 
130     if (IsEqualIID(iid,
131                    &IID_IBindStatusCallback) ||
132         IsEqualIID(iid,
133                    &IID_IUnknown))
134     {
135         *pvObject = impl_to_interface(This, IBindStatusCallback);
136     }
137     else
138         return E_NOINTERFACE;
139 
140     CBindStatusCallback_AddRef(iface);
141     return S_OK;
142 }
143 
144 static HRESULT STDMETHODCALLTYPE
145 CBindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
146                                    DWORD dwReserved,
147                                    IBinding* pib)
148 {
149     return E_NOTIMPL;
150 }
151 
152 static HRESULT STDMETHODCALLTYPE
153 CBindStatusCallback_GetPriority(IBindStatusCallback *iface,
154                                 LONG* pnPriority)
155 {
156     return E_NOTIMPL;
157 }
158 
159 static HRESULT STDMETHODCALLTYPE
160 CBindStatusCallback_OnLowResource(IBindStatusCallback *iface,
161                                   DWORD reserved)
162 {
163     return E_NOTIMPL;
164 }
165 
166 static HRESULT STDMETHODCALLTYPE
167 CBindStatusCallback_OnProgress(IBindStatusCallback *iface,
168                                ULONG ulProgress,
169                                ULONG ulProgressMax,
170                                ULONG ulStatusCode,
171                                LPCWSTR szStatusText)
172 {
173     CBindStatusCallback *This = interface_to_impl(iface, IBindStatusCallback);
174 
175     switch (ulStatusCode)
176     {
177         case BINDSTATUS_FINDINGRESOURCE:
178             if (!This->bResolving)
179             {
180                 wcscpy(This->szHostName, szStatusText);
181                 This->bResolving = TRUE;
182 
183                 ConResPrintf(StdOut, IDS_RESOLVING, This->szHostName);
184             }
185             break;
186 
187         case BINDSTATUS_CONNECTING:
188             This->bConnecting = TRUE;
189             This->bSendingReq = FALSE;
190             This->bBeginTransfer = FALSE;
191             This->szMimeType[0] = L'\0';
192             if (This->bResolving)
193             {
194                 ConResPrintf(StdOut, IDS_DONE);
195                 ConResPrintf(StdOut, IDS_CONNECTING_TO_FULL, This->szHostName, szStatusText);
196             }
197             else
198             {
199                 ConResPrintf(StdOut, IDS_CONNECTING_TO, szStatusText);
200             }
201             break;
202 
203         case BINDSTATUS_REDIRECTING:
204             This->bResolving = FALSE;
205             This->bConnecting = FALSE;
206             This->bSendingReq = FALSE;
207             This->bBeginTransfer = FALSE;
208             This->szMimeType[0] = L'\0';
209             ConResPrintf(StdOut, IDS_REDIRECTING_TO, szStatusText);
210             break;
211 
212         case BINDSTATUS_SENDINGREQUEST:
213             This->bBeginTransfer = FALSE;
214             This->szMimeType[0] = L'\0';
215             if (This->bResolving || This->bConnecting)
216                 ConResPrintf(StdOut, IDS_DONE);
217 
218             if (!This->bSendingReq)
219                 ConResPrintf(StdOut, IDS_SEND_REQUEST);
220 
221             This->bSendingReq = TRUE;
222             break;
223 
224         case BINDSTATUS_MIMETYPEAVAILABLE:
225             wcscpy(This->szMimeType, szStatusText);
226             break;
227 
228         case BINDSTATUS_BEGINDOWNLOADDATA:
229             This->Progress = (UINT64)ulProgress;
230             This->Size = (UINT64)ulProgressMax;
231 
232             if (This->bSendingReq)
233                 ConResPrintf(StdOut, IDS_DONE);
234 
235             if (!This->bBeginTransfer && This->Size != 0)
236             {
237                 if (This->szMimeType[0] != L'\0')
238                     ConResPrintf(StdOut, IDS_LENGTH_FULL, This->Size, This->szMimeType);
239                 else
240                     ConResPrintf(StdOut, IDS_LENGTH, This->Size);
241             }
242 
243             ConPuts(StdOut, L"\n");
244 
245             This->bBeginTransfer = TRUE;
246             break;
247 
248         case BINDSTATUS_ENDDOWNLOADDATA:
249             ConResPrintf(StdOut, IDS_FILE_SAVED);
250             break;
251 
252         case BINDSTATUS_DOWNLOADINGDATA:
253             This->Progress = (UINT64)ulProgress;
254             This->Size = (UINT64)ulProgressMax;
255 
256             CBindStatusCallback_UpdateProgress(This);
257             break;
258     }
259 
260     return S_OK;
261 }
262 
263 static HRESULT STDMETHODCALLTYPE
264 CBindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
265                                   HRESULT hresult,
266                                   LPCWSTR szError)
267 {
268     return E_NOTIMPL;
269 }
270 
271 static HRESULT STDMETHODCALLTYPE
272 CBindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
273                                 DWORD* grfBINDF,
274                                 BINDINFO* pbindinfo)
275 {
276     return E_NOTIMPL;
277 }
278 
279 static HRESULT STDMETHODCALLTYPE
280 CBindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
281                                     DWORD grfBSCF,
282                                     DWORD dwSize,
283                                     FORMATETC* pformatetc,
284                                     STGMEDIUM* pstgmed)
285 {
286     return E_NOTIMPL;
287 }
288 
289 static HRESULT STDMETHODCALLTYPE
290 CBindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
291                                       REFIID riid,
292                                       IUnknown* punk)
293 {
294     return E_NOTIMPL;
295 }
296 
297 static const struct IBindStatusCallbackVtbl vtblIBindStatusCallback =
298 {
299     CBindStatusCallback_QueryInterface,
300     CBindStatusCallback_AddRef,
301     CBindStatusCallback_Release,
302     CBindStatusCallback_OnStartBinding,
303     CBindStatusCallback_GetPriority,
304     CBindStatusCallback_OnLowResource,
305     CBindStatusCallback_OnProgress,
306     CBindStatusCallback_OnStopBinding,
307     CBindStatusCallback_GetBindInfo,
308     CBindStatusCallback_OnDataAvailable,
309     CBindStatusCallback_OnObjectAvailable,
310 };
311 
312 static IBindStatusCallback *
313 CreateBindStatusCallback(void)
314 {
315     CBindStatusCallback *This;
316 
317     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
318     if (This == NULL)
319         return NULL;
320 
321     This->lpIBindStatusCallbackVtbl = &vtblIBindStatusCallback;
322     This->ref = 1;
323 
324     return impl_to_interface(This, IBindStatusCallback);
325 }
326 
327 
328 // ToDo: Show status, get file name from webserver, better error reporting
329 
330 static int
331 get_display_url(IN LPURL_COMPONENTS purl,
332                 OUT LPWSTR szBuffer,
333                 IN PDWORD pdwBufferSize)
334 {
335     URL_COMPONENTS urlc;
336 
337     /* Hide the password */
338     urlc = *purl;
339     urlc.lpszPassword = NULL;
340     urlc.dwPasswordLength = 0;
341 
342     if (!InternetCreateUrl(&urlc, ICU_ESCAPE, szBuffer, pdwBufferSize))
343         return DWNL_E_LASTERROR;
344 
345     return 1;
346 }
347 
348 static int
349 download_file(IN LPCWSTR pszUrl,
350               IN LPCWSTR pszFile OPTIONAL)
351 {
352     WCHAR szScheme[INTERNET_MAX_SCHEME_LENGTH + 1];
353     WCHAR szHostName[INTERNET_MAX_HOST_NAME_LENGTH + 1];
354     WCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH + 1];
355     WCHAR szPassWord[INTERNET_MAX_PASSWORD_LENGTH + 1];
356     WCHAR szUrlPath[INTERNET_MAX_PATH_LENGTH + 1];
357     WCHAR szExtraInfo[INTERNET_MAX_PATH_LENGTH + 1];
358     WCHAR szUrl[INTERNET_MAX_URL_LENGTH + 1];
359     DWORD dwUrlLen;
360     LPTSTR pszFilePart;
361     URL_COMPONENTS urlc;
362     IBindStatusCallback *pbsc;
363     int iRet;
364     SYSTEMTIME sysTime;
365 
366     if (pszFile != NULL && pszFile[0] == L'\0')
367         pszFile = NULL;
368 
369     urlc.dwStructSize = sizeof(urlc);
370     urlc.lpszScheme = szScheme;
371     urlc.dwSchemeLength = sizeof(szScheme) / sizeof(szScheme[0]);
372     urlc.lpszHostName = szHostName;
373     urlc.dwHostNameLength = sizeof(szHostName) / sizeof(szHostName[0]);
374     urlc.lpszUserName = szUserName;
375     urlc.dwUserNameLength = sizeof(szUserName) / sizeof(szUserName[0]);
376     urlc.lpszPassword = szPassWord;
377     urlc.dwPasswordLength = sizeof(szPassWord) / sizeof(szPassWord[0]);
378     urlc.lpszUrlPath = szUrlPath;
379     urlc.dwUrlPathLength = sizeof(szUrlPath) / sizeof(szUrlPath[0]);
380     urlc.lpszExtraInfo = szExtraInfo;
381     urlc.dwExtraInfoLength = sizeof(szExtraInfo) / sizeof(szExtraInfo[0]);
382     if (!InternetCrackUrl(pszUrl, wcslen(pszUrl), ICU_ESCAPE, &urlc))
383         return DWNL_E_LASTERROR;
384 
385     if (urlc.nScheme != INTERNET_SCHEME_FTP &&
386         urlc.nScheme != INTERNET_SCHEME_GOPHER &&
387         urlc.nScheme != INTERNET_SCHEME_HTTP &&
388         urlc.nScheme != INTERNET_SCHEME_HTTPS)
389     {
390         return DWNL_E_UNSUPPORTEDSCHEME;
391     }
392 
393     if (urlc.nScheme == INTERNET_SCHEME_FTP && urlc.dwUserNameLength == 0 && urlc.dwPasswordLength == 0)
394     {
395         wcscpy(szUserName, L"anonymous");
396         urlc.dwUserNameLength = wcslen(szUserName);
397     }
398 
399     /* FIXME: Get file name from server */
400     if (urlc.dwUrlPathLength == 0 && pszFile == NULL)
401         return DWNL_E_NEEDTARGETFILENAME;
402 
403     pszFilePart = wcsrchr(szUrlPath, L'/');
404     if (pszFilePart != NULL)
405         pszFilePart++;
406 
407     if (pszFilePart == NULL && pszFile == NULL)
408         return DWNL_E_NEEDTARGETFILENAME;
409 
410     if (pszFile == NULL)
411         pszFile = pszFilePart;
412 
413     if (urlc.dwUserNameLength == 0)
414         urlc.lpszUserName = NULL;
415 
416     if (urlc.dwPasswordLength == 0)
417         urlc.lpszPassword = NULL;
418 
419     /* Generate the URL to be displayed (without a password) */
420     dwUrlLen = sizeof(szUrl) / sizeof(szUrl[0]);
421     iRet = get_display_url(&urlc, szUrl, &dwUrlLen);
422     if (iRet <= 0)
423         return iRet;
424 
425     GetLocalTime(&sysTime);
426 
427     ConPrintf(StdOut, L"--%d-%02d-%02d %02d:%02d:%02d-- %s\n\t=> %s\n",
428           sysTime.wYear, sysTime.wMonth, sysTime.wDay,
429           sysTime.wHour, sysTime.wMinute, sysTime.wSecond,
430           szUrl, pszFile);
431 
432     /* Generate the URL to download */
433     dwUrlLen = sizeof(szUrl) / sizeof(szUrl[0]);
434     if (!InternetCreateUrl(&urlc, ICU_ESCAPE, szUrl, &dwUrlLen))
435         return DWNL_E_LASTERROR;
436 
437     pbsc = CreateBindStatusCallback();
438     if (pbsc == NULL)
439         return DWNL_E_LASTERROR;
440 
441     if(!SUCCEEDED(URLDownloadToFile(NULL, szUrl, pszFile, 0, pbsc)))
442     {
443         IBindStatusCallback_Release(pbsc);
444         return DWNL_E_LASTERROR; /* FIXME */
445     }
446 
447     IBindStatusCallback_Release(pbsc);
448     return 1;
449 }
450 
451 static int
452 print_err(int iErr)
453 {
454     write_status(L"");
455 
456     if (iErr == DWNL_E_LASTERROR)
457     {
458         if (GetLastError() == ERROR_SUCCESS)
459         {
460             /* File not found */
461             ConResPrintf(StdErr, IDS_ERROR_DOWNLOAD);
462         }
463         else
464         {
465             /* Display last error code */
466             ConResPrintf(StdErr, IDS_ERROR_CODE, GetLastError());
467         }
468     }
469     else
470     {
471         switch (iErr)
472         {
473             case DWNL_E_NEEDTARGETFILENAME:
474                 ConResPrintf(StdErr, IDS_ERROR_FILENAME);
475                 break;
476 
477             case DWNL_E_UNSUPPORTEDSCHEME:
478                 ConResPrintf(StdErr, IDS_ERROR_PROTOCOL);
479                 break;
480         }
481     }
482 
483     return 1;
484 }
485 
486 int wmain(int argc, WCHAR **argv)
487 {
488     int iErr, iRet = 0;
489 
490     /* Initialize the Console Standard Streams */
491     ConInitStdStreams();
492 
493     if(argc != 2 && argc != 3)
494     {
495         ConResPrintf(StdOut, IDS_USAGE);
496         return 2;
497     }
498 
499     iErr = download_file(argv[1], argc == 3 ? argv[2] : NULL);
500     if (iErr <= 0)
501         iRet = print_err(iErr);
502 
503     return iRet;
504 }
505