file.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winreg.h"
#include "winhttp.h"
#include "qmgr.h"
#include "wine/debug.h"

Include dependency graph for file.c:

Go to the source code of this file.

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (qmgr)
static BackgroundCopyFileImpl *	impl_from_IBackgroundCopyFile2 (IBackgroundCopyFile2 *iface)
static HRESULT WINAPI	BackgroundCopyFile_QueryInterface (IBackgroundCopyFile2 *iface, REFIID riid, void **obj)
static ULONG WINAPI	BackgroundCopyFile_AddRef (IBackgroundCopyFile2 *iface)
static ULONG WINAPI	BackgroundCopyFile_Release (IBackgroundCopyFile2 *iface)
static HRESULT WINAPI	BackgroundCopyFile_GetRemoteName (IBackgroundCopyFile2 *iface, LPWSTR *pVal)
static HRESULT WINAPI	BackgroundCopyFile_GetLocalName (IBackgroundCopyFile2 *iface, LPWSTR *pVal)
static HRESULT WINAPI	BackgroundCopyFile_GetProgress (IBackgroundCopyFile2 *iface, BG_FILE_PROGRESS *pVal)
static HRESULT WINAPI	BackgroundCopyFile_GetFileRanges (IBackgroundCopyFile2 *iface, DWORD *RangeCount, BG_FILE_RANGE **Ranges)
static HRESULT WINAPI	BackgroundCopyFile_SetRemoteName (IBackgroundCopyFile2 *iface, LPCWSTR Val)
HRESULT	BackgroundCopyFileConstructor (BackgroundCopyJobImpl *owner, LPCWSTR remoteName, LPCWSTR localName, BackgroundCopyFileImpl **file)
static HRESULT	hresult_from_http_response (DWORD code)
static void CALLBACK	progress_callback_http (HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buf, DWORD buflen)
static DWORD	wait_for_completion (BackgroundCopyJobImpl *job)
static UINT	target_from_index (UINT index)
static UINT	scheme_from_index (UINT index)
static BOOL	set_request_credentials (HINTERNET req, BackgroundCopyJobImpl *job)
static BOOL	transfer_file_http (BackgroundCopyFileImpl *file, URL_COMPONENTSW *uc, const WCHAR *tmpfile)
static DWORD CALLBACK	progress_callback_local (LARGE_INTEGER totalSize, LARGE_INTEGER totalTransferred, LARGE_INTEGER streamSize, LARGE_INTEGER streamTransferred, DWORD streamNum, DWORD reason, HANDLE srcFile, HANDLE dstFile, LPVOID obj)
static BOOL	transfer_file_local (BackgroundCopyFileImpl *file, const WCHAR *tmpname)
BOOL	processFile (BackgroundCopyFileImpl *file, BackgroundCopyJobImpl *job)

Variables
static const IBackgroundCopyFile2Vtbl	BackgroundCopyFile2Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 28 of file file.c.

Function Documentation

BackgroundCopyFile_AddRef()

static ULONG WINAPI BackgroundCopyFile_AddRef ( IBackgroundCopyFile2 *  iface )

static

Definition at line 65 of file file.c.

{
    BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
    ULONG ref = InterlockedIncrement(&file->ref);
    TRACE("(%p)->(%d)\n", file, ref);
    return ref;
}

BackgroundCopyFile_GetFileRanges()

static HRESULT WINAPI BackgroundCopyFile_GetFileRanges ( IBackgroundCopyFile2 *  iface, DWORD *  RangeCount, BG_FILE_RANGE **  Ranges  )

static

Definition at line 131 of file file.c.

{
    BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
    FIXME("(%p)->(%p %p)\n", file, RangeCount, Ranges);
    return E_NOTIMPL;
}

BackgroundCopyFile_GetLocalName()

static HRESULT WINAPI BackgroundCopyFile_GetLocalName ( IBackgroundCopyFile2 *  iface, LPWSTR *  pVal  )

static

Definition at line 105 of file file.c.

{
    BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
 
    TRACE("(%p)->(%p)\n", file, pVal);
 
    return return_strval(file->info.LocalName, pVal);
}

BackgroundCopyFile_GetProgress()

static HRESULT WINAPI BackgroundCopyFile_GetProgress ( IBackgroundCopyFile2 *  iface, BG_FILE_PROGRESS *  pVal  )

static

Definition at line 116 of file file.c.

{
    BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
 
    TRACE("(%p)->(%p)\n", file, pVal);
 
    EnterCriticalSection(&file->owner->cs);
    *pVal = file->fileProgress;
    LeaveCriticalSection(&file->owner->cs);
 
    return S_OK;
}

BackgroundCopyFile_GetRemoteName()

static HRESULT WINAPI BackgroundCopyFile_GetRemoteName ( IBackgroundCopyFile2 *  iface, LPWSTR *  pVal  )

static

Definition at line 94 of file file.c.

{
    BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
 
    TRACE("(%p)->(%p)\n", file, pVal);
 
    return return_strval(file->info.RemoteName, pVal);
}

BackgroundCopyFile_QueryInterface()

static HRESULT WINAPI BackgroundCopyFile_QueryInterface ( IBackgroundCopyFile2 *  iface, REFIID  riid, void **  obj  )

static

Definition at line 40 of file file.c.

{
    BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
 
    TRACE("(%p)->(%s %p)\n", file, debugstr_guid(riid), obj);
 
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IBackgroundCopyFile) ||
        IsEqualGUID(riid, &IID_IBackgroundCopyFile2))
    {
        *obj = iface;
    }
    else
    {
        *obj = NULL;
        return E_NOINTERFACE;
    }
 
    IBackgroundCopyFile2_AddRef(iface);
    return S_OK;
}

BackgroundCopyFile_Release()

static ULONG WINAPI BackgroundCopyFile_Release ( IBackgroundCopyFile2 *  iface )

static

Definition at line 74 of file file.c.

{
    BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
    ULONG ref = InterlockedDecrement(&file->ref);
 
    TRACE("(%p)->(%d)\n", file, ref);
 
    if (ref == 0)
    {
        IBackgroundCopyJob3_Release(&file->owner->IBackgroundCopyJob3_iface);
        HeapFree(GetProcessHeap(), 0, file->info.LocalName);
        HeapFree(GetProcessHeap(), 0, file->info.RemoteName);
        HeapFree(GetProcessHeap(), 0, file);
    }
 
    return ref;
}

BackgroundCopyFile_SetRemoteName()

static HRESULT WINAPI BackgroundCopyFile_SetRemoteName ( IBackgroundCopyFile2 *  iface, LPCWSTR  Val  )

static

Definition at line 141 of file file.c.

{
    BackgroundCopyFileImpl *file = impl_from_IBackgroundCopyFile2(iface);
    FIXME("(%p)->(%s)\n", file, debugstr_w(Val));
    return E_NOTIMPL;
}

BackgroundCopyFileConstructor()

HRESULT BackgroundCopyFileConstructor	(	BackgroundCopyJobImpl *	owner,
		LPCWSTR	remoteName,
		LPCWSTR	localName,
		BackgroundCopyFileImpl **	file
	)

Definition at line 162 of file file.c.

{
    BackgroundCopyFileImpl *This;
 
    TRACE("(%s, %s, %p)\n", debugstr_w(remoteName), debugstr_w(localName), file);
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
    if (!This)
        return E_OUTOFMEMORY;
 
    This->info.RemoteName = strdupW(remoteName);
    if (!This->info.RemoteName)
    {
        HeapFree(GetProcessHeap(), 0, This);
        return E_OUTOFMEMORY;
    }
 
    This->info.LocalName = strdupW(localName);
    if (!This->info.LocalName)
    {
        HeapFree(GetProcessHeap(), 0, This->info.RemoteName);
        HeapFree(GetProcessHeap(), 0, This);
        return E_OUTOFMEMORY;
    }
 
    This->IBackgroundCopyFile2_iface.lpVtbl = &BackgroundCopyFile2Vtbl;
    This->ref = 1;
 
    This->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
    This->fileProgress.BytesTransferred = 0;
    This->fileProgress.Completed = FALSE;
    This->owner = owner;
    This->read_size = 0;
    This->tempFileName[0] = 0;
    IBackgroundCopyJob3_AddRef(&owner->IBackgroundCopyJob3_iface);
 
    *file = This;
    return S_OK;
}

Referenced by BackgroundCopyJob_AddFileSet().

hresult_from_http_response()

static HRESULT hresult_from_http_response ( DWORD  code )

static

Definition at line 204 of file file.c.

{
    switch (code)
    {
    case 200: return S_OK;
    case 400: return BG_E_HTTP_ERROR_400;
    case 401: return BG_E_HTTP_ERROR_401;
    case 404: return BG_E_HTTP_ERROR_404;
    case 407: return BG_E_HTTP_ERROR_407;
    case 414: return BG_E_HTTP_ERROR_414;
    case 501: return BG_E_HTTP_ERROR_501;
    case 503: return BG_E_HTTP_ERROR_503;
    case 504: return BG_E_HTTP_ERROR_504;
    case 505: return BG_E_HTTP_ERROR_505;
    default:
        FIXME("unhandled response code %u\n", code);
        return S_OK;
    }
}

Referenced by progress_callback_http().

impl_from_IBackgroundCopyFile2()

static BackgroundCopyFileImpl * impl_from_IBackgroundCopyFile2 ( IBackgroundCopyFile2 *  iface )

inlinestatic

Definition at line 34 of file file.c.

{
    return CONTAINING_RECORD(iface, BackgroundCopyFileImpl, IBackgroundCopyFile2_iface);
}

Referenced by BackgroundCopyFile_AddRef(), BackgroundCopyFile_GetFileRanges(), BackgroundCopyFile_GetLocalName(), BackgroundCopyFile_GetProgress(), BackgroundCopyFile_GetRemoteName(), BackgroundCopyFile_QueryInterface(), BackgroundCopyFile_Release(), and BackgroundCopyFile_SetRemoteName().

processFile()

BOOL processFile	(	BackgroundCopyFileImpl *	file,
		BackgroundCopyJobImpl *	job
	)

Definition at line 477 of file file.c.

{
    static const WCHAR prefix[] = {'B','I','T', 0};
    WCHAR tmpDir[MAX_PATH], tmpName[MAX_PATH];
    WCHAR host[MAX_PATH];
    URL_COMPONENTSW uc;
    BOOL ret;
 
    if (!GetTempPathW(MAX_PATH, tmpDir))
    {
        ERR("Couldn't create temp file name: %d\n", GetLastError());
        /* Guessing on what state this should give us */
        transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
        return FALSE;
    }
 
    if (!GetTempFileNameW(tmpDir, prefix, 0, tmpName))
    {
        ERR("Couldn't create temp file: %d\n", GetLastError());
        /* Guessing on what state this should give us */
        transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSIENT_ERROR);
        return FALSE;
    }
 
    EnterCriticalSection(&job->cs);
    file->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
    file->fileProgress.BytesTransferred = 0;
    file->fileProgress.Completed = FALSE;
    LeaveCriticalSection(&job->cs);
 
    TRACE("Transferring: %s -> %s -> %s\n",
          debugstr_w(file->info.RemoteName),
          debugstr_w(tmpName),
          debugstr_w(file->info.LocalName));
 
    uc.dwStructSize      = sizeof(uc);
    uc.nScheme           = 0;
    uc.lpszScheme        = NULL;
    uc.dwSchemeLength    = 0;
    uc.lpszUserName      = NULL;
    uc.dwUserNameLength  = 0;
    uc.lpszPassword      = NULL;
    uc.dwPasswordLength  = 0;
    uc.lpszHostName      = host;
    uc.dwHostNameLength  = ARRAY_SIZE(host);
    uc.nPort             = 0;
    uc.lpszUrlPath       = NULL;
    uc.dwUrlPathLength   = ~0u;
    uc.lpszExtraInfo     = NULL;
    uc.dwExtraInfoLength = 0;
    ret = WinHttpCrackUrl(file->info.RemoteName, 0, 0, &uc);
    if (!ret)
    {
        TRACE("WinHttpCrackUrl failed, trying local file copy\n");
        if (!transfer_file_local(file, tmpName)) WARN("local transfer failed\n");
    }
    else if (!transfer_file_http(file, &uc, tmpName)) WARN("HTTP transfer failed\n");
 
    if (transitionJobState(job, BG_JOB_STATE_CONNECTING, BG_JOB_STATE_QUEUED) ||
        transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_QUEUED))
    {
        lstrcpyW(file->tempFileName, tmpName);
 
        EnterCriticalSection(&job->cs);
        file->fileProgress.Completed = TRUE;
        job->jobProgress.FilesTransferred++;
        LeaveCriticalSection(&job->cs);
 
        return TRUE;
    }
    else
    {
        DeleteFileW(tmpName);
        return FALSE;
    }
}

Referenced by processJob().

progress_callback_http()

static void CALLBACK progress_callback_http ( HINTERNET  handle, DWORD_PTR  context, DWORD  status, LPVOID  buf, DWORD  buflen  )

static

Definition at line 224 of file file.c.

{
    BackgroundCopyFileImpl *file = (BackgroundCopyFileImpl *)context;
    BackgroundCopyJobImpl *job = file->owner;
 
    TRACE("%p, %p, %x, %p, %u\n", handle, file, status, buf, buflen);
 
    switch (status)
    {
    case WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE:
    {
        DWORD code, len, size;
 
        size = sizeof(code);
        if (WinHttpQueryHeaders(handle, WINHTTP_QUERY_STATUS_CODE|WINHTTP_QUERY_FLAG_NUMBER,
                                NULL, &code, &size, NULL))
        {
            if ((job->error.code = hresult_from_http_response(code)))
            {
                EnterCriticalSection(&job->cs);
 
                job->error.context = BG_ERROR_CONTEXT_REMOTE_FILE;
                if (job->error.file) IBackgroundCopyFile2_Release(job->error.file);
                job->error.file = &file->IBackgroundCopyFile2_iface;
                IBackgroundCopyFile2_AddRef(job->error.file);
 
                LeaveCriticalSection(&job->cs);
                transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
            }
            else
            {
                EnterCriticalSection(&job->cs);
 
                job->error.context = 0;
                if (job->error.file)
                {
                    IBackgroundCopyFile2_Release(job->error.file);
                    job->error.file = NULL;
                }
 
                LeaveCriticalSection(&job->cs);
            }
        }
        size = sizeof(len);
        if (WinHttpQueryHeaders(handle, WINHTTP_QUERY_CONTENT_LENGTH|WINHTTP_QUERY_FLAG_NUMBER,
                                NULL, &len, &size, NULL))
        {
            file->fileProgress.BytesTotal = len;
        }
        break;
    }
    case WINHTTP_CALLBACK_STATUS_READ_COMPLETE:
    {
        file->read_size = buflen;
        break;
    }
    case WINHTTP_CALLBACK_STATUS_REQUEST_ERROR:
    {
        WINHTTP_ASYNC_RESULT *result = (WINHTTP_ASYNC_RESULT *)buf;
        job->error.code = HRESULT_FROM_WIN32(result->dwError);
        transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
        break;
    }
    default: break;
    }
 
    SetEvent(job->wait);
}

Referenced by transfer_file_http().

progress_callback_local()

static DWORD CALLBACK progress_callback_local ( LARGE_INTEGER  totalSize, LARGE_INTEGER  totalTransferred, LARGE_INTEGER  streamSize, LARGE_INTEGER  streamTransferred, DWORD  streamNum, DWORD  reason, HANDLE  srcFile, HANDLE  dstFile, LPVOID  obj  )

static

Definition at line 430 of file file.c.

{
    BackgroundCopyFileImpl *file = obj;
    BackgroundCopyJobImpl *job = file->owner;
    ULONG64 diff;
 
    EnterCriticalSection(&job->cs);
    diff = (file->fileProgress.BytesTotal == BG_SIZE_UNKNOWN
            ? totalTransferred.QuadPart
            : totalTransferred.QuadPart - file->fileProgress.BytesTransferred);
    file->fileProgress.BytesTotal = totalSize.QuadPart;
    file->fileProgress.BytesTransferred = totalTransferred.QuadPart;
    job->jobProgress.BytesTransferred += diff;
    LeaveCriticalSection(&job->cs);
 
    return (job->state == BG_JOB_STATE_TRANSFERRING
            ? PROGRESS_CONTINUE
            : PROGRESS_CANCEL);
}

Referenced by transfer_file_local().

scheme_from_index()

static UINT scheme_from_index ( UINT  index )

static

Definition at line 331 of file file.c.

{
    switch (index)
    {
    case 0: return WINHTTP_AUTH_SCHEME_BASIC;
    case 1: return WINHTTP_AUTH_SCHEME_NTLM;
    case 2: return WINHTTP_AUTH_SCHEME_PASSPORT;
    case 3: return WINHTTP_AUTH_SCHEME_DIGEST;
    case 4: return WINHTTP_AUTH_SCHEME_NEGOTIATE;
    default:
        ERR("unhandled index %u\n", index);
        break;
    }
    return 0;
}

Referenced by set_request_credentials().

set_request_credentials()

static BOOL set_request_credentials ( HINTERNET  req, BackgroundCopyJobImpl *  job  )

static

Definition at line 347 of file file.c.

{
    UINT i, j;
 
    for (i = 0; i < BG_AUTH_TARGET_PROXY; i++)
    {
        UINT target = target_from_index(i);
        for (j = 0; j < BG_AUTH_SCHEME_PASSPORT; j++)
        {
            UINT scheme = scheme_from_index(j);
            const WCHAR *username = job->http_options.creds[i][j].Credentials.Basic.UserName;
            const WCHAR *password = job->http_options.creds[i][j].Credentials.Basic.Password;
 
            if (!username) continue;
            if (!WinHttpSetCredentials(req, target, scheme, username, password, NULL)) return FALSE;
        }
    }
    return TRUE;
}

Referenced by transfer_file_http().

target_from_index()

static UINT target_from_index ( UINT  index )

static

Definition at line 318 of file file.c.

{
    switch (index)
    {
    case 0: return WINHTTP_AUTH_TARGET_SERVER;
    case 1: return WINHTTP_AUTH_TARGET_PROXY;
    default:
        ERR("unhandled index %u\n", index);
        break;
    }
    return 0;
}

Referenced by set_request_credentials().

transfer_file_http()

static BOOL transfer_file_http ( BackgroundCopyFileImpl *  file, URL_COMPONENTSW *  uc, const WCHAR *  tmpfile  )

static

Definition at line 367 of file file.c.

{
    BackgroundCopyJobImpl *job = file->owner;
    HANDLE handle;
    HINTERNET ses, con = NULL, req = NULL;
    DWORD flags = (uc->nScheme == INTERNET_SCHEME_HTTPS) ? WINHTTP_FLAG_SECURE : 0;
    char buf[4096];
    BOOL ret = FALSE;
    DWORD written;
 
    transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_CONNECTING);
 
    if (!(ses = WinHttpOpen(NULL, 0, NULL, NULL, WINHTTP_FLAG_ASYNC))) return FALSE;
    WinHttpSetStatusCallback(ses, progress_callback_http, WINHTTP_CALLBACK_FLAG_ALL_COMPLETIONS, 0);
    if (!WinHttpSetOption(ses, WINHTTP_OPTION_CONTEXT_VALUE, &file, sizeof(file))) goto done;
 
    if (!(con = WinHttpConnect(ses, uc->lpszHostName, uc->nPort, 0))) goto done;
    if (!(req = WinHttpOpenRequest(con, NULL, uc->lpszUrlPath, NULL, NULL, NULL, flags))) goto done;
    if (!set_request_credentials(req, job)) goto done;
 
    if (!(WinHttpSendRequest(req, job->http_options.headers, ~0u, NULL, 0, 0, (DWORD_PTR)file))) goto done;
    if (wait_for_completion(job) || FAILED(job->error.code)) goto done;
 
    if (!(WinHttpReceiveResponse(req, NULL))) goto done;
    if (wait_for_completion(job) || FAILED(job->error.code)) goto done;
 
    transitionJobState(job, BG_JOB_STATE_CONNECTING, BG_JOB_STATE_TRANSFERRING);
 
    handle = CreateFileW(tmpfile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (handle == INVALID_HANDLE_VALUE) goto done;
 
    for (;;)
    {
        file->read_size = 0;
        if (!(ret = WinHttpReadData(req, buf, sizeof(buf), NULL))) break;
        if (wait_for_completion(job) || FAILED(job->error.code))
        {
            ret = FALSE;
            break;
        }
        if (!file->read_size) break;
        if (!(ret = WriteFile(handle, buf, file->read_size, &written, NULL))) break;
 
        EnterCriticalSection(&job->cs);
        file->fileProgress.BytesTransferred += file->read_size;
        job->jobProgress.BytesTransferred += file->read_size;
        LeaveCriticalSection(&job->cs);
    }
 
    CloseHandle(handle);
 
done:
    WinHttpCloseHandle(req);
    WinHttpCloseHandle(con);
    WinHttpCloseHandle(ses);
    if (!ret && !transitionJobState(job, BG_JOB_STATE_CONNECTING, BG_JOB_STATE_ERROR))
        transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
 
    SetEvent(job->done);
    return ret;
}

Referenced by processFile().

transfer_file_local()

static BOOL transfer_file_local ( BackgroundCopyFileImpl *  file, const WCHAR *  tmpname  )

static

Definition at line 453 of file file.c.

{
    static const WCHAR fileW[] = {'f','i','l','e',':','/','/',0};
    BackgroundCopyJobImpl *job = file->owner;
    const WCHAR *ptr;
    BOOL ret;
 
    transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSFERRING);
 
    if (lstrlenW(file->info.RemoteName) > 7 && !_wcsnicmp(file->info.RemoteName, fileW, 7))
        ptr = file->info.RemoteName + 7;
    else
        ptr = file->info.RemoteName;
 
    if (!(ret = CopyFileExW(ptr, tmpname, progress_callback_local, file, NULL, 0)))
    {
        WARN("Local file copy failed: error %u\n", GetLastError());
        transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
    }
 
    SetEvent(job->done);
    return ret;
}

Referenced by processFile().

wait_for_completion()

static DWORD wait_for_completion ( BackgroundCopyJobImpl *  job )

static

Definition at line 294 of file file.c.

{
    HANDLE handles[2] = {job->wait, job->cancel};
    DWORD error = ERROR_SUCCESS;
 
    switch (WaitForMultipleObjects(2, handles, FALSE, INFINITE))
    {
    case WAIT_OBJECT_0:
        break;
 
    case WAIT_OBJECT_0 + 1:
        error = ERROR_CANCELLED;
        transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_CANCELLED);
        break;
 
    default:
        error = GetLastError();
        transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
        break;
    }
 
    return error;
}

Referenced by transfer_file_http().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

qmgr

)

Variable Documentation

BackgroundCopyFile2Vtbl

const IBackgroundCopyFile2Vtbl BackgroundCopyFile2Vtbl

static

Initial value:

=
{
    BackgroundCopyFile_QueryInterface,
    BackgroundCopyFile_AddRef,
    BackgroundCopyFile_Release,
    BackgroundCopyFile_GetRemoteName,
    BackgroundCopyFile_GetLocalName,
    BackgroundCopyFile_GetProgress,
    BackgroundCopyFile_GetFileRanges,
    BackgroundCopyFile_SetRemoteName
}

Definition at line 150 of file file.c.

Referenced by BackgroundCopyFileConstructor().