qmgr.h File Reference

#include "windef.h"
#include "bits.h"
#include "bits1_5.h"
#include "bits2_0.h"
#include "bits2_5.h"
#include "bits3_0.h"
#include <string.h>
#include "wine/list.h"

Include dependency graph for qmgr.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	BackgroundCopyJobImpl
struct	BackgroundCopyFileImpl
struct	BackgroundCopyManagerImpl
struct	ClassFactoryImpl

Macros
#define	COBJMACROS

Functions
HRESULT	BackgroundCopyManagerConstructor (LPVOID *ppObj) DECLSPEC_HIDDEN
HRESULT	BackgroundCopyJobConstructor (LPCWSTR displayName, BG_JOB_TYPE type, GUID *pJobId, BackgroundCopyJobImpl **job) DECLSPEC_HIDDEN
HRESULT	enum_copy_job_create (BackgroundCopyManagerImpl *qmgr, IEnumBackgroundCopyJobs **enumjob) DECLSPEC_HIDDEN
HRESULT	BackgroundCopyFileConstructor (BackgroundCopyJobImpl *owner, LPCWSTR remoteName, LPCWSTR localName, BackgroundCopyFileImpl **file) DECLSPEC_HIDDEN
HRESULT	EnumBackgroundCopyFilesConstructor (BackgroundCopyJobImpl *, IEnumBackgroundCopyFiles **) DECLSPEC_HIDDEN
DWORD WINAPI	fileTransfer (void *param) DECLSPEC_HIDDEN
void	processJob (BackgroundCopyJobImpl *job) DECLSPEC_HIDDEN
BOOL	processFile (BackgroundCopyFileImpl *file, BackgroundCopyJobImpl *job) DECLSPEC_HIDDEN
BOOL	transitionJobState (BackgroundCopyJobImpl *job, BG_JOB_STATE from, BG_JOB_STATE to) DECLSPEC_HIDDEN
static WCHAR *	strdupW (const WCHAR *src)
static WCHAR *	co_strdupW (const WCHAR *src)
static HRESULT	return_strval (const WCHAR *str, WCHAR **ret)

Variables
HANDLE stop_event	DECLSPEC_HIDDEN

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 25 of file qmgr.h.

Function Documentation

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().

BackgroundCopyJobConstructor()

HRESULT BackgroundCopyJobConstructor	(	LPCWSTR	displayName,
		BG_JOB_TYPE	type,
		GUID *	pJobId,
		BackgroundCopyJobImpl **	job
	)

Definition at line 1197 of file job.c.

{
    HRESULT hr;
    BackgroundCopyJobImpl *This;
 
    TRACE("(%s,%d,%p)\n", debugstr_w(displayName), type, job);
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IBackgroundCopyJob3_iface.lpVtbl = &BackgroundCopyJob3Vtbl;
    This->IBackgroundCopyJobHttpOptions_iface.lpVtbl = &http_options_vtbl;
    InitializeCriticalSection(&This->cs);
    This->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BackgroundCopyJobImpl.cs");
 
    This->ref = 1;
    This->type = type;
 
    This->displayName = strdupW(displayName);
    if (!This->displayName)
    {
        This->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->cs);
        HeapFree(GetProcessHeap(), 0, This);
        return E_OUTOFMEMORY;
    }
 
    hr = CoCreateGuid(&This->jobId);
    if (FAILED(hr))
    {
        This->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->cs);
        HeapFree(GetProcessHeap(), 0, This->displayName);
        HeapFree(GetProcessHeap(), 0, This);
        return hr;
    }
    *job_id = This->jobId;
 
    list_init(&This->files);
    This->jobProgress.BytesTotal = 0;
    This->jobProgress.BytesTransferred = 0;
    This->jobProgress.FilesTotal = 0;
    This->jobProgress.FilesTransferred = 0;
 
    This->state = BG_JOB_STATE_SUSPENDED;
    This->description = NULL;
    This->notify_flags = BG_NOTIFY_JOB_ERROR | BG_NOTIFY_JOB_TRANSFERRED;
    This->callback = NULL;
    This->callback2 = FALSE;
 
    This->error.context = 0;
    This->error.code = S_OK;
    This->error.file = NULL;
 
    memset(&This->http_options, 0, sizeof(This->http_options));
 
    This->wait   = CreateEventW(NULL, FALSE, FALSE, NULL);
    This->cancel = CreateEventW(NULL, FALSE, FALSE, NULL);
    This->done   = CreateEventW(NULL, FALSE, FALSE, NULL);
 
    *job = This;
 
    TRACE("created job %s:%p\n", debugstr_guid(&This->jobId), This);
 
    return S_OK;
}

Referenced by BackgroundCopyManager_CreateJob().

BackgroundCopyManagerConstructor()

HRESULT BackgroundCopyManagerConstructor

(

LPVOID *

ppObj

)

Definition at line 141 of file qmgr.c.

{
    TRACE("(%p)\n", ppObj);
    *ppObj = &globalMgr;
    return S_OK;
}

Referenced by BITS_IClassFactory_CreateInstance().

co_strdupW()

static WCHAR * co_strdupW ( const WCHAR *  src )

inlinestatic

Definition at line 125 of file qmgr.h.

{
    WCHAR *dst = CoTaskMemAlloc((lstrlenW(src) + 1) * sizeof(WCHAR));
    if (dst) lstrcpyW(dst, src);
    return dst;
}

enum_copy_job_create()

HRESULT enum_copy_job_create	(	BackgroundCopyManagerImpl *	qmgr,
		IEnumBackgroundCopyJobs **	enumjob
	)

Definition at line 179 of file enum_jobs.c.

{
    EnumBackgroundCopyJobsImpl *This;
    BackgroundCopyJobImpl *job;
    ULONG i;
 
    TRACE("%p, %p)\n", qmgr, enumjob);
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
    if (!This)
        return E_OUTOFMEMORY;
    This->IEnumBackgroundCopyJobs_iface.lpVtbl = &EnumBackgroundCopyJobsVtbl;
    This->ref = 1;
 
    /* Create array of jobs */
    This->indexJobs = 0;
 
    EnterCriticalSection(&qmgr->cs);
    This->numJobs = list_count(&qmgr->jobs);
 
    if (0 < This->numJobs)
    {
        This->jobs = HeapAlloc(GetProcessHeap(), 0,
                               This->numJobs * sizeof *This->jobs);
        if (!This->jobs)
        {
            LeaveCriticalSection(&qmgr->cs);
            HeapFree(GetProcessHeap(), 0, This);
            return E_OUTOFMEMORY;
        }
    }
    else
        This->jobs = NULL;
 
    i = 0;
    LIST_FOR_EACH_ENTRY(job, &qmgr->jobs, BackgroundCopyJobImpl, entryFromQmgr)
    {
        IBackgroundCopyJob3_AddRef(&job->IBackgroundCopyJob3_iface);
        This->jobs[i++] = &job->IBackgroundCopyJob3_iface;
    }
    LeaveCriticalSection(&qmgr->cs);
 
    *enumjob = &This->IEnumBackgroundCopyJobs_iface;
    return S_OK;
}

Referenced by BackgroundCopyManager_EnumJobs().

EnumBackgroundCopyFilesConstructor()

HRESULT EnumBackgroundCopyFilesConstructor	(	BackgroundCopyJobImpl *	job,
		IEnumBackgroundCopyFiles **	enum_files
	)

Definition at line 183 of file enum_files.c.

{
    EnumBackgroundCopyFilesImpl *This;
    BackgroundCopyFileImpl *file;
    ULONG i;
 
    TRACE("%p, %p)\n", job, enum_files);
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IEnumBackgroundCopyFiles_iface.lpVtbl = &EnumBackgroundCopyFilesVtbl;
    This->ref = 1;
 
    /* Create array of files */
    This->indexFiles = 0;
    EnterCriticalSection(&job->cs);
    This->numFiles = list_count(&job->files);
    This->files = NULL;
    if (This->numFiles > 0)
    {
        This->files = HeapAlloc(GetProcessHeap(), 0,
                                This->numFiles * sizeof This->files[0]);
        if (!This->files)
        {
            LeaveCriticalSection(&job->cs);
            HeapFree(GetProcessHeap(), 0, This);
            return E_OUTOFMEMORY;
        }
    }
 
    i = 0;
    LIST_FOR_EACH_ENTRY(file, &job->files, BackgroundCopyFileImpl, entryFromJob)
    {
        IBackgroundCopyFile2_AddRef(&file->IBackgroundCopyFile2_iface);
        This->files[i] = &file->IBackgroundCopyFile2_iface;
        ++i;
    }
    LeaveCriticalSection(&job->cs);
 
    *enum_files = &This->IEnumBackgroundCopyFiles_iface;
    return S_OK;
}

Referenced by BackgroundCopyJob_EnumFiles().

fileTransfer()

DWORD WINAPI fileTransfer

(

void *

param

)

Definition at line 148 of file qmgr.c.

{
    BackgroundCopyManagerImpl *qmgr = &globalMgr;
    HANDLE events[2];
 
    events[0] = stop_event;
    events[1] = qmgr->jobEvent;
 
    for (;;)
    {
        BackgroundCopyJobImpl *job, *jobCur;
        BOOL haveJob = FALSE;
 
        /* Check if it's the stop_event */
        if (WaitForMultipleObjects(2, events, FALSE, INFINITE) == WAIT_OBJECT_0)
        {
            LIST_FOR_EACH_ENTRY_SAFE(job, jobCur, &qmgr->jobs, BackgroundCopyJobImpl, entryFromQmgr)
            {
                list_remove(&job->entryFromQmgr);
                IBackgroundCopyJob3_Release(&job->IBackgroundCopyJob3_iface);
            }
            return 0;
        }
 
        /* Note that other threads may add files to the job list, but only
           this thread ever deletes them so we don't need to worry about jobs
           magically disappearing from the list.  */
        EnterCriticalSection(&qmgr->cs);
 
        LIST_FOR_EACH_ENTRY_SAFE(job, jobCur, &qmgr->jobs, BackgroundCopyJobImpl, entryFromQmgr)
        {
            if (job->state == BG_JOB_STATE_ACKNOWLEDGED || job->state == BG_JOB_STATE_CANCELLED)
            {
                list_remove(&job->entryFromQmgr);
                IBackgroundCopyJob3_Release(&job->IBackgroundCopyJob3_iface);
            }
            else if (job->state == BG_JOB_STATE_QUEUED)
            {
                haveJob = TRUE;
                break;
            }
            else if (job->state == BG_JOB_STATE_CONNECTING
                     || job->state == BG_JOB_STATE_TRANSFERRING)
            {
                ERR("Invalid state for job %p: %d\n", job, job->state);
            }
        }
 
        if (!haveJob)
            ResetEvent(qmgr->jobEvent);
 
        LeaveCriticalSection(&qmgr->cs);
 
        if (haveJob)
            processJob(job);
    }
}

Referenced by ServiceMain().

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().

processJob()

void processJob

(

BackgroundCopyJobImpl *

job

)

Definition at line 1265 of file job.c.

{
    for (;;)
    {
        BackgroundCopyFileImpl *file;
        BOOL done = TRUE;
 
        EnterCriticalSection(&job->cs);
        LIST_FOR_EACH_ENTRY(file, &job->files, BackgroundCopyFileImpl, entryFromJob)
            if (!file->fileProgress.Completed)
            {
                done = FALSE;
                break;
            }
        LeaveCriticalSection(&job->cs);
        if (done)
        {
            transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSFERRED);
            return;
        }
 
        if (!processFile(file, job))
          return;
    }
}

Referenced by fileTransfer().

return_strval()

static HRESULT return_strval ( const WCHAR *  str, WCHAR **  ret  )

inlinestatic

Definition at line 132 of file qmgr.h.

{
    int len;
 
    if (!ret) return E_INVALIDARG;
 
    len = lstrlenW(str);
    *ret = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
    if (!*ret) return E_OUTOFMEMORY;
    lstrcpyW(*ret, str);
    return S_OK;
}

Referenced by BackgroundCopyFile_GetLocalName(), BackgroundCopyFile_GetRemoteName(), BackgroundCopyJob_GetDescription(), and BackgroundCopyJob_GetDisplayName().

strdupW()

static WCHAR * strdupW ( const WCHAR *  src )

inlinestatic

Definition at line 118 of file qmgr.h.

{
    WCHAR *dst = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(src) + 1) * sizeof(WCHAR));
    if (dst) lstrcpyW(dst, src);
    return dst;
}

transitionJobState()

BOOL transitionJobState	(	BackgroundCopyJobImpl *	job,
		BG_JOB_STATE	from,
		BG_JOB_STATE	to
	)

Definition at line 30 of file job.c.

{
    BOOL ret = FALSE;
 
    EnterCriticalSection(&globalMgr.cs);
    if (job->state == from)
    {
        job->state = to;
        ret = TRUE;
    }
    LeaveCriticalSection(&globalMgr.cs);
    return ret;
}

Referenced by processFile(), processJob(), progress_callback_http(), transfer_file_http(), transfer_file_local(), and wait_for_completion().

Variable Documentation

DECLSPEC_HIDDEN

BackgroundCopyManagerImpl globalMgr DECLSPEC_HIDDEN

extern

Definition at line 100 of file qmgr.h.