mlang/tests: Remove unused assignment (LLVM/Clang).
[wine] / dlls / qmgr / file.c
1 /*
2  * Queue Manager (BITS) File
3  *
4  * Copyright 2007, 2008 Google (Roy Shea, Dan Hipschman)
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "winreg.h"
29 #include "ole2.h"
30 #include "urlmon.h"
31 #include "wininet.h"
32
33 #include "qmgr.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
37
38 static void BackgroundCopyFileDestructor(BackgroundCopyFileImpl *This)
39 {
40     IBackgroundCopyJob_Release((IBackgroundCopyJob *) This->owner);
41     HeapFree(GetProcessHeap(), 0, This->info.LocalName);
42     HeapFree(GetProcessHeap(), 0, This->info.RemoteName);
43     HeapFree(GetProcessHeap(), 0, This);
44 }
45
46 static ULONG WINAPI BITS_IBackgroundCopyFile_AddRef(IBackgroundCopyFile* iface)
47 {
48     BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
49     return InterlockedIncrement(&This->ref);
50 }
51
52 static HRESULT WINAPI BITS_IBackgroundCopyFile_QueryInterface(
53     IBackgroundCopyFile* iface,
54     REFIID riid,
55     void **ppvObject)
56 {
57     BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
58
59     if (IsEqualGUID(riid, &IID_IUnknown)
60         || IsEqualGUID(riid, &IID_IBackgroundCopyFile))
61     {
62         *ppvObject = &This->lpVtbl;
63         BITS_IBackgroundCopyFile_AddRef(iface);
64         return S_OK;
65     }
66
67     *ppvObject = NULL;
68     return E_NOINTERFACE;
69 }
70
71
72 static ULONG WINAPI BITS_IBackgroundCopyFile_Release(
73     IBackgroundCopyFile* iface)
74 {
75     BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
76     ULONG ref = InterlockedDecrement(&This->ref);
77
78     if (ref == 0)
79         BackgroundCopyFileDestructor(This);
80
81     return ref;
82 }
83
84 /* Get the remote name of a background copy file */
85 static HRESULT WINAPI BITS_IBackgroundCopyFile_GetRemoteName(
86     IBackgroundCopyFile* iface,
87     LPWSTR *pVal)
88 {
89     BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
90     int n = (lstrlenW(This->info.RemoteName) + 1) * sizeof(WCHAR);
91
92     *pVal = CoTaskMemAlloc(n);
93     if (!*pVal)
94         return E_OUTOFMEMORY;
95
96     memcpy(*pVal, This->info.RemoteName, n);
97     return S_OK;
98 }
99
100 static HRESULT WINAPI BITS_IBackgroundCopyFile_GetLocalName(
101     IBackgroundCopyFile* iface,
102     LPWSTR *pVal)
103 {
104     BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
105     int n = (lstrlenW(This->info.LocalName) + 1) * sizeof(WCHAR);
106
107     *pVal = CoTaskMemAlloc(n);
108     if (!*pVal)
109         return E_OUTOFMEMORY;
110
111     memcpy(*pVal, This->info.LocalName, n);
112     return S_OK;
113 }
114
115 static HRESULT WINAPI BITS_IBackgroundCopyFile_GetProgress(
116     IBackgroundCopyFile* iface,
117     BG_FILE_PROGRESS *pVal)
118 {
119     BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
120
121     EnterCriticalSection(&This->owner->cs);
122     pVal->BytesTotal = This->fileProgress.BytesTotal;
123     pVal->BytesTransferred = This->fileProgress.BytesTransferred;
124     pVal->Completed = This->fileProgress.Completed;
125     LeaveCriticalSection(&This->owner->cs);
126
127     return S_OK;
128 }
129
130 static const IBackgroundCopyFileVtbl BITS_IBackgroundCopyFile_Vtbl =
131 {
132     BITS_IBackgroundCopyFile_QueryInterface,
133     BITS_IBackgroundCopyFile_AddRef,
134     BITS_IBackgroundCopyFile_Release,
135     BITS_IBackgroundCopyFile_GetRemoteName,
136     BITS_IBackgroundCopyFile_GetLocalName,
137     BITS_IBackgroundCopyFile_GetProgress
138 };
139
140 HRESULT BackgroundCopyFileConstructor(BackgroundCopyJobImpl *owner,
141                                       LPCWSTR remoteName, LPCWSTR localName,
142                                       LPVOID *ppObj)
143 {
144     BackgroundCopyFileImpl *This;
145     int n;
146
147     TRACE("(%s,%s,%p)\n", debugstr_w(remoteName),
148             debugstr_w(localName), ppObj);
149
150     This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
151     if (!This)
152         return E_OUTOFMEMORY;
153
154     n = (lstrlenW(remoteName) + 1) * sizeof(WCHAR);
155     This->info.RemoteName = HeapAlloc(GetProcessHeap(), 0, n);
156     if (!This->info.RemoteName)
157     {
158         HeapFree(GetProcessHeap(), 0, This);
159         return E_OUTOFMEMORY;
160     }
161     memcpy(This->info.RemoteName, remoteName, n);
162
163     n = (lstrlenW(localName) + 1) * sizeof(WCHAR);
164     This->info.LocalName = HeapAlloc(GetProcessHeap(), 0, n);
165     if (!This->info.LocalName)
166     {
167         HeapFree(GetProcessHeap(), 0, This->info.RemoteName);
168         HeapFree(GetProcessHeap(), 0, This);
169         return E_OUTOFMEMORY;
170     }
171     memcpy(This->info.LocalName, localName, n);
172
173     This->lpVtbl = &BITS_IBackgroundCopyFile_Vtbl;
174     This->ref = 1;
175
176     This->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
177     This->fileProgress.BytesTransferred = 0;
178     This->fileProgress.Completed = FALSE;
179     This->owner = owner;
180     IBackgroundCopyJob_AddRef((IBackgroundCopyJob *) owner);
181
182     *ppObj = &This->lpVtbl;
183     return S_OK;
184 }
185
186 static DWORD CALLBACK copyProgressCallback(LARGE_INTEGER totalSize,
187                                            LARGE_INTEGER totalTransferred,
188                                            LARGE_INTEGER streamSize,
189                                            LARGE_INTEGER streamTransferred,
190                                            DWORD streamNum,
191                                            DWORD reason,
192                                            HANDLE srcFile,
193                                            HANDLE dstFile,
194                                            LPVOID obj)
195 {
196     BackgroundCopyFileImpl *file = obj;
197     BackgroundCopyJobImpl *job = file->owner;
198     ULONG64 diff;
199
200     EnterCriticalSection(&job->cs);
201     diff = (file->fileProgress.BytesTotal == BG_SIZE_UNKNOWN
202             ? totalTransferred.QuadPart
203             : totalTransferred.QuadPart - file->fileProgress.BytesTransferred);
204     file->fileProgress.BytesTotal = totalSize.QuadPart;
205     file->fileProgress.BytesTransferred = totalTransferred.QuadPart;
206     job->jobProgress.BytesTransferred += diff;
207     LeaveCriticalSection(&job->cs);
208
209     return (job->state == BG_JOB_STATE_TRANSFERRING
210             ? PROGRESS_CONTINUE
211             : PROGRESS_CANCEL);
212 }
213
214 typedef struct
215 {
216     IBindStatusCallback IBindStatusCallback_iface;
217     BackgroundCopyFileImpl *file;
218     LONG ref;
219 } DLBindStatusCallback;
220
221 static inline DLBindStatusCallback *impl_from_IBindStatusCallback(IBindStatusCallback *iface)
222 {
223     return CONTAINING_RECORD(iface, DLBindStatusCallback, IBindStatusCallback_iface);
224 }
225
226 static ULONG WINAPI DLBindStatusCallback_AddRef(IBindStatusCallback *iface)
227 {
228     DLBindStatusCallback *This = impl_from_IBindStatusCallback(iface);
229     return InterlockedIncrement(&This->ref);
230 }
231
232 static ULONG WINAPI DLBindStatusCallback_Release(IBindStatusCallback *iface)
233 {
234     DLBindStatusCallback *This = impl_from_IBindStatusCallback(iface);
235     ULONG ref = InterlockedDecrement(&This->ref);
236
237     if (ref == 0)
238     {
239         IBackgroundCopyFile_Release((IBackgroundCopyFile *) This->file);
240         HeapFree(GetProcessHeap(), 0, This);
241     }
242
243     return ref;
244 }
245
246 static HRESULT WINAPI DLBindStatusCallback_QueryInterface(
247     IBindStatusCallback *iface,
248     REFIID riid,
249     void **ppvObject)
250 {
251     DLBindStatusCallback *This = impl_from_IBindStatusCallback(iface);
252
253     if (IsEqualGUID(riid, &IID_IUnknown)
254         || IsEqualGUID(riid, &IID_IBindStatusCallback))
255     {
256         *ppvObject = &This->IBindStatusCallback_iface;
257         DLBindStatusCallback_AddRef(iface);
258         return S_OK;
259     }
260
261     *ppvObject = NULL;
262     return E_NOINTERFACE;
263 }
264
265 static HRESULT WINAPI DLBindStatusCallback_GetBindInfo(
266     IBindStatusCallback *iface,
267     DWORD *grfBINDF,
268     BINDINFO *pbindinfo)
269 {
270     return E_NOTIMPL;
271 }
272
273 static HRESULT WINAPI DLBindStatusCallback_GetPriority(
274     IBindStatusCallback *iface,
275     LONG *pnPriority)
276 {
277     return E_NOTIMPL;
278 }
279
280 static HRESULT WINAPI DLBindStatusCallback_OnDataAvailable(
281     IBindStatusCallback *iface,
282     DWORD grfBSCF,
283     DWORD dwSize,
284     FORMATETC *pformatetc,
285     STGMEDIUM *pstgmed)
286 {
287     return E_NOTIMPL;
288 }
289
290 static HRESULT WINAPI DLBindStatusCallback_OnLowResource(
291     IBindStatusCallback *iface,
292     DWORD reserved)
293 {
294     return E_NOTIMPL;
295 }
296
297 static HRESULT WINAPI DLBindStatusCallback_OnObjectAvailable(
298     IBindStatusCallback *iface,
299     REFIID riid,
300     IUnknown *punk)
301 {
302     return E_NOTIMPL;
303 }
304
305 static HRESULT WINAPI DLBindStatusCallback_OnProgress(
306     IBindStatusCallback *iface,
307     ULONG progress,
308     ULONG progressMax,
309     ULONG statusCode,
310     LPCWSTR statusText)
311 {
312     DLBindStatusCallback *This = impl_from_IBindStatusCallback(iface);
313     BackgroundCopyFileImpl *file = This->file;
314     BackgroundCopyJobImpl *job = file->owner;
315     ULONG64 diff;
316
317     EnterCriticalSection(&job->cs);
318     diff = (file->fileProgress.BytesTotal == BG_SIZE_UNKNOWN
319             ? progress
320             : progress - file->fileProgress.BytesTransferred);
321     file->fileProgress.BytesTotal = progressMax ? progressMax : BG_SIZE_UNKNOWN;
322     file->fileProgress.BytesTransferred = progress;
323     job->jobProgress.BytesTransferred += diff;
324     LeaveCriticalSection(&job->cs);
325
326     return S_OK;
327 }
328
329 static HRESULT WINAPI DLBindStatusCallback_OnStartBinding(
330     IBindStatusCallback *iface,
331     DWORD dwReserved,
332     IBinding *pib)
333 {
334     return E_NOTIMPL;
335 }
336
337 static HRESULT WINAPI DLBindStatusCallback_OnStopBinding(
338     IBindStatusCallback *iface,
339     HRESULT hresult,
340     LPCWSTR szError)
341 {
342     return E_NOTIMPL;
343 }
344
345 static const IBindStatusCallbackVtbl DLBindStatusCallback_Vtbl =
346 {
347     DLBindStatusCallback_QueryInterface,
348     DLBindStatusCallback_AddRef,
349     DLBindStatusCallback_Release,
350     DLBindStatusCallback_OnStartBinding,
351     DLBindStatusCallback_GetPriority,
352     DLBindStatusCallback_OnLowResource,
353     DLBindStatusCallback_OnProgress,
354     DLBindStatusCallback_OnStopBinding,
355     DLBindStatusCallback_GetBindInfo,
356     DLBindStatusCallback_OnDataAvailable,
357     DLBindStatusCallback_OnObjectAvailable
358 };
359
360 static DLBindStatusCallback *DLBindStatusCallbackConstructor(
361     BackgroundCopyFileImpl *file)
362 {
363     DLBindStatusCallback *This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
364     if (!This)
365         return NULL;
366
367     This->IBindStatusCallback_iface.lpVtbl = &DLBindStatusCallback_Vtbl;
368     IBackgroundCopyFile_AddRef((IBackgroundCopyFile *) file);
369     This->file = file;
370     This->ref = 1;
371     return This;
372 }
373
374 BOOL processFile(BackgroundCopyFileImpl *file, BackgroundCopyJobImpl *job)
375 {
376     static const WCHAR prefix[] = {'B','I','T', 0};
377     DLBindStatusCallback *callbackObj;
378     WCHAR tmpDir[MAX_PATH];
379     WCHAR tmpName[MAX_PATH];
380     HRESULT hr;
381
382     if (!GetTempPathW(MAX_PATH, tmpDir))
383     {
384         ERR("Couldn't create temp file name: %d\n", GetLastError());
385         /* Guessing on what state this should give us */
386         transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
387         return FALSE;
388     }
389
390     if (!GetTempFileNameW(tmpDir, prefix, 0, tmpName))
391     {
392         ERR("Couldn't create temp file: %d\n", GetLastError());
393         /* Guessing on what state this should give us */
394         transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
395         return FALSE;
396     }
397
398     callbackObj = DLBindStatusCallbackConstructor(file);
399     if (!callbackObj)
400     {
401         ERR("Out of memory\n");
402         transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
403         return FALSE;
404     }
405
406     EnterCriticalSection(&job->cs);
407     file->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
408     file->fileProgress.BytesTransferred = 0;
409     file->fileProgress.Completed = FALSE;
410     LeaveCriticalSection(&job->cs);
411
412     TRACE("Transferring: %s -> %s -> %s\n",
413           debugstr_w(file->info.RemoteName),
414           debugstr_w(tmpName),
415           debugstr_w(file->info.LocalName));
416
417     transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSFERRING);
418
419     DeleteUrlCacheEntryW(file->info.RemoteName);
420     hr = URLDownloadToFileW(NULL, file->info.RemoteName, tmpName, 0,
421                             &callbackObj->IBindStatusCallback_iface);
422     IBindStatusCallback_Release(&callbackObj->IBindStatusCallback_iface);
423     if (hr == INET_E_DOWNLOAD_FAILURE)
424     {
425         TRACE("URLDownload failed, trying local file copy\n");
426         if (!CopyFileExW(file->info.RemoteName, tmpName, copyProgressCallback,
427                          file, NULL, 0))
428         {
429             ERR("Local file copy failed: error %d\n", GetLastError());
430             transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
431             return FALSE;
432         }
433     }
434     else if (FAILED(hr))
435     {
436         ERR("URLDownload failed: eh 0x%08x\n", hr);
437         transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
438         return FALSE;
439     }
440
441     if (transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_QUEUED))
442     {
443         lstrcpyW(file->tempFileName, tmpName);
444
445         EnterCriticalSection(&job->cs);
446         file->fileProgress.Completed = TRUE;
447         job->jobProgress.FilesTransferred++;
448         LeaveCriticalSection(&job->cs);
449
450         return TRUE;
451     }
452     else
453     {
454         DeleteFileW(tmpName);
455         return FALSE;
456     }
457 }