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)
HRESULT	BackgroundCopyJobConstructor (LPCWSTR displayName, BG_JOB_TYPE type, GUID *pJobId, BackgroundCopyJobImpl **job)
HRESULT	enum_copy_job_create (BackgroundCopyManagerImpl *qmgr, IEnumBackgroundCopyJobs **enumjob)
HRESULT	BackgroundCopyFileConstructor (BackgroundCopyJobImpl *owner, LPCWSTR remoteName, LPCWSTR localName, BackgroundCopyFileImpl **file)
HRESULT	EnumBackgroundCopyFilesConstructor (BackgroundCopyJobImpl *, IEnumBackgroundCopyFiles **)
DWORD WINAPI	fileTransfer (void *param)
void	processJob (BackgroundCopyJobImpl *job)
BOOL	processFile (BackgroundCopyFileImpl *file, BackgroundCopyJobImpl *job)
BOOL	transitionJobState (BackgroundCopyJobImpl *job, BG_JOB_STATE from, BG_JOB_STATE to)
static WCHAR *	co_strdupW (const WCHAR *src)
static HRESULT	return_strval (const WCHAR *str, WCHAR **ret)

Variables
HANDLE	stop_event
ClassFactoryImpl	BITS_ClassFactory
BackgroundCopyManagerImpl	globalMgr

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 = calloc(1, sizeof(*This));
    if (!This)
        return E_OUTOFMEMORY;
 
    This->info.RemoteName = wcsdup(remoteName);
    if (!This->info.RemoteName)
    {
        free(This);
        return E_OUTOFMEMORY;
    }
 
    This->info.LocalName = wcsdup(localName);
    if (!This->info.LocalName)
    {
        free(This->info.RemoteName);
        free(This);
        return E_OUTOFMEMORY;
    }
 
    This->IBackgroundCopyFile2_iface.lpVtbl = &BackgroundCopyFile2Vtbl;
    This->ref = 1;
    This->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
    This->owner = owner;
    IBackgroundCopyJob4_AddRef(&owner->IBackgroundCopyJob4_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 1135 of file job.c.

{
    HRESULT hr;
    BackgroundCopyJobImpl *This;
 
    TRACE("(%s,%d,%p)\n", debugstr_w(displayName), type, job);
 
    This = malloc(sizeof(*This));
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IBackgroundCopyJob4_iface.lpVtbl = &BackgroundCopyJobVtbl;
    This->IBackgroundCopyJobHttpOptions_iface.lpVtbl = &http_options_vtbl;
    InitializeCriticalSectionEx(&This->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    This->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BackgroundCopyJobImpl.cs");
 
    This->ref = 1;
    This->type = type;
 
    This->displayName = wcsdup(displayName);
    if (!This->displayName)
    {
        This->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->cs);
        free(This);
        return E_OUTOFMEMORY;
    }
 
    hr = CoCreateGuid(&This->jobId);
    if (FAILED(hr))
    {
        This->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->cs);
        free(This->displayName);
        free(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 118 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 177 of file enum_jobs.c.

{
    EnumBackgroundCopyJobsImpl *This;
    BackgroundCopyJobImpl *job;
    ULONG i;
 
    TRACE("%p, %p)\n", qmgr, enumjob);
 
    This = malloc(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 = malloc(This->numJobs * sizeof *This->jobs);
        if (!This->jobs)
        {
            LeaveCriticalSection(&qmgr->cs);
            free(This);
            return E_OUTOFMEMORY;
        }
    }
    else
        This->jobs = NULL;
 
    i = 0;
    LIST_FOR_EACH_ENTRY(job, &qmgr->jobs, BackgroundCopyJobImpl, entryFromQmgr)
    {
        IBackgroundCopyJob4_AddRef(&job->IBackgroundCopyJob4_iface);
        This->jobs[i++] = &job->IBackgroundCopyJob4_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 = malloc(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 = malloc(This->numFiles * sizeof This->files[0]);
        if (!This->files)
        {
            LeaveCriticalSection(&job->cs);
            free(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);
                IBackgroundCopyJob4_Release(&job->IBackgroundCopyJob4_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);
                IBackgroundCopyJob4_Release(&job->IBackgroundCopyJob4_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 471 of file file.c.

{
    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: %ld\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, L"BIT", 0, tmpName))
    {
        ERR("Couldn't create temp file: %ld\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 1203 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);
            if (job->callback && (job->notify_flags & BG_NOTIFY_JOB_TRANSFERRED))
            {
                TRACE("Calling JobTransferred -->\n");
                IBackgroundCopyCallback2_JobTransferred(job->callback, (IBackgroundCopyJob*)&job->IBackgroundCopyJob4_iface);
                TRACE("Called JobTransferred <--\n");
            }
            return;
        }
 
        if (!processFile(file, job))
          return;
    }
}

Referenced by fileTransfer().

return_strval()

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

inlinestatic

Definition at line 125 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().

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

BITS_ClassFactory

ClassFactoryImpl BITS_ClassFactory

extern

Definition at line 88 of file factory.c.

Referenced by BITS_IClassFactory_QueryInterface(), and StartCount().

globalMgr

BackgroundCopyManagerImpl globalMgr

extern

Definition at line 26 of file qmgr.c.

Referenced by BackgroundCopyJob_Resume(), BackgroundCopyManager_CreateJob(), BackgroundCopyManager_EnumJobs(), BackgroundCopyManager_GetJob(), BackgroundCopyManagerConstructor(), fileTransfer(), ServiceMain(), and transitionJobState().

stop_event

HANDLE stop_event

extern

Definition at line 55 of file nfs41_daemon.c.

Referenced by fileTransfer(), hide_from_debugger_thread(), local_server_proc(), notification_thread_func(), ServiceHandler(), ServiceMain(), ServiceStart(), ServiceStop(), test_delegated_methods(), test_HideFromDebugger(), test_SetActiveWindow_0_proc(), test_ThreadIsTerminated(), test_ThreadIsTerminated_thread(), and UpdateStatus().