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 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "winreg.h"
  27 #include "winhttp.h"
  28 #define COBJMACROS
  29 #include "qmgr.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
  33
  34 static inline BackgroundCopyFileImpl *impl_from_IBackgroundCopyFile2(
  35     IBackgroundCopyFile2 *iface)
  36 {
  37     return CONTAINING_RECORD(iface, BackgroundCopyFileImpl, IBackgroundCopyFile2_iface);
  38 }
  39
  40 static HRESULT WINAPI BackgroundCopyFile_QueryInterface(
  41     IBackgroundCopyFile2 *iface,
  42     REFIID riid,
  43     void **obj)
  44 {
  45     BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
  46
  47     TRACE("(%p)->(%s %p)\n", file, debugstr_guid(riid), obj);
  48
  49     if (IsEqualGUID(riid, &IID_IUnknown) ||
  50         IsEqualGUID(riid, &IID_IBackgroundCopyFile) ||
  51         IsEqualGUID(riid, &IID_IBackgroundCopyFile2))
  52     {
  53         *obj = iface;
  54     }
  55     else
  56     {
  57         *obj = NULL;
  58         return E_NOINTERFACE;
  59     }
  60
  61     IBackgroundCopyFile2_AddRef(iface);
  62     return S_OK;
  63 }
  64
  65 static ULONG WINAPI BackgroundCopyFile_AddRef(
  66     IBackgroundCopyFile2 *iface)
  67 {
  68     BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
  69     ULONG ref = InterlockedIncrement(&file->ref);
  70     TRACE("(%p)->(%d)\n", file, ref);
  71     return ref;
  72 }
  73
  74 static ULONG WINAPI BackgroundCopyFile_Release(
  75     IBackgroundCopyFile2 *iface)
  76 {
  77     BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
  78     ULONG ref = InterlockedDecrement(&file->ref);
  79
  80     TRACE("(%p)->(%d)\n", file, ref);
  81
  82     if (ref == 0)
  83     {
  84         IBackgroundCopyJob4_Release(&file->owner->IBackgroundCopyJob4_iface);
  85         HeapFree(GetProcessHeap(), 0, file->info.LocalName);
  86         HeapFree(GetProcessHeap(), 0, file->info.RemoteName);
  87         HeapFree(GetProcessHeap(), 0, file);
  88     }
  89
  90     return ref;
  91 }
  92
  93 /* Get the remote name of a background copy file */
  94 static HRESULT WINAPI BackgroundCopyFile_GetRemoteName(
  95     IBackgroundCopyFile2 *iface,
  96     LPWSTR *pVal)
  97 {
  98     BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
  99
 100     TRACE("(%p)->(%p)\n", file, pVal);
 101
 102     return return_strval(file->info.RemoteName, pVal);
 103 }
 104
 105 static HRESULT WINAPI BackgroundCopyFile_GetLocalName(
 106     IBackgroundCopyFile2 *iface,
 107     LPWSTR *pVal)
 108 {
 109     BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
 110
 111     TRACE("(%p)->(%p)\n", file, pVal);
 112
 113     return return_strval(file->info.LocalName, pVal);
 114 }
 115
 116 static HRESULT WINAPI BackgroundCopyFile_GetProgress(
 117     IBackgroundCopyFile2 *iface,
 118     BG_FILE_PROGRESS *pVal)
 119 {
 120     BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
 121
 122     TRACE("(%p)->(%p)\n", file, pVal);
 123
 124     EnterCriticalSection(&file->owner->cs);
 125     *pVal = file->fileProgress;
 126     LeaveCriticalSection(&file->owner->cs);
 127
 128     return S_OK;
 129 }
 130
 131 static HRESULT WINAPI BackgroundCopyFile_GetFileRanges(
 132     IBackgroundCopyFile2 *iface,
 133     DWORD *RangeCount,
 134     BG_FILE_RANGE **Ranges)
 135 {
 136     BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
 137     FIXME("(%p)->(%p %p)\n", file, RangeCount, Ranges);
 138     return E_NOTIMPL;
 139 }
 140
 141 static HRESULT WINAPI BackgroundCopyFile_SetRemoteName(
 142     IBackgroundCopyFile2 *iface,
 143     LPCWSTR Val)
 144 {
 145     BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
 146     FIXME("(%p)->(%s)\n", file, debugstr_w(Val));
 147     return E_NOTIMPL;
 148 }
 149
 150 static const IBackgroundCopyFile2Vtbl BackgroundCopyFile2Vtbl =
 151 {
 152     BackgroundCopyFile_QueryInterface,
 153     BackgroundCopyFile_AddRef,
 154     BackgroundCopyFile_Release,
 155     BackgroundCopyFile_GetRemoteName,
 156     BackgroundCopyFile_GetLocalName,
 157     BackgroundCopyFile_GetProgress,
 158     BackgroundCopyFile_GetFileRanges,
 159     BackgroundCopyFile_SetRemoteName
 160 };
 161
 162 HRESULT BackgroundCopyFileConstructor(BackgroundCopyJobImpl *owner,
 163                                       LPCWSTR remoteName, LPCWSTR localName,
 164                                       BackgroundCopyFileImpl **file)
 165 {
 166     BackgroundCopyFileImpl *This;
 167
 168     TRACE("(%s, %s, %p)\n", debugstr_w(remoteName), debugstr_w(localName), file);
 169
 170     This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
 171     if (!This)
 172         return E_OUTOFMEMORY;
 173
 174     This->info.RemoteName = strdupW(remoteName);
 175     if (!This->info.RemoteName)
 176     {
 177         HeapFree(GetProcessHeap(), 0, This);
 178         return E_OUTOFMEMORY;
 179     }
 180
 181     This->info.LocalName = strdupW(localName);
 182     if (!This->info.LocalName)
 183     {
 184         HeapFree(GetProcessHeap(), 0, This->info.RemoteName);
 185         HeapFree(GetProcessHeap(), 0, This);
 186         return E_OUTOFMEMORY;
 187     }
 188
 189     This->IBackgroundCopyFile2_iface.lpVtbl = &BackgroundCopyFile2Vtbl;
 190     This->ref = 1;
 191
 192     This->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
 193     This->fileProgress.BytesTransferred = 0;
 194     This->fileProgress.Completed = FALSE;
 195     This->owner = owner;
 196     This->read_size = 0;
 197     This->tempFileName[0] = 0;
 198     IBackgroundCopyJob4_AddRef(&owner->IBackgroundCopyJob4_iface);
 199
 200     *file = This;
 201     return S_OK;
 202 }
 203
 204 static HRESULT hresult_from_http_response(DWORD code)
 205 {
 206     switch (code)
 207     {
 208     case 200: return S_OK;
 209     case 400: return BG_E_HTTP_ERROR_400;
 210     case 401: return BG_E_HTTP_ERROR_401;
 211     case 404: return BG_E_HTTP_ERROR_404;
 212     case 407: return BG_E_HTTP_ERROR_407;
 213     case 414: return BG_E_HTTP_ERROR_414;
 214     case 501: return BG_E_HTTP_ERROR_501;
 215     case 503: return BG_E_HTTP_ERROR_503;
 216     case 504: return BG_E_HTTP_ERROR_504;
 217     case 505: return BG_E_HTTP_ERROR_505;
 218     default:
 219         FIXME("unhandled response code %u\n", code);
 220         return S_OK;
 221     }
 222 }
 223
 224 static void CALLBACK progress_callback_http(HINTERNET handle, DWORD_PTR context, DWORD status,
 225                                             LPVOID buf, DWORD buflen)
 226 {
 227     BackgroundCopyFileImpl *file = (BackgroundCopyFileImpl *)context;
 228     BackgroundCopyJobImpl *job = file->owner;
 229
 230     TRACE("%p, %p, %x, %p, %u\n", handle, file, status, buf, buflen);
 231
 232     switch (status)
 233     {
 234     case WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE:
 235     {
 236         DWORD code, len, size;
 237
 238         size = sizeof(code);
 239         if (WinHttpQueryHeaders(handle, WINHTTP_QUERY_STATUS_CODE|WINHTTP_QUERY_FLAG_NUMBER,
 240                                 NULL, &code, &size, NULL))
 241         {
 242             if ((job->error.code = hresult_from_http_response(code)))
 243             {
 244                 EnterCriticalSection(&job->cs);
 245
 246                 job->error.context = BG_ERROR_CONTEXT_REMOTE_FILE;
 247                 if (job->error.file) IBackgroundCopyFile2_Release(job->error.file);
 248                 job->error.file = &file->IBackgroundCopyFile2_iface;
 249                 IBackgroundCopyFile2_AddRef(job->error.file);
 250
 251                 LeaveCriticalSection(&job->cs);
 252                 transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
 253             }
 254             else
 255             {
 256                 EnterCriticalSection(&job->cs);
 257
 258                 job->error.context = 0;
 259                 if (job->error.file)
 260                 {
 261                     IBackgroundCopyFile2_Release(job->error.file);
 262                     job->error.file = NULL;
 263                 }
 264
 265                 LeaveCriticalSection(&job->cs);
 266             }
 267         }
 268         size = sizeof(len);
 269         if (WinHttpQueryHeaders(handle, WINHTTP_QUERY_CONTENT_LENGTH|WINHTTP_QUERY_FLAG_NUMBER,
 270                                 NULL, &len, &size, NULL))
 271         {
 272             file->fileProgress.BytesTotal = len;
 273         }
 274         break;
 275     }
 276     case WINHTTP_CALLBACK_STATUS_READ_COMPLETE:
 277     {
 278         file->read_size = buflen;
 279         break;
 280     }
 281     case WINHTTP_CALLBACK_STATUS_REQUEST_ERROR:
 282     {
 283         WINHTTP_ASYNC_RESULT *result = (WINHTTP_ASYNC_RESULT *)buf;
 284         job->error.code = HRESULT_FROM_WIN32(result->dwError);
 285         transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
 286         break;
 287     }
 288     default: break;
 289     }
 290
 291     SetEvent(job->wait);
 292 }
 293
 294 static DWORD wait_for_completion(BackgroundCopyJobImpl *job)
 295 {
 296     HANDLE handles[2] = {job->wait, job->cancel};
 297     DWORD error = ERROR_SUCCESS;
 298
 299     switch (WaitForMultipleObjects(2, handles, FALSE, INFINITE))
 300     {
 301     case WAIT_OBJECT_0:
 302         break;
 303
 304     case WAIT_OBJECT_0 + 1:
 305         error = ERROR_CANCELLED;
 306         transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_CANCELLED);
 307         break;
 308
 309     default:
 310         error = GetLastError();
 311         transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
 312         break;
 313     }
 314
 315     return error;
 316 }
 317
 318 static UINT target_from_index(UINT index)
 319 {
 320     switch (index)
 321     {
 322     case 0: return WINHTTP_AUTH_TARGET_SERVER;
 323     case 1: return WINHTTP_AUTH_TARGET_PROXY;
 324     default:
 325         ERR("unhandled index %u\n", index);
 326         break;
 327     }
 328     return 0;
 329 }
 330
 331 static UINT scheme_from_index(UINT index)
 332 {
 333     switch (index)
 334     {
 335     case 0: return WINHTTP_AUTH_SCHEME_BASIC;
 336     case 1: return WINHTTP_AUTH_SCHEME_NTLM;
 337     case 2: return WINHTTP_AUTH_SCHEME_PASSPORT;
 338     case 3: return WINHTTP_AUTH_SCHEME_DIGEST;
 339     case 4: return WINHTTP_AUTH_SCHEME_NEGOTIATE;
 340     default:
 341         ERR("unhandled index %u\n", index);
 342         break;
 343     }
 344     return 0;
 345 }
 346
 347 static BOOL set_request_credentials(HINTERNET req, BackgroundCopyJobImpl *job)
 348 {
 349     UINT i, j;
 350
 351     for (i = 0; i < BG_AUTH_TARGET_PROXY; i++)
 352     {
 353         UINT target = target_from_index(i);
 354         for (j = 0; j < BG_AUTH_SCHEME_PASSPORT; j++)
 355         {
 356             UINT scheme = scheme_from_index(j);
 357             const WCHAR *username = job->http_options.creds[i][j].Credentials.Basic.UserName;
 358             const WCHAR *password = job->http_options.creds[i][j].Credentials.Basic.Password;
 359
 360             if (!username) continue;
 361             if (!WinHttpSetCredentials(req, target, scheme, username, password, NULL)) return FALSE;
 362         }
 363     }
 364     return TRUE;
 365 }
 366
 367 static BOOL transfer_file_http(BackgroundCopyFileImpl *file, URL_COMPONENTSW *uc,
 368                                const WCHAR *tmpfile)
 369 {
 370     BackgroundCopyJobImpl *job = file->owner;
 371     HANDLE handle;
 372     HINTERNET ses, con = NULL, req = NULL;
 373     DWORD flags = (uc->nScheme == INTERNET_SCHEME_HTTPS) ? WINHTTP_FLAG_SECURE : 0;
 374     char buf[4096];
 375     BOOL ret = FALSE;
 376     DWORD written;
 377
 378     transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_CONNECTING);
 379
 380     if (!(ses = WinHttpOpen(NULL, 0, NULL, NULL, WINHTTP_FLAG_ASYNC))) return FALSE;
 381     WinHttpSetStatusCallback(ses, progress_callback_http, WINHTTP_CALLBACK_FLAG_ALL_COMPLETIONS, 0);
 382     if (!WinHttpSetOption(ses, WINHTTP_OPTION_CONTEXT_VALUE, &file, sizeof(file))) goto done;
 383
 384     if (!(con = WinHttpConnect(ses, uc->lpszHostName, uc->nPort, 0))) goto done;
 385     if (!(req = WinHttpOpenRequest(con, NULL, uc->lpszUrlPath, NULL, NULL, NULL, flags))) goto done;
 386     if (!set_request_credentials(req, job)) goto done;
 387
 388     if (!(WinHttpSendRequest(req, job->http_options.headers, ~0u, NULL, 0, 0, (DWORD_PTR)file))) goto done;
 389     if (wait_for_completion(job) || FAILED(job->error.code)) goto done;
 390
 391     if (!(WinHttpReceiveResponse(req, NULL))) goto done;
 392     if (wait_for_completion(job) || FAILED(job->error.code)) goto done;
 393
 394     transitionJobState(job, BG_JOB_STATE_CONNECTING, BG_JOB_STATE_TRANSFERRING);
 395
 396     handle = CreateFileW(tmpfile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 397     if (handle == INVALID_HANDLE_VALUE) goto done;
 398
 399     for (;;)
 400     {
 401         file->read_size = 0;
 402         if (!(ret = WinHttpReadData(req, buf, sizeof(buf), NULL))) break;
 403         if (wait_for_completion(job) || FAILED(job->error.code))
 404         {
 405             ret = FALSE;
 406             break;
 407         }
 408         if (!file->read_size) break;
 409         if (!(ret = WriteFile(handle, buf, file->read_size, &written, NULL))) break;
 410
 411         EnterCriticalSection(&job->cs);
 412         file->fileProgress.BytesTransferred += file->read_size;
 413         job->jobProgress.BytesTransferred += file->read_size;
 414         LeaveCriticalSection(&job->cs);
 415     }
 416
 417     CloseHandle(handle);
 418
 419 done:
 420     WinHttpCloseHandle(req);
 421     WinHttpCloseHandle(con);
 422     WinHttpCloseHandle(ses);
 423     if (!ret && !transitionJobState(job, BG_JOB_STATE_CONNECTING, BG_JOB_STATE_ERROR))
 424         transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
 425
 426     SetEvent(job->done);
 427     return ret;
 428 }
 429
 430 static DWORD CALLBACK progress_callback_local(LARGE_INTEGER totalSize, LARGE_INTEGER totalTransferred,
 431                                               LARGE_INTEGER streamSize, LARGE_INTEGER streamTransferred,
 432                                               DWORD streamNum, DWORD reason, HANDLE srcFile,
 433                                               HANDLE dstFile, LPVOID obj)
 434 {
 435     BackgroundCopyFileImpl *file = obj;
 436     BackgroundCopyJobImpl *job = file->owner;
 437     ULONG64 diff;
 438
 439     EnterCriticalSection(&job->cs);
 440     diff = (file->fileProgress.BytesTotal == BG_SIZE_UNKNOWN
 441             ? totalTransferred.QuadPart
 442             : totalTransferred.QuadPart - file->fileProgress.BytesTransferred);
 443     file->fileProgress.BytesTotal = totalSize.QuadPart;
 444     file->fileProgress.BytesTransferred = totalTransferred.QuadPart;
 445     job->jobProgress.BytesTransferred += diff;
 446     LeaveCriticalSection(&job->cs);
 447
 448     return (job->state == BG_JOB_STATE_TRANSFERRING
 449             ? PROGRESS_CONTINUE
 450             : PROGRESS_CANCEL);
 451 }
 452
 453 static BOOL transfer_file_local(BackgroundCopyFileImpl *file, const WCHAR *tmpname)
 454 {
 455     BackgroundCopyJobImpl *job = file->owner;
 456     const WCHAR *ptr;
 457     BOOL ret;
 458
 459     transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSFERRING);
 460
 461     if (lstrlenW(file->info.RemoteName) > 7 && !wcsnicmp(file->info.RemoteName, L"file://", 7))
 462         ptr = file->info.RemoteName + 7;
 463     else
 464         ptr = file->info.RemoteName;
 465
 466     if (!(ret = CopyFileExW(ptr, tmpname, progress_callback_local, file, NULL, 0)))
 467     {
 468         WARN("Local file copy failed: error %u\n", GetLastError());
 469         transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
 470     }
 471
 472     SetEvent(job->done);
 473     return ret;
 474 }
 475
 476 BOOL processFile(BackgroundCopyFileImpl *file, BackgroundCopyJobImpl *job)
 477 {
 478     WCHAR tmpDir[MAX_PATH], tmpName[MAX_PATH];
 479     WCHAR host[MAX_PATH];
 480     URL_COMPONENTSW uc;
 481     BOOL ret;
 482
 483     if (!GetTempPathW(MAX_PATH, tmpDir))
 484     {
 485         ERR("Couldn't create temp file name: %d\n", GetLastError());
 486         /* Guessing on what state this should give us */
 487         transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
 488         return FALSE;
 489     }
 490
 491     if (!GetTempFileNameW(tmpDir, L"BIT", 0, tmpName))
 492     {
 493         ERR("Couldn't create temp file: %d\n", GetLastError());
 494         /* Guessing on what state this should give us */
 495         transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
 496         return FALSE;
 497     }
 498
 499     EnterCriticalSection(&job->cs);
 500     file->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
 501     file->fileProgress.BytesTransferred = 0;
 502     file->fileProgress.Completed = FALSE;
 503     LeaveCriticalSection(&job->cs);
 504
 505     TRACE("Transferring: %s -> %s -> %s\n",
 506           debugstr_w(file->info.RemoteName),
 507           debugstr_w(tmpName),
 508           debugstr_w(file->info.LocalName));
 509
 510     uc.dwStructSize      = sizeof(uc);
 511     uc.nScheme           = 0;
 512     uc.lpszScheme        = NULL;
 513     uc.dwSchemeLength    = 0;
 514     uc.lpszUserName      = NULL;
 515     uc.dwUserNameLength  = 0;
 516     uc.lpszPassword      = NULL;
 517     uc.dwPasswordLength  = 0;
 518     uc.lpszHostName      = host;
 519     uc.dwHostNameLength  = ARRAY_SIZE(host);
 520     uc.nPort             = 0;
 521     uc.lpszUrlPath       = NULL;
 522     uc.dwUrlPathLength   = ~0u;
 523     uc.lpszExtraInfo     = NULL;
 524     uc.dwExtraInfoLength = 0;
 525     ret = WinHttpCrackUrl(file->info.RemoteName, 0, 0, &uc);
 526     if (!ret)
 527     {
 528         TRACE("WinHttpCrackUrl failed, trying local file copy\n");
 529         if (!transfer_file_local(file, tmpName)) WARN("local transfer failed\n");
 530     }
 531     else if (!transfer_file_http(file, &uc, tmpName)) WARN("HTTP transfer failed\n");
 532
 533     if (transitionJobState(job, BG_JOB_STATE_CONNECTING, BG_JOB_STATE_QUEUED) ||
 534         transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_QUEUED))
 535     {
 536         lstrcpyW(file->tempFileName, tmpName);
 537
 538         EnterCriticalSection(&job->cs);
 539         file->fileProgress.Completed = TRUE;
 540         job->jobProgress.FilesTransferred++;
 541         LeaveCriticalSection(&job->cs);
 542
 543         return TRUE;
 544     }
 545     else
 546     {
 547         DeleteFileW(tmpName);
 548         return FALSE;
 549     }
 550 }