wined3d: Create a relative addressing token for 1.x shaders in the frontend.
[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     const IBindStatusCallbackVtbl *lpVtbl;
217     BackgroundCopyFileImpl *file;
218     LONG ref;
219 } DLBindStatusCallback;
220
221 static ULONG WINAPI DLBindStatusCallback_AddRef(IBindStatusCallback *iface)
222 {
223     DLBindStatusCallback *This = (DLBindStatusCallback *) iface;
224     return InterlockedIncrement(&This->ref);
225 }
226
227 static ULONG WINAPI DLBindStatusCallback_Release(IBindStatusCallback *iface)
228 {
229     DLBindStatusCallback *This = (DLBindStatusCallback *) iface;
230     ULONG ref = InterlockedDecrement(&This->ref);
231
232     if (ref == 0)
233     {
234         IBackgroundCopyFile_Release((IBackgroundCopyFile *) This->file);
235         HeapFree(GetProcessHeap(), 0, This);
236     }
237
238     return ref;
239 }
240
241 static HRESULT WINAPI DLBindStatusCallback_QueryInterface(
242     IBindStatusCallback *iface,
243     REFIID riid,
244     void **ppvObject)
245 {
246     DLBindStatusCallback *This = (DLBindStatusCallback *) iface;
247
248     if (IsEqualGUID(riid, &IID_IUnknown)
249         || IsEqualGUID(riid, &IID_IBindStatusCallback))
250     {
251         *ppvObject = &This->lpVtbl;
252         DLBindStatusCallback_AddRef(iface);
253         return S_OK;
254     }
255
256     *ppvObject = NULL;
257     return E_NOINTERFACE;
258 }
259
260 static HRESULT WINAPI DLBindStatusCallback_GetBindInfo(
261     IBindStatusCallback *iface,
262     DWORD *grfBINDF,
263     BINDINFO *pbindinfo)
264 {
265     return E_NOTIMPL;
266 }
267
268 static HRESULT WINAPI DLBindStatusCallback_GetPriority(
269     IBindStatusCallback *iface,
270     LONG *pnPriority)
271 {
272     return E_NOTIMPL;
273 }
274
275 static HRESULT WINAPI DLBindStatusCallback_OnDataAvailable(
276     IBindStatusCallback *iface,
277     DWORD grfBSCF,
278     DWORD dwSize,
279     FORMATETC *pformatetc,
280     STGMEDIUM *pstgmed)
281 {
282     return E_NOTIMPL;
283 }
284
285 static HRESULT WINAPI DLBindStatusCallback_OnLowResource(
286     IBindStatusCallback *iface,
287     DWORD reserved)
288 {
289     return E_NOTIMPL;
290 }
291
292 static HRESULT WINAPI DLBindStatusCallback_OnObjectAvailable(
293     IBindStatusCallback *iface,
294     REFIID riid,
295     IUnknown *punk)
296 {
297     return E_NOTIMPL;
298 }
299
300 static HRESULT WINAPI DLBindStatusCallback_OnProgress(
301     IBindStatusCallback *iface,
302     ULONG progress,
303     ULONG progressMax,
304     ULONG statusCode,
305     LPCWSTR statusText)
306 {
307     DLBindStatusCallback *This = (DLBindStatusCallback *) iface;
308     BackgroundCopyFileImpl *file = This->file;
309     BackgroundCopyJobImpl *job = file->owner;
310     ULONG64 diff;
311
312     EnterCriticalSection(&job->cs);
313     diff = (file->fileProgress.BytesTotal == BG_SIZE_UNKNOWN
314             ? progress
315             : progress - file->fileProgress.BytesTransferred);
316     file->fileProgress.BytesTotal = progressMax ? progressMax : BG_SIZE_UNKNOWN;
317     file->fileProgress.BytesTransferred = progress;
318     job->jobProgress.BytesTransferred += diff;
319     LeaveCriticalSection(&job->cs);
320
321     return S_OK;
322 }
323
324 static HRESULT WINAPI DLBindStatusCallback_OnStartBinding(
325     IBindStatusCallback *iface,
326     DWORD dwReserved,
327     IBinding *pib)
328 {
329     return E_NOTIMPL;
330 }
331
332 static HRESULT WINAPI DLBindStatusCallback_OnStopBinding(
333     IBindStatusCallback *iface,
334     HRESULT hresult,
335     LPCWSTR szError)
336 {
337     return E_NOTIMPL;
338 }
339
340 static const IBindStatusCallbackVtbl DLBindStatusCallback_Vtbl =
341 {
342     DLBindStatusCallback_QueryInterface,
343     DLBindStatusCallback_AddRef,
344     DLBindStatusCallback_Release,
345     DLBindStatusCallback_OnStartBinding,
346     DLBindStatusCallback_GetPriority,
347     DLBindStatusCallback_OnLowResource,
348     DLBindStatusCallback_OnProgress,
349     DLBindStatusCallback_OnStopBinding,
350     DLBindStatusCallback_GetBindInfo,
351     DLBindStatusCallback_OnDataAvailable,
352     DLBindStatusCallback_OnObjectAvailable
353 };
354
355 static DLBindStatusCallback *DLBindStatusCallbackConstructor(
356     BackgroundCopyFileImpl *file)
357 {
358     DLBindStatusCallback *This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
359     if (!This)
360         return NULL;
361
362     This->lpVtbl = &DLBindStatusCallback_Vtbl;
363     IBackgroundCopyFile_AddRef((IBackgroundCopyFile *) file);
364     This->file = file;
365     This->ref = 1;
366     return This;
367 }
368
369 BOOL processFile(BackgroundCopyFileImpl *file, BackgroundCopyJobImpl *job)
370 {
371     static const WCHAR prefix[] = {'B','I','T', 0};
372     IBindStatusCallback *callbackObj;
373     WCHAR tmpDir[MAX_PATH];
374     WCHAR tmpName[MAX_PATH];
375     HRESULT hr;
376
377     if (!GetTempPathW(MAX_PATH, tmpDir))
378     {
379         ERR("Couldn't create temp file name: %d\n", GetLastError());
380         /* Guessing on what state this should give us */
381         transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
382         return FALSE;
383     }
384
385     if (!GetTempFileNameW(tmpDir, prefix, 0, tmpName))
386     {
387         ERR("Couldn't create temp file: %d\n", GetLastError());
388         /* Guessing on what state this should give us */
389         transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
390         return FALSE;
391     }
392
393     callbackObj = (IBindStatusCallback *) DLBindStatusCallbackConstructor(file);
394     if (!callbackObj)
395     {
396         ERR("Out of memory\n");
397         transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
398         return FALSE;
399     }
400
401     EnterCriticalSection(&job->cs);
402     file->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
403     file->fileProgress.BytesTransferred = 0;
404     file->fileProgress.Completed = FALSE;
405     LeaveCriticalSection(&job->cs);
406
407     TRACE("Transferring: %s -> %s -> %s\n",
408           debugstr_w(file->info.RemoteName),
409           debugstr_w(tmpName),
410           debugstr_w(file->info.LocalName));
411
412     transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSFERRING);
413
414     DeleteUrlCacheEntryW(file->info.RemoteName);
415     hr = URLDownloadToFileW(NULL, file->info.RemoteName, tmpName, 0, callbackObj);
416     IBindStatusCallback_Release(callbackObj);
417     if (hr == INET_E_DOWNLOAD_FAILURE)
418     {
419         TRACE("URLDownload failed, trying local file copy\n");
420         if (!CopyFileExW(file->info.RemoteName, tmpName, copyProgressCallback,
421                          file, NULL, 0))
422         {
423             ERR("Local file copy failed: error %d\n", GetLastError());
424             transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
425             return FALSE;
426         }
427     }
428     else if (FAILED(hr))
429     {
430         ERR("URLDownload failed: eh 0x%08x\n", hr);
431         transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
432         return FALSE;
433     }
434
435     if (transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_QUEUED))
436     {
437         lstrcpyW(file->tempFileName, tmpName);
438
439         EnterCriticalSection(&job->cs);
440         file->fileProgress.Completed = TRUE;
441         job->jobProgress.FilesTransferred++;
442         LeaveCriticalSection(&job->cs);
443
444         return TRUE;
445     }
446     else
447     {
448         DeleteFileW(tmpName);
449         return FALSE;
450     }
451 }