- Add some headers from Wine

- Import qmgr from Wine (not included yet to build)

svn path=/trunk/; revision=39240

reactos/baseaddress.rbuild

@@ -17,6 +17,7 @@
   <property name="BASEADDRESS_PWRCFG" value="0x587e0000" />
   <property name="BASEADDRESS_MMSYS" value="0x588a0000" />
   <property name="BASEADDRESS_JOY" value="0x589b0000" />
+  <property name="BASEADDRESS_QMGR" value="0x59620000" />
   <property name="BASEADDRESS_UXTHEME" value="0x5ad70000" />
   <property name="BASEADDRESS_VDMDBG" value="0x5b0d0000" />
   <property name="BASEADDRESS_UNTFS" value="0x5b340000" />

reactos/dll/win32/qmgr/enum_files.c

@@ -0,0 +1,215 @@
+/*
+ * Queue Manager (BITS) File Enumerator
+ *
+ * Copyright 2007, 2008 Google (Roy Shea, Dan Hipschman)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "qmgr.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
+
+static void EnumBackgroundCopyFilesDestructor(EnumBackgroundCopyFilesImpl *This)
+{
+    ULONG i;
+
+    for(i = 0; i < This->numFiles; i++)
+        IBackgroundCopyFile_Release(This->files[i]);
+
+    HeapFree(GetProcessHeap(), 0, This->files);
+    HeapFree(GetProcessHeap(), 0, This);
+}
+
+static ULONG WINAPI BITS_IEnumBackgroundCopyFiles_AddRef(
+    IEnumBackgroundCopyFiles* iface)
+{
+    EnumBackgroundCopyFilesImpl *This = (EnumBackgroundCopyFilesImpl *) iface;
+    return InterlockedIncrement(&This->ref);
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyFiles_QueryInterface(
+    IEnumBackgroundCopyFiles* iface,
+    REFIID riid,
+    void **ppvObject)
+{
+    EnumBackgroundCopyFilesImpl *This = (EnumBackgroundCopyFilesImpl *) iface;
+    TRACE("IID: %s\n", debugstr_guid(riid));
+
+    if (IsEqualGUID(riid, &IID_IUnknown)
+        || IsEqualGUID(riid, &IID_IEnumBackgroundCopyFiles))
+    {
+        *ppvObject = &This->lpVtbl;
+        BITS_IEnumBackgroundCopyFiles_AddRef(iface);
+        return S_OK;
+    }
+
+    *ppvObject = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI BITS_IEnumBackgroundCopyFiles_Release(
+    IEnumBackgroundCopyFiles* iface)
+{
+    EnumBackgroundCopyFilesImpl *This = (EnumBackgroundCopyFilesImpl *) iface;
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    if (ref == 0)
+        EnumBackgroundCopyFilesDestructor(This);
+
+    return ref;
+}
+
+/* Return reference to one or more files in the file enumerator */
+static HRESULT WINAPI BITS_IEnumBackgroundCopyFiles_Next(
+    IEnumBackgroundCopyFiles* iface,
+    ULONG celt,
+    IBackgroundCopyFile **rgelt,
+    ULONG *pceltFetched)
+{
+    EnumBackgroundCopyFilesImpl *This = (EnumBackgroundCopyFilesImpl *) iface;
+    ULONG fetched;
+    ULONG i;
+    IBackgroundCopyFile *file;
+
+    /* Despite documented behavior, Windows (tested on XP) is not verifying
+       that the caller set pceltFetched to zero.  No check here. */
+
+    fetched = min(celt, This->numFiles - This->indexFiles);
+    if (pceltFetched)
+        *pceltFetched = fetched;
+    else
+    {
+        /* We need to initialize this array if the caller doesn't request
+           the length because length_is will default to celt.  */
+        for (i = 0; i < celt; i++)
+            rgelt[i] = NULL;
+
+        /* pceltFetched can only be NULL if celt is 1 */
+        if (celt != 1)
+            return E_INVALIDARG;
+    }
+
+    /* Fill in the array of objects */
+    for (i = 0; i < fetched; i++)
+    {
+        file = This->files[This->indexFiles++];
+        IBackgroundCopyFile_AddRef(file);
+        rgelt[i] = file;
+    }
+
+    return fetched == celt ? S_OK : S_FALSE;
+}
+
+/* Skip over one or more files in the file enumerator */
+static HRESULT WINAPI BITS_IEnumBackgroundCopyFiles_Skip(
+    IEnumBackgroundCopyFiles* iface,
+    ULONG celt)
+{
+    EnumBackgroundCopyFilesImpl *This = (EnumBackgroundCopyFilesImpl *) iface;
+
+    if (celt > This->numFiles - This->indexFiles)
+    {
+        This->indexFiles = This->numFiles;
+        return S_FALSE;
+    }
+
+    This->indexFiles += celt;
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyFiles_Reset(
+    IEnumBackgroundCopyFiles* iface)
+{
+    EnumBackgroundCopyFilesImpl *This = (EnumBackgroundCopyFilesImpl *) iface;
+    This->indexFiles = 0;
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyFiles_Clone(
+    IEnumBackgroundCopyFiles* iface,
+    IEnumBackgroundCopyFiles **ppenum)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyFiles_GetCount(
+    IEnumBackgroundCopyFiles* iface,
+    ULONG *puCount)
+{
+    EnumBackgroundCopyFilesImpl *This = (EnumBackgroundCopyFilesImpl *) iface;
+    *puCount = This->numFiles;
+    return S_OK;
+}
+
+static const IEnumBackgroundCopyFilesVtbl BITS_IEnumBackgroundCopyFiles_Vtbl =
+{
+    BITS_IEnumBackgroundCopyFiles_QueryInterface,
+    BITS_IEnumBackgroundCopyFiles_AddRef,
+    BITS_IEnumBackgroundCopyFiles_Release,
+    BITS_IEnumBackgroundCopyFiles_Next,
+    BITS_IEnumBackgroundCopyFiles_Skip,
+    BITS_IEnumBackgroundCopyFiles_Reset,
+    BITS_IEnumBackgroundCopyFiles_Clone,
+    BITS_IEnumBackgroundCopyFiles_GetCount
+};
+
+HRESULT EnumBackgroundCopyFilesConstructor(LPVOID *ppObj, IBackgroundCopyJob2 *iCopyJob)
+{
+    EnumBackgroundCopyFilesImpl *This;
+    BackgroundCopyFileImpl *file;
+    BackgroundCopyJobImpl *job = (BackgroundCopyJobImpl *) iCopyJob;
+    ULONG i;
+
+    TRACE("%p, %p)\n", ppObj, job);
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
+    if (!This)
+        return E_OUTOFMEMORY;
+
+    This->lpVtbl = &BITS_IEnumBackgroundCopyFiles_Vtbl;
+    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)
+    {
+        file->lpVtbl->AddRef((IBackgroundCopyFile *) file);
+        This->files[i] = (IBackgroundCopyFile *) file;
+        ++i;
+    }
+    LeaveCriticalSection(&job->cs);
+
+    *ppObj = &This->lpVtbl;
+    return S_OK;
+}

reactos/dll/win32/qmgr/enum_jobs.c

@@ -0,0 +1,213 @@
+/*
+ * Queue Manager (BITS) Job Enumerator
+ *
+ * Copyright 2007 Google (Roy Shea)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "qmgr.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
+
+static void EnumBackgroundCopyJobsDestructor(EnumBackgroundCopyJobsImpl *This)
+{
+    ULONG i;
+
+    for(i = 0; i < This->numJobs; i++)
+        IBackgroundCopyJob_Release(This->jobs[i]);
+
+    HeapFree(GetProcessHeap(), 0, This->jobs);
+    HeapFree(GetProcessHeap(), 0, This);
+}
+
+static ULONG WINAPI BITS_IEnumBackgroundCopyJobs_AddRef(
+    IEnumBackgroundCopyJobs* iface)
+{
+    EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
+    return InterlockedIncrement(&This->ref);
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_QueryInterface(
+    IEnumBackgroundCopyJobs* iface,
+    REFIID riid,
+    void **ppvObject)
+{
+    EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
+    TRACE("IID: %s\n", debugstr_guid(riid));
+
+    if (IsEqualGUID(riid, &IID_IUnknown)
+        || IsEqualGUID(riid, &IID_IEnumBackgroundCopyJobs))
+    {
+        *ppvObject = &This->lpVtbl;
+        BITS_IEnumBackgroundCopyJobs_AddRef(iface);
+        return S_OK;
+    }
+
+    *ppvObject = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI BITS_IEnumBackgroundCopyJobs_Release(
+    IEnumBackgroundCopyJobs* iface)
+{
+    EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    if (ref == 0)
+        EnumBackgroundCopyJobsDestructor(This);
+
+    return ref;
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_Next(
+    IEnumBackgroundCopyJobs* iface,
+    ULONG celt,
+    IBackgroundCopyJob **rgelt,
+    ULONG *pceltFetched)
+{
+    EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
+    ULONG fetched;
+    ULONG i;
+    IBackgroundCopyJob *job;
+
+    fetched = min(celt, This->numJobs - This->indexJobs);
+    if (pceltFetched)
+        *pceltFetched = fetched;
+    else
+    {
+        /* We need to initialize this array if the caller doesn't request
+           the length because length_is will default to celt.  */
+        for (i = 0; i < celt; ++i)
+            rgelt[i] = NULL;
+
+        /* pceltFetched can only be NULL if celt is 1 */
+        if (celt != 1)
+            return E_INVALIDARG;
+    }
+
+    /* Fill in the array of objects */
+    for (i = 0; i < fetched; ++i)
+    {
+        job = This->jobs[This->indexJobs++];
+        IBackgroundCopyJob_AddRef(job);
+        rgelt[i] = job;
+    }
+
+    return fetched == celt ? S_OK : S_FALSE;
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_Skip(
+    IEnumBackgroundCopyJobs* iface,
+    ULONG celt)
+{
+    EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
+
+    if (This->numJobs - This->indexJobs < celt)
+    {
+        This->indexJobs = This->numJobs;
+        return S_FALSE;
+    }
+
+    This->indexJobs += celt;
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_Reset(
+    IEnumBackgroundCopyJobs* iface)
+{
+    EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
+    This->indexJobs = 0;
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_Clone(
+    IEnumBackgroundCopyJobs* iface,
+    IEnumBackgroundCopyJobs **ppenum)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IEnumBackgroundCopyJobs_GetCount(
+    IEnumBackgroundCopyJobs* iface,
+    ULONG *puCount)
+{
+    EnumBackgroundCopyJobsImpl *This = (EnumBackgroundCopyJobsImpl *) iface;
+    *puCount = This->numJobs;
+    return S_OK;
+}
+
+static const IEnumBackgroundCopyJobsVtbl BITS_IEnumBackgroundCopyJobs_Vtbl =
+{
+    BITS_IEnumBackgroundCopyJobs_QueryInterface,
+    BITS_IEnumBackgroundCopyJobs_AddRef,
+    BITS_IEnumBackgroundCopyJobs_Release,
+    BITS_IEnumBackgroundCopyJobs_Next,
+    BITS_IEnumBackgroundCopyJobs_Skip,
+    BITS_IEnumBackgroundCopyJobs_Reset,
+    BITS_IEnumBackgroundCopyJobs_Clone,
+    BITS_IEnumBackgroundCopyJobs_GetCount
+};
+
+HRESULT EnumBackgroundCopyJobsConstructor(LPVOID *ppObj,
+                                          IBackgroundCopyManager* copyManager)
+{
+    BackgroundCopyManagerImpl *qmgr = (BackgroundCopyManagerImpl *) copyManager;
+    EnumBackgroundCopyJobsImpl *This;
+    BackgroundCopyJobImpl *job;
+    ULONG i;
+
+    TRACE("%p, %p)\n", ppObj, copyManager);
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
+    if (!This)
+        return E_OUTOFMEMORY;
+    This->lpVtbl = &BITS_IEnumBackgroundCopyJobs_Vtbl;
+    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)
+    {
+        IBackgroundCopyJob *iJob = (IBackgroundCopyJob *) job;
+        IBackgroundCopyJob_AddRef(iJob);
+        This->jobs[i++] = iJob;
+    }
+    LeaveCriticalSection(&qmgr->cs);
+
+    *ppObj = &This->lpVtbl;
+    return S_OK;
+}

reactos/dll/win32/qmgr/factory.c

@@ -0,0 +1,96 @@
+/*
+ * Class factory interface for Queue Manager (BITS)
+ *
+ * Copyright (C) 2007 Google (Roy Shea)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "qmgr.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
+
+static ULONG WINAPI
+BITS_IClassFactory_AddRef(LPCLASSFACTORY iface)
+{
+    return 2;
+}
+
+static HRESULT WINAPI
+BITS_IClassFactory_QueryInterface(LPCLASSFACTORY iface, REFIID riid,
+                                  LPVOID *ppvObj)
+{
+    ClassFactoryImpl *This = (ClassFactoryImpl *) iface;
+
+    if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IClassFactory))
+    {
+        *ppvObj = &This->lpVtbl;
+        return S_OK;
+    }
+
+    *ppvObj = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI
+BITS_IClassFactory_Release(LPCLASSFACTORY iface)
+{
+    return 1;
+}
+
+static HRESULT WINAPI
+BITS_IClassFactory_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pUnkOuter,
+                                  REFIID riid, LPVOID *ppvObj)
+{
+    HRESULT res;
+    IUnknown *punk = NULL;
+
+    TRACE("IID: %s\n", debugstr_guid(riid));
+
+    if (pUnkOuter)
+        return CLASS_E_NOAGGREGATION;
+
+    res = BackgroundCopyManagerConstructor(pUnkOuter, (LPVOID*) &punk);
+    if (FAILED(res))
+        return res;
+
+    res = IUnknown_QueryInterface(punk, riid, ppvObj);
+    IUnknown_Release(punk);
+    return res;
+}
+
+static HRESULT WINAPI
+BITS_IClassFactory_LockServer(LPCLASSFACTORY iface, BOOL fLock)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static const IClassFactoryVtbl BITS_IClassFactory_Vtbl =
+{
+    BITS_IClassFactory_QueryInterface,
+    BITS_IClassFactory_AddRef,
+    BITS_IClassFactory_Release,
+    BITS_IClassFactory_CreateInstance,
+    BITS_IClassFactory_LockServer
+};
+
+ClassFactoryImpl BITS_ClassFactory =
+{
+    &BITS_IClassFactory_Vtbl
+};

reactos/dll/win32/qmgr/file.c

@@ -0,0 +1,451 @@
+/*
+ * Queue Manager (BITS) File
+ *
+ * Copyright 2007, 2008 Google (Roy Shea, Dan Hipschman)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+
+#define COBJMACROS
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "winreg.h"
+#include "ole2.h"
+#include "urlmon.h"
+#include "wininet.h"
+
+#include "qmgr.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
+
+static void BackgroundCopyFileDestructor(BackgroundCopyFileImpl *This)
+{
+    IBackgroundCopyJob_Release((IBackgroundCopyJob *) This->owner);
+    HeapFree(GetProcessHeap(), 0, This->info.LocalName);
+    HeapFree(GetProcessHeap(), 0, This->info.RemoteName);
+    HeapFree(GetProcessHeap(), 0, This);
+}
+
+static ULONG WINAPI BITS_IBackgroundCopyFile_AddRef(IBackgroundCopyFile* iface)
+{
+    BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
+    return InterlockedIncrement(&This->ref);
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyFile_QueryInterface(
+    IBackgroundCopyFile* iface,
+    REFIID riid,
+    void **ppvObject)
+{
+    BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
+
+    if (IsEqualGUID(riid, &IID_IUnknown)
+        || IsEqualGUID(riid, &IID_IBackgroundCopyFile))
+    {
+        *ppvObject = &This->lpVtbl;
+        BITS_IBackgroundCopyFile_AddRef(iface);
+        return S_OK;
+    }
+
+    *ppvObject = NULL;
+    return E_NOINTERFACE;
+}
+
+
+static ULONG WINAPI BITS_IBackgroundCopyFile_Release(
+    IBackgroundCopyFile* iface)
+{
+    BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    if (ref == 0)
+        BackgroundCopyFileDestructor(This);
+
+    return ref;
+}
+
+/* Get the remote name of a background copy file */
+static HRESULT WINAPI BITS_IBackgroundCopyFile_GetRemoteName(
+    IBackgroundCopyFile* iface,
+    LPWSTR *pVal)
+{
+    BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
+    int n = (lstrlenW(This->info.RemoteName) + 1) * sizeof(WCHAR);
+
+    *pVal = CoTaskMemAlloc(n);
+    if (!*pVal)
+        return E_OUTOFMEMORY;
+
+    memcpy(*pVal, This->info.RemoteName, n);
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyFile_GetLocalName(
+    IBackgroundCopyFile* iface,
+    LPWSTR *pVal)
+{
+    BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
+    int n = (lstrlenW(This->info.LocalName) + 1) * sizeof(WCHAR);
+
+    *pVal = CoTaskMemAlloc(n);
+    if (!*pVal)
+        return E_OUTOFMEMORY;
+
+    memcpy(*pVal, This->info.LocalName, n);
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyFile_GetProgress(
+    IBackgroundCopyFile* iface,
+    BG_FILE_PROGRESS *pVal)
+{
+    BackgroundCopyFileImpl *This = (BackgroundCopyFileImpl *) iface;
+
+    EnterCriticalSection(&This->owner->cs);
+    pVal->BytesTotal = This->fileProgress.BytesTotal;
+    pVal->BytesTransferred = This->fileProgress.BytesTransferred;
+    pVal->Completed = This->fileProgress.Completed;
+    LeaveCriticalSection(&This->owner->cs);
+
+    return S_OK;
+}
+
+static const IBackgroundCopyFileVtbl BITS_IBackgroundCopyFile_Vtbl =
+{
+    BITS_IBackgroundCopyFile_QueryInterface,
+    BITS_IBackgroundCopyFile_AddRef,
+    BITS_IBackgroundCopyFile_Release,
+    BITS_IBackgroundCopyFile_GetRemoteName,
+    BITS_IBackgroundCopyFile_GetLocalName,
+    BITS_IBackgroundCopyFile_GetProgress
+};
+
+HRESULT BackgroundCopyFileConstructor(BackgroundCopyJobImpl *owner,
+                                      LPCWSTR remoteName, LPCWSTR localName,
+                                      LPVOID *ppObj)
+{
+    BackgroundCopyFileImpl *This;
+    int n;
+
+    TRACE("(%s,%s,%p)\n", debugstr_w(remoteName),
+            debugstr_w(localName), ppObj);
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
+    if (!This)
+        return E_OUTOFMEMORY;
+
+    n = (lstrlenW(remoteName) + 1) * sizeof(WCHAR);
+    This->info.RemoteName = HeapAlloc(GetProcessHeap(), 0, n);
+    if (!This->info.RemoteName)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+        return E_OUTOFMEMORY;
+    }
+    memcpy(This->info.RemoteName, remoteName, n);
+
+    n = (lstrlenW(localName) + 1) * sizeof(WCHAR);
+    This->info.LocalName = HeapAlloc(GetProcessHeap(), 0, n);
+    if (!This->info.LocalName)
+    {
+        HeapFree(GetProcessHeap(), 0, This->info.RemoteName);
+        HeapFree(GetProcessHeap(), 0, This);
+        return E_OUTOFMEMORY;
+    }
+    memcpy(This->info.LocalName, localName, n);
+
+    This->lpVtbl = &BITS_IBackgroundCopyFile_Vtbl;
+    This->ref = 1;
+
+    This->fileProgress.BytesTotal = BG_SIZE_UNKNOWN;
+    This->fileProgress.BytesTransferred = 0;
+    This->fileProgress.Completed = FALSE;
+    This->owner = owner;
+    IBackgroundCopyJob_AddRef((IBackgroundCopyJob *) owner);
+
+    *ppObj = &This->lpVtbl;
+    return S_OK;
+}
+
+static DWORD CALLBACK copyProgressCallback(LARGE_INTEGER totalSize,
+                                           LARGE_INTEGER totalTransferred,
+                                           LARGE_INTEGER streamSize,
+                                           LARGE_INTEGER streamTransferred,
+                                           DWORD streamNum,
+                                           DWORD reason,
+                                           HANDLE srcFile,
+                                           HANDLE dstFile,
+                                           LPVOID obj)
+{
+    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);
+}
+
+typedef struct
+{
+    const IBindStatusCallbackVtbl *lpVtbl;
+    BackgroundCopyFileImpl *file;
+    LONG ref;
+} DLBindStatusCallback;
+
+static ULONG WINAPI DLBindStatusCallback_AddRef(IBindStatusCallback *iface)
+{
+    DLBindStatusCallback *This = (DLBindStatusCallback *) iface;
+    return InterlockedIncrement(&This->ref);
+}
+
+static ULONG WINAPI DLBindStatusCallback_Release(IBindStatusCallback *iface)
+{
+    DLBindStatusCallback *This = (DLBindStatusCallback *) iface;
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    if (ref == 0)
+    {
+        IBackgroundCopyFile_Release((IBackgroundCopyFile *) This->file);
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI DLBindStatusCallback_QueryInterface(
+    IBindStatusCallback *iface,
+    REFIID riid,
+    void **ppvObject)
+{
+    DLBindStatusCallback *This = (DLBindStatusCallback *) iface;
+
+    if (IsEqualGUID(riid, &IID_IUnknown)
+        || IsEqualGUID(riid, &IID_IBindStatusCallback))
+    {
+        *ppvObject = &This->lpVtbl;
+        DLBindStatusCallback_AddRef(iface);
+        return S_OK;
+    }
+
+    *ppvObject = NULL;
+    return E_NOINTERFACE;
+}
+
+static HRESULT WINAPI DLBindStatusCallback_GetBindInfo(
+    IBindStatusCallback *iface,
+    DWORD *grfBINDF,
+    BINDINFO *pbindinfo)
+{
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI DLBindStatusCallback_GetPriority(
+    IBindStatusCallback *iface,
+    LONG *pnPriority)
+{
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI DLBindStatusCallback_OnDataAvailable(
+    IBindStatusCallback *iface,
+    DWORD grfBSCF,
+    DWORD dwSize,
+    FORMATETC *pformatetc,
+    STGMEDIUM *pstgmed)
+{
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI DLBindStatusCallback_OnLowResource(
+    IBindStatusCallback *iface,
+    DWORD reserved)
+{
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI DLBindStatusCallback_OnObjectAvailable(
+    IBindStatusCallback *iface,
+    REFIID riid,
+    IUnknown *punk)
+{
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI DLBindStatusCallback_OnProgress(
+    IBindStatusCallback *iface,
+    ULONG progress,
+    ULONG progressMax,
+    ULONG statusCode,
+    LPCWSTR statusText)
+{
+    DLBindStatusCallback *This = (DLBindStatusCallback *) iface;
+    BackgroundCopyFileImpl *file = This->file;
+    BackgroundCopyJobImpl *job = file->owner;
+    ULONG64 diff;
+
+    EnterCriticalSection(&job->cs);
+    diff = (file->fileProgress.BytesTotal == BG_SIZE_UNKNOWN
+            ? progress
+            : progress - file->fileProgress.BytesTransferred);
+    file->fileProgress.BytesTotal = progressMax ? progressMax : BG_SIZE_UNKNOWN;
+    file->fileProgress.BytesTransferred = progress;
+    job->jobProgress.BytesTransferred += diff;
+    LeaveCriticalSection(&job->cs);
+
+    return S_OK;
+}
+
+static HRESULT WINAPI DLBindStatusCallback_OnStartBinding(
+    IBindStatusCallback *iface,
+    DWORD dwReserved,
+    IBinding *pib)
+{
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI DLBindStatusCallback_OnStopBinding(
+    IBindStatusCallback *iface,
+    HRESULT hresult,
+    LPCWSTR szError)
+{
+    return E_NOTIMPL;
+}
+
+static const IBindStatusCallbackVtbl DLBindStatusCallback_Vtbl =
+{
+    DLBindStatusCallback_QueryInterface,
+    DLBindStatusCallback_AddRef,
+    DLBindStatusCallback_Release,
+    DLBindStatusCallback_OnStartBinding,
+    DLBindStatusCallback_GetPriority,
+    DLBindStatusCallback_OnLowResource,
+    DLBindStatusCallback_OnProgress,
+    DLBindStatusCallback_OnStopBinding,
+    DLBindStatusCallback_GetBindInfo,
+    DLBindStatusCallback_OnDataAvailable,
+    DLBindStatusCallback_OnObjectAvailable
+};
+
+static DLBindStatusCallback *DLBindStatusCallbackConstructor(
+    BackgroundCopyFileImpl *file)
+{
+    DLBindStatusCallback *This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
+    if (!This)
+        return NULL;
+
+    This->lpVtbl = &DLBindStatusCallback_Vtbl;
+    IBackgroundCopyFile_AddRef((IBackgroundCopyFile *) file);
+    This->file = file;
+    This->ref = 1;
+    return This;
+}
+
+BOOL processFile(BackgroundCopyFileImpl *file, BackgroundCopyJobImpl *job)
+{
+    static const WCHAR prefix[] = {'B','I','T', 0};
+    IBindStatusCallback *callbackObj;
+    WCHAR tmpDir[MAX_PATH];
+    WCHAR tmpName[MAX_PATH];
+    HRESULT hr;
+
+    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;
+    }
+
+    callbackObj = (IBindStatusCallback *) DLBindStatusCallbackConstructor(file);
+    if (!callbackObj)
+    {
+        ERR("Out of memory\n");
+        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));
+
+    transitionJobState(job, BG_JOB_STATE_QUEUED, BG_JOB_STATE_TRANSFERRING);
+
+    DeleteUrlCacheEntryW(file->info.RemoteName);
+    hr = URLDownloadToFileW(NULL, file->info.RemoteName, tmpName, 0, callbackObj);
+    IBindStatusCallback_Release(callbackObj);
+    if (hr == INET_E_DOWNLOAD_FAILURE)
+    {
+        TRACE("URLDownload failed, trying local file copy\n");
+        if (!CopyFileExW(file->info.RemoteName, tmpName, copyProgressCallback,
+                         file, NULL, 0))
+        {
+            ERR("Local file copy failed: error %d\n", GetLastError());
+            transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
+            return FALSE;
+        }
+    }
+    else if (FAILED(hr))
+    {
+        ERR("URLDownload failed: eh 0x%08x\n", hr);
+        transitionJobState(job, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_ERROR);
+        return FALSE;
+    }
+
+    if (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;
+    }
+}

reactos/dll/win32/qmgr/job.c

@@ -0,0 +1,639 @@
+/*
+ * Background Copy Job Interface for BITS
+ *
+ * Copyright 2007 Google (Roy Shea)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+
+#include "qmgr.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
+
+static void BackgroundCopyJobDestructor(BackgroundCopyJobImpl *This)
+{
+    DeleteCriticalSection(&This->cs);
+    HeapFree(GetProcessHeap(), 0, This->displayName);
+    HeapFree(GetProcessHeap(), 0, This);
+}
+
+static ULONG WINAPI BITS_IBackgroundCopyJob_AddRef(IBackgroundCopyJob2 *iface)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+    return InterlockedIncrement(&This->ref);
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_QueryInterface(
+    IBackgroundCopyJob2 *iface, REFIID riid, LPVOID *ppvObject)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+    TRACE("IID: %s\n", debugstr_guid(riid));
+
+    if (IsEqualGUID(riid, &IID_IUnknown)
+        || IsEqualGUID(riid, &IID_IBackgroundCopyJob)
+        || IsEqualGUID(riid, &IID_IBackgroundCopyJob2))
+    {
+        *ppvObject = &This->lpVtbl;
+        BITS_IBackgroundCopyJob_AddRef(iface);
+        return S_OK;
+    }
+
+    *ppvObject = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI BITS_IBackgroundCopyJob_Release(IBackgroundCopyJob2 *iface)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    if (ref == 0)
+        BackgroundCopyJobDestructor(This);
+
+    return ref;
+}
+
+/*** IBackgroundCopyJob methods ***/
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_AddFileSet(
+    IBackgroundCopyJob2 *iface,
+    ULONG cFileCount,
+    BG_FILE_INFO *pFileSet)
+{
+    ULONG i;
+    for (i = 0; i < cFileCount; ++i)
+    {
+        HRESULT hr = IBackgroundCopyJob_AddFile(iface, pFileSet[i].RemoteName,
+                                                pFileSet[i].LocalName);
+        if (FAILED(hr))
+            return hr;
+    }
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_AddFile(
+    IBackgroundCopyJob2 *iface,
+    LPCWSTR RemoteUrl,
+    LPCWSTR LocalName)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+    IBackgroundCopyFile *pFile;
+    BackgroundCopyFileImpl *file;
+    HRESULT res;
+
+    /* We should return E_INVALIDARG in these cases.  */
+    FIXME("Check for valid filenames and supported protocols\n");
+
+    res = BackgroundCopyFileConstructor(This, RemoteUrl, LocalName, (LPVOID *) &pFile);
+    if (res != S_OK)
+        return res;
+
+    /* Add a reference to the file to file list */
+    IBackgroundCopyFile_AddRef(pFile);
+    file = (BackgroundCopyFileImpl *) pFile;
+    EnterCriticalSection(&This->cs);
+    list_add_head(&This->files, &file->entryFromJob);
+    This->jobProgress.BytesTotal = BG_SIZE_UNKNOWN;
+    ++This->jobProgress.FilesTotal;
+    LeaveCriticalSection(&This->cs);
+
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_EnumFiles(
+    IBackgroundCopyJob2 *iface,
+    IEnumBackgroundCopyFiles **ppEnum)
+{
+    TRACE("\n");
+    return EnumBackgroundCopyFilesConstructor((LPVOID *) ppEnum, iface);
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_Suspend(
+    IBackgroundCopyJob2 *iface)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_Resume(
+    IBackgroundCopyJob2 *iface)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+    HRESULT rv = S_OK;
+
+    EnterCriticalSection(&globalMgr.cs);
+    if (This->state == BG_JOB_STATE_CANCELLED
+        || This->state == BG_JOB_STATE_ACKNOWLEDGED)
+    {
+        rv = BG_E_INVALID_STATE;
+    }
+    else if (This->jobProgress.FilesTransferred == This->jobProgress.FilesTotal)
+    {
+        rv = BG_E_EMPTY;
+    }
+    else if (This->state != BG_JOB_STATE_CONNECTING
+             && This->state != BG_JOB_STATE_TRANSFERRING)
+    {
+        This->state = BG_JOB_STATE_QUEUED;
+        SetEvent(globalMgr.jobEvent);
+    }
+    LeaveCriticalSection(&globalMgr.cs);
+
+    return rv;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_Cancel(
+    IBackgroundCopyJob2 *iface)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_Complete(
+    IBackgroundCopyJob2 *iface)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+    HRESULT rv = S_OK;
+
+    EnterCriticalSection(&This->cs);
+
+    if (This->state == BG_JOB_STATE_CANCELLED
+        || This->state == BG_JOB_STATE_ACKNOWLEDGED)
+    {
+        rv = BG_E_INVALID_STATE;
+    }
+    else
+    {
+        BackgroundCopyFileImpl *file;
+        LIST_FOR_EACH_ENTRY(file, &This->files, BackgroundCopyFileImpl, entryFromJob)
+        {
+            if (file->fileProgress.Completed)
+            {
+                if (!MoveFileExW(file->tempFileName, file->info.LocalName,
+                                 (MOVEFILE_COPY_ALLOWED
+                                  | MOVEFILE_REPLACE_EXISTING
+                                  | MOVEFILE_WRITE_THROUGH)))
+                {
+                    ERR("Couldn't rename file %s -> %s\n",
+                        debugstr_w(file->tempFileName),
+                        debugstr_w(file->info.LocalName));
+                    rv = BG_S_PARTIAL_COMPLETE;
+                }
+            }
+            else
+                rv = BG_S_PARTIAL_COMPLETE;
+        }
+    }
+
+    This->state = BG_JOB_STATE_ACKNOWLEDGED;
+    LeaveCriticalSection(&This->cs);
+
+    return rv;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetId(
+    IBackgroundCopyJob2 *iface,
+    GUID *pVal)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+    *pVal = This->jobId;
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetType(
+    IBackgroundCopyJob2 *iface,
+    BG_JOB_TYPE *pVal)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+
+    if (!pVal)
+        return E_INVALIDARG;
+
+    *pVal = This->type;
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetProgress(
+    IBackgroundCopyJob2 *iface,
+    BG_JOB_PROGRESS *pVal)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+
+    if (!pVal)
+        return E_INVALIDARG;
+
+    EnterCriticalSection(&This->cs);
+    pVal->BytesTotal = This->jobProgress.BytesTotal;
+    pVal->BytesTransferred = This->jobProgress.BytesTransferred;
+    pVal->FilesTotal = This->jobProgress.FilesTotal;
+    pVal->FilesTransferred = This->jobProgress.FilesTransferred;
+    LeaveCriticalSection(&This->cs);
+
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetTimes(
+    IBackgroundCopyJob2 *iface,
+    BG_JOB_TIMES *pVal)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetState(
+    IBackgroundCopyJob2 *iface,
+    BG_JOB_STATE *pVal)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+
+    if (!pVal)
+        return E_INVALIDARG;
+
+    /* Don't think we need a critical section for this */
+    *pVal = This->state;
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetError(
+    IBackgroundCopyJob2 *iface,
+    IBackgroundCopyError **ppError)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetOwner(
+    IBackgroundCopyJob2 *iface,
+    LPWSTR *pVal)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetDisplayName(
+    IBackgroundCopyJob2 *iface,
+    LPCWSTR Val)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetDisplayName(
+    IBackgroundCopyJob2 *iface,
+    LPWSTR *pVal)
+{
+    BackgroundCopyJobImpl *This = (BackgroundCopyJobImpl *) iface;
+    int n;
+
+    if (!pVal)
+        return E_INVALIDARG;
+
+    n = (lstrlenW(This->displayName) + 1) * sizeof **pVal;
+    *pVal = CoTaskMemAlloc(n);
+    if (*pVal == NULL)
+        return E_OUTOFMEMORY;
+    memcpy(*pVal, This->displayName, n);
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetDescription(
+    IBackgroundCopyJob2 *iface,
+    LPCWSTR Val)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetDescription(
+    IBackgroundCopyJob2 *iface,
+    LPWSTR *pVal)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetPriority(
+    IBackgroundCopyJob2 *iface,
+    BG_JOB_PRIORITY Val)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetPriority(
+    IBackgroundCopyJob2 *iface,
+    BG_JOB_PRIORITY *pVal)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetNotifyFlags(
+    IBackgroundCopyJob2 *iface,
+    ULONG Val)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetNotifyFlags(
+    IBackgroundCopyJob2 *iface,
+    ULONG *pVal)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetNotifyInterface(
+    IBackgroundCopyJob2 *iface,
+    IUnknown *Val)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetNotifyInterface(
+    IBackgroundCopyJob2 *iface,
+    IUnknown **pVal)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetMinimumRetryDelay(
+    IBackgroundCopyJob2 *iface,
+    ULONG Seconds)
+{
+    FIXME("%u\n", Seconds);
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetMinimumRetryDelay(
+    IBackgroundCopyJob2 *iface,
+    ULONG *Seconds)
+{
+    FIXME("%p\n", Seconds);
+    *Seconds = 30;
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetNoProgressTimeout(
+    IBackgroundCopyJob2 *iface,
+    ULONG Seconds)
+{
+    FIXME("%u\n", Seconds);
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetNoProgressTimeout(
+    IBackgroundCopyJob2 *iface,
+    ULONG *Seconds)
+{
+    FIXME("%p\n", Seconds);
+    *Seconds = 900;
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetErrorCount(
+    IBackgroundCopyJob2 *iface,
+    ULONG *Errors)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetProxySettings(
+    IBackgroundCopyJob2 *iface,
+    BG_JOB_PROXY_USAGE ProxyUsage,
+    const WCHAR *ProxyList,
+    const WCHAR *ProxyBypassList)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetProxySettings(
+    IBackgroundCopyJob2 *iface,
+    BG_JOB_PROXY_USAGE *pProxyUsage,
+    LPWSTR *pProxyList,
+    LPWSTR *pProxyBypassList)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_TakeOwnership(
+    IBackgroundCopyJob2 *iface)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetNotifyCmdLine(
+    IBackgroundCopyJob2 *iface,
+    LPCWSTR prog,
+    LPCWSTR params)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetNotifyCmdLine(
+    IBackgroundCopyJob2 *iface,
+    LPWSTR *prog,
+    LPWSTR *params)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetReplyProgress(
+    IBackgroundCopyJob2 *iface,
+    BG_JOB_REPLY_PROGRESS *progress)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetReplyData(
+    IBackgroundCopyJob2 *iface,
+    byte **pBuffer,
+    UINT64 *pLength)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetReplyFileName(
+    IBackgroundCopyJob2 *iface,
+    LPCWSTR filename)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_GetReplyFileName(
+    IBackgroundCopyJob2 *iface,
+    LPWSTR *pFilename)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_SetCredentials(
+    IBackgroundCopyJob2 *iface,
+    BG_AUTH_CREDENTIALS *cred)
+{
+    FIXME("Not implemented\n");
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyJob_RemoveCredentials(
+    IBackgroundCopyJob2 *iface,
+    BG_AUTH_TARGET target,
+    BG_AUTH_SCHEME scheme)
+{
+    FIXME("Not implemented\n");
+    return S_OK;
+}
+
+static const IBackgroundCopyJob2Vtbl BITS_IBackgroundCopyJob_Vtbl =
+{
+    BITS_IBackgroundCopyJob_QueryInterface,
+    BITS_IBackgroundCopyJob_AddRef,
+    BITS_IBackgroundCopyJob_Release,
+    BITS_IBackgroundCopyJob_AddFileSet,
+    BITS_IBackgroundCopyJob_AddFile,
+    BITS_IBackgroundCopyJob_EnumFiles,
+    BITS_IBackgroundCopyJob_Suspend,
+    BITS_IBackgroundCopyJob_Resume,
+    BITS_IBackgroundCopyJob_Cancel,
+    BITS_IBackgroundCopyJob_Complete,
+    BITS_IBackgroundCopyJob_GetId,
+    BITS_IBackgroundCopyJob_GetType,
+    BITS_IBackgroundCopyJob_GetProgress,
+    BITS_IBackgroundCopyJob_GetTimes,
+    BITS_IBackgroundCopyJob_GetState,
+    BITS_IBackgroundCopyJob_GetError,
+    BITS_IBackgroundCopyJob_GetOwner,
+    BITS_IBackgroundCopyJob_SetDisplayName,
+    BITS_IBackgroundCopyJob_GetDisplayName,
+    BITS_IBackgroundCopyJob_SetDescription,
+    BITS_IBackgroundCopyJob_GetDescription,
+    BITS_IBackgroundCopyJob_SetPriority,
+    BITS_IBackgroundCopyJob_GetPriority,
+    BITS_IBackgroundCopyJob_SetNotifyFlags,
+    BITS_IBackgroundCopyJob_GetNotifyFlags,
+    BITS_IBackgroundCopyJob_SetNotifyInterface,
+    BITS_IBackgroundCopyJob_GetNotifyInterface,
+    BITS_IBackgroundCopyJob_SetMinimumRetryDelay,
+    BITS_IBackgroundCopyJob_GetMinimumRetryDelay,
+    BITS_IBackgroundCopyJob_SetNoProgressTimeout,
+    BITS_IBackgroundCopyJob_GetNoProgressTimeout,
+    BITS_IBackgroundCopyJob_GetErrorCount,
+    BITS_IBackgroundCopyJob_SetProxySettings,
+    BITS_IBackgroundCopyJob_GetProxySettings,
+    BITS_IBackgroundCopyJob_TakeOwnership,
+    BITS_IBackgroundCopyJob_SetNotifyCmdLine,
+    BITS_IBackgroundCopyJob_GetNotifyCmdLine,
+    BITS_IBackgroundCopyJob_GetReplyProgress,
+    BITS_IBackgroundCopyJob_GetReplyData,
+    BITS_IBackgroundCopyJob_SetReplyFileName,
+    BITS_IBackgroundCopyJob_GetReplyFileName,
+    BITS_IBackgroundCopyJob_SetCredentials,
+    BITS_IBackgroundCopyJob_RemoveCredentials
+};
+
+HRESULT BackgroundCopyJobConstructor(LPCWSTR displayName, BG_JOB_TYPE type,
+                                     GUID *pJobId, LPVOID *ppObj)
+{
+    HRESULT hr;
+    BackgroundCopyJobImpl *This;
+    int n;
+
+    TRACE("(%s,%d,%p)\n", debugstr_w(displayName), type, ppObj);
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof *This);
+    if (!This)
+        return E_OUTOFMEMORY;
+
+    This->lpVtbl = &BITS_IBackgroundCopyJob_Vtbl;
+    InitializeCriticalSection(&This->cs);
+    This->ref = 1;
+    This->type = type;
+
+    n = (lstrlenW(displayName) + 1) *  sizeof *displayName;
+    This->displayName = HeapAlloc(GetProcessHeap(), 0, n);
+    if (!This->displayName)
+    {
+        DeleteCriticalSection(&This->cs);
+        HeapFree(GetProcessHeap(), 0, This);
+        return E_OUTOFMEMORY;
+    }
+    memcpy(This->displayName, displayName, n);
+
+    hr = CoCreateGuid(&This->jobId);
+    if (FAILED(hr))
+    {
+        DeleteCriticalSection(&This->cs);
+        HeapFree(GetProcessHeap(), 0, This->displayName);
+        HeapFree(GetProcessHeap(), 0, This);
+        return hr;
+    }
+    *pJobId = 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;
+
+    *ppObj = &This->lpVtbl;
+    return S_OK;
+}
+
+void processJob(BackgroundCopyJobImpl *job)
+{
+    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;
+    }
+}

reactos/dll/win32/qmgr/qmgr.c

@@ -0,0 +1,194 @@
+/*
+ * Queue Manager (BITS) core functions
+ *
+ * Copyright 2007, 2008 Google (Roy Shea, Dan Hipschman)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "qmgr.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
+
+/* Add a reference to the iface pointer */
+static ULONG WINAPI BITS_IBackgroundCopyManager_AddRef(
+        IBackgroundCopyManager* iface)
+{
+    return 2;
+}
+
+/* Attempt to provide a new interface to interact with iface */
+static HRESULT WINAPI BITS_IBackgroundCopyManager_QueryInterface(
+        IBackgroundCopyManager* iface,
+        REFIID riid,
+        LPVOID *ppvObject)
+{
+    BackgroundCopyManagerImpl * This = (BackgroundCopyManagerImpl *)iface;
+
+    TRACE("IID: %s\n", debugstr_guid(riid));
+
+    if (IsEqualGUID(riid, &IID_IUnknown) ||
+            IsEqualGUID(riid, &IID_IBackgroundCopyManager))
+    {
+        *ppvObject = &This->lpVtbl;
+        BITS_IBackgroundCopyManager_AddRef(iface);
+        return S_OK;
+    }
+
+    *ppvObject = NULL;
+    return E_NOINTERFACE;
+}
+
+/* Release an interface to iface */
+static ULONG WINAPI BITS_IBackgroundCopyManager_Release(
+        IBackgroundCopyManager* iface)
+{
+    return 1;
+}
+
+/*** IBackgroundCopyManager interface methods ***/
+
+static HRESULT WINAPI BITS_IBackgroundCopyManager_CreateJob(
+        IBackgroundCopyManager* iface,
+        LPCWSTR DisplayName,
+        BG_JOB_TYPE Type,
+        GUID *pJobId,
+        IBackgroundCopyJob **ppJob)
+{
+    BackgroundCopyManagerImpl * This = (BackgroundCopyManagerImpl *) iface;
+    BackgroundCopyJobImpl *job;
+    HRESULT hres;
+    TRACE("\n");
+
+    hres = BackgroundCopyJobConstructor(DisplayName, Type, pJobId,
+                                        (LPVOID *) ppJob);
+    if (FAILED(hres))
+        return hres;
+
+    /* Add a reference to the job to job list */
+    IBackgroundCopyJob_AddRef(*ppJob);
+    job = (BackgroundCopyJobImpl *) *ppJob;
+    EnterCriticalSection(&This->cs);
+    list_add_head(&This->jobs, &job->entryFromQmgr);
+    LeaveCriticalSection(&This->cs);
+    return S_OK;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyManager_GetJob(
+        IBackgroundCopyManager* iface,
+        REFGUID jobID,
+        IBackgroundCopyJob **ppJob)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyManager_EnumJobs(
+        IBackgroundCopyManager* iface,
+        DWORD dwFlags,
+        IEnumBackgroundCopyJobs **ppEnum)
+{
+    TRACE("\n");
+    return EnumBackgroundCopyJobsConstructor((LPVOID *) ppEnum, iface);
+}
+
+static HRESULT WINAPI BITS_IBackgroundCopyManager_GetErrorDescription(
+        IBackgroundCopyManager* iface,
+        HRESULT hResult,
+        DWORD LanguageId,
+        LPWSTR *pErrorDescription)
+{
+    FIXME("Not implemented\n");
+    return E_NOTIMPL;
+}
+
+
+static const IBackgroundCopyManagerVtbl BITS_IBackgroundCopyManager_Vtbl =
+{
+    BITS_IBackgroundCopyManager_QueryInterface,
+    BITS_IBackgroundCopyManager_AddRef,
+    BITS_IBackgroundCopyManager_Release,
+    BITS_IBackgroundCopyManager_CreateJob,
+    BITS_IBackgroundCopyManager_GetJob,
+    BITS_IBackgroundCopyManager_EnumJobs,
+    BITS_IBackgroundCopyManager_GetErrorDescription
+};
+
+BackgroundCopyManagerImpl globalMgr = {
+    &BITS_IBackgroundCopyManager_Vtbl,
+    { NULL, -1, 0, 0, 0, 0 },
+    NULL,
+    LIST_INIT(globalMgr.jobs)
+};
+
+/* Constructor for instances of background copy manager */
+HRESULT BackgroundCopyManagerConstructor(IUnknown *pUnkOuter, LPVOID *ppObj)
+{
+    TRACE("(%p,%p)\n", pUnkOuter, ppObj);
+    *ppObj = &globalMgr;
+    return S_OK;
+}
+
+DWORD WINAPI fileTransfer(void *param)
+{
+    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)
+            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);
+                IBackgroundCopyJob_Release((IBackgroundCopyJob *) job);
+            }
+            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);
+    }
+}

reactos/dll/win32/qmgr/qmgr.h

@@ -0,0 +1,138 @@
+/*
+ * Queue Manager definitions
+ *
+ * Copyright 2007 Google (Roy Shea)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __QMGR_H__
+#define __QMGR_H__
+
+#include "windef.h"
+#include "objbase.h"
+
+#define COBJMACROS
+#include "bits1_5.h"
+
+#include <string.h>
+#include "wine/list.h"
+
+/* Background copy job vtbl and related data */
+typedef struct
+{
+    const IBackgroundCopyJob2Vtbl *lpVtbl;
+    LONG ref;
+    LPWSTR displayName;
+    BG_JOB_TYPE type;
+    GUID jobId;
+    struct list files;
+    BG_JOB_PROGRESS jobProgress;
+    BG_JOB_STATE state;
+    /* Protects file list, and progress */
+    CRITICAL_SECTION cs;
+    struct list entryFromQmgr;
+} BackgroundCopyJobImpl;
+
+/* Enum background copy jobs vtbl and related data */
+typedef struct
+{
+    const IEnumBackgroundCopyJobsVtbl *lpVtbl;
+    LONG ref;
+    IBackgroundCopyJob **jobs;
+    ULONG numJobs;
+    ULONG indexJobs;
+} EnumBackgroundCopyJobsImpl;
+
+/* Enum background copy files vtbl and related data */
+typedef struct
+{
+    const IEnumBackgroundCopyFilesVtbl *lpVtbl;
+    LONG ref;
+    IBackgroundCopyFile **files;
+    ULONG numFiles;
+    ULONG indexFiles;
+} EnumBackgroundCopyFilesImpl;
+
+/* Background copy file vtbl and related data */
+typedef struct
+{
+    const IBackgroundCopyFileVtbl *lpVtbl;
+    LONG ref;
+    BG_FILE_INFO info;
+    BG_FILE_PROGRESS fileProgress;
+    WCHAR tempFileName[MAX_PATH];
+    struct list entryFromJob;
+    BackgroundCopyJobImpl *owner;
+} BackgroundCopyFileImpl;
+
+/* Background copy manager vtbl and related data */
+typedef struct
+{
+    const IBackgroundCopyManagerVtbl *lpVtbl;
+    /* Protects job list, job states, and jobEvent  */
+    CRITICAL_SECTION cs;
+    HANDLE jobEvent;
+    struct list jobs;
+} BackgroundCopyManagerImpl;
+
+typedef struct
+{
+    const IClassFactoryVtbl *lpVtbl;
+} ClassFactoryImpl;
+
+extern HANDLE stop_event;
+extern ClassFactoryImpl BITS_ClassFactory;
+extern BackgroundCopyManagerImpl globalMgr;
+
+HRESULT BackgroundCopyManagerConstructor(IUnknown *pUnkOuter, LPVOID *ppObj);
+HRESULT BackgroundCopyJobConstructor(LPCWSTR displayName, BG_JOB_TYPE type,
+                                     GUID *pJobId, LPVOID *ppObj);
+HRESULT EnumBackgroundCopyJobsConstructor(LPVOID *ppObj,
+                                          IBackgroundCopyManager* copyManager);
+HRESULT BackgroundCopyFileConstructor(BackgroundCopyJobImpl *owner,
+                                      LPCWSTR remoteName, LPCWSTR localName,
+                                      LPVOID *ppObj);
+HRESULT EnumBackgroundCopyFilesConstructor(LPVOID *ppObj,
+                                           IBackgroundCopyJob2 *copyJob);
+DWORD WINAPI fileTransfer(void *param);
+void processJob(BackgroundCopyJobImpl *job);
+BOOL processFile(BackgroundCopyFileImpl *file, BackgroundCopyJobImpl *job);
+
+/* Little helper functions */
+static inline char *
+qmgr_strdup(const char *s)
+{
+    size_t n = strlen(s) + 1;
+    char *d = HeapAlloc(GetProcessHeap(), 0, n);
+    return d ? memcpy(d, s, n) : NULL;
+}
+
+static inline BOOL
+transitionJobState(BackgroundCopyJobImpl *job, BG_JOB_STATE fromState,
+                   BG_JOB_STATE toState)
+{
+    BOOL rv = FALSE;
+    EnterCriticalSection(&globalMgr.cs);
+    if (job->state == fromState)
+    {
+        job->state = toState;
+        rv = TRUE;
+    }
+    LeaveCriticalSection(&globalMgr.cs);
+    return rv;
+}
+
+#endif /* __QMGR_H__ */

reactos/dll/win32/qmgr/qmgr.inf

@@ -0,0 +1,16 @@
+[version]
+Signature="$CHICAGO$"
+
+[RegisterDll]
+AddReg = Qmgr.Reg
+
+[UnregisterDll]
+DelReg = Qmgr.Reg
+
+[Qmgr.Reg]
+HKCR,"AppID\BITS","AppID",,"%CLSID_BackgroundCopyQMgr%"
+HKCR,"AppID\%CLSID_BackgroundCopyQMgr%","LocalService",,"BITS"
+HKCR,"CLSID\%CLSID_BackgroundCopyManager%","AppID",,"%CLSID_BackgroundCopyQMgr%"
+
+HKLM,"Software\Microsoft\Windows NT\CurrentVersion\SvcHost","netsvcs",0x00010000,"BITS"
+HKLM,"System\CurrentControlSet\Services\BITS\Parameters","ServiceDll",0x00020000,"qmgr.dll"

reactos/dll/win32/qmgr/qmgr.rbuild

@@ -0,0 +1,31 @@
+<group>
+<module name="qmgr" type="win32dll" baseaddress="${BASEADDRESS_QMGR}" installbase="system32" installname="qmgr.dll" allowwarnings="true">
+	<autoregister infsection="OleControlDlls" type="DllRegisterServer" />
+	<importlibrary definition="qmgr.spec" />
+	<include base="qmgr">.</include>
+	<include base="qmgr" root="intermediate">.</include>
+	<include base="ReactOS">include/reactos/wine</include>
+	<define name="__WINESRC__" />
+	<dependency>qmgr_local_header</dependency>
+	<library>wine</library>
+	<library>uuid</library>
+	<library>wininet</library>
+	<library>urlmon</library>
+	<library>ole32</library>
+	<library>advapi32</library>
+	<library>kernel32</library>
+	<library>ntdll</library>
+	<file>enum_files.c</file>
+	<file>enum_jobs.c</file>
+	<file>factory.c</file>
+	<file>file.c</file>
+	<file>job.c</file>
+	<file>qmgr.c</file>
+	<file>qmgr_main.c</file>
+	<file>service.c</file>
+	<file>rsrc.rc</file>
+</module>
+<module name="qmgr_local_header" type="idlheader">
+	<file>qmgr_local.idl</file>
+</module>
+</group>

reactos/dll/win32/qmgr/qmgr.spec

@@ -0,0 +1,3 @@
+@ stdcall -private DllRegisterServer()
+@ stdcall -private DllUnregisterServer()
+@ stdcall -private ServiceMain(long ptr)

reactos/dll/win32/qmgr/qmgr_local.idl

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2007, 2008 Google (Roy Shea, Dan Hipschman)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "bits.idl"
+
+#define DO_NO_IMPORTS
+#include "bits1_5.idl"

reactos/dll/win32/qmgr/qmgr_main.c

@@ -0,0 +1,179 @@
+/*
+ * Main DLL interface to Queue Manager (BITS)
+ *
+ * Background Intelligent Transfer Service (BITS) interface.  Dll is named
+ * qmgr for backwards compatibility with early versions of BITS.
+ *
+ * Copyright 2007 Google (Roy Shea)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdio.h>
+
+#include "objbase.h"
+#include "winuser.h"
+#include "winreg.h"
+#include "advpub.h"
+#include "olectl.h"
+#include "winsvc.h"
+
+#include "bits.h"
+#include "qmgr.h"
+#include "initguid.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
+
+/* Handle to the base address of this DLL */
+static HINSTANCE hInst;
+
+/* Other GUIDs used by this module */
+DEFINE_GUID(CLSID_BackgroundCopyQMgr, 0x69AD4AEE, 0x51BE, 0x439b, 0xA9,0x2C, 0x86,0xAE,0x49,0x0E,0x8B,0x30);
+
+/* Entry point for DLL */
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+{
+    TRACE("(%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
+
+    switch (fdwReason)
+    {
+        case DLL_WINE_PREATTACH:
+            return FALSE;  /* prefer native version */
+        case DLL_PROCESS_ATTACH:
+            DisableThreadLibraryCalls(hinstDLL);
+            hInst = hinstDLL;
+            break;
+        case DLL_PROCESS_DETACH:
+            break;
+    }
+
+    return TRUE;
+}
+
+static HRESULT init_register_strtable(STRTABLEA *strtable)
+{
+#define CLSID_EXPANSION_ENTRY(id) { "CLSID_" #id, &CLSID_ ## id }
+    static const struct {
+        const char *name;
+        const CLSID *clsid;
+    } expns[] =  {
+        CLSID_EXPANSION_ENTRY(BackgroundCopyQMgr),
+        CLSID_EXPANSION_ENTRY(BackgroundCopyManager)
+    };
+#undef CLSID_EXPANSION_ENTRY
+    static STRENTRYA pse[sizeof expns / sizeof expns[0]];
+    DWORD i;
+
+    strtable->cEntries = sizeof pse / sizeof pse[0];
+    strtable->pse = pse;
+    for (i = 0; i < strtable->cEntries; i++) {
+        static const char dummy_sample[] = "{12345678-1234-1234-1234-123456789012}";
+        const CLSID *clsid = expns[i].clsid;
+        pse[i].pszName = qmgr_strdup(expns[i].name);
+        pse[i].pszValue = HeapAlloc(GetProcessHeap(), 0, sizeof dummy_sample);
+        if (!pse[i].pszName || !pse[i].pszValue)
+            return E_OUTOFMEMORY;
+        sprintf(pse[i].pszValue, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
+                clsid->Data1, clsid->Data2, clsid->Data3, clsid->Data4[0],
+                clsid->Data4[1], clsid->Data4[2], clsid->Data4[3], clsid->Data4[4],
+                clsid->Data4[5], clsid->Data4[6], clsid->Data4[7]);
+    }
+
+    return S_OK;
+}
+
+static void cleanup_register_strtable(STRTABLEA *strtable)
+{
+    DWORD i;
+    for (i = 0; i < strtable->cEntries; i++) {
+        HeapFree(GetProcessHeap(), 0, strtable->pse[i].pszName);
+        HeapFree(GetProcessHeap(), 0, strtable->pse[i].pszValue);
+        if (!strtable->pse[i].pszName || !strtable->pse[i].pszValue)
+            return;
+    }
+}
+
+static HRESULT register_service(BOOL do_register)
+{
+    static const WCHAR name[] = { 'B','I','T','S', 0 };
+    static const WCHAR path[] = { 's','v','c','h','o','s','t','.','e','x','e',
+                                  ' ','-','k',' ','n','e','t','s','v','c','s', 0 };
+    SC_HANDLE scm, service;
+
+    scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
+    if (!scm)
+        return SELFREG_E_CLASS;
+
+    if (do_register)
+        service = CreateServiceW(scm, name, name, SERVICE_ALL_ACCESS,
+                                 SERVICE_WIN32_OWN_PROCESS,
+                                 SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
+                                 path, NULL, NULL, NULL, NULL, NULL);
+    else
+        service = OpenServiceW(scm, name, DELETE);
+
+
+    CloseServiceHandle(scm);
+    if (service)
+    {
+        if (!do_register) DeleteService(service);
+        CloseServiceHandle(service);
+    }
+    return S_OK;
+}
+
+/* Use an INF file to register or unregister the DLL */
+static HRESULT register_server(BOOL do_register)
+{
+    HRESULT hr;
+    STRTABLEA strtable;
+    HMODULE hAdvpack;
+    HRESULT (WINAPI *pRegInstall)(HMODULE hm, LPCSTR pszSection, const STRTABLEA* pstTable);
+    static const WCHAR wszAdvpack[] = {'a','d','v','p','a','c','k','.','d','l','l',0};
+
+    TRACE("(%x)\n", do_register);
+
+    hr = register_service(do_register);
+    if (FAILED(hr)) {
+        ERR("register_service failed: %d\n", GetLastError());
+        return hr;
+    }
+
+    hAdvpack = LoadLibraryW(wszAdvpack);
+    pRegInstall = (void *)GetProcAddress(hAdvpack, "RegInstall");
+
+    hr = init_register_strtable(&strtable);
+    if (SUCCEEDED(hr))
+        hr = pRegInstall(hInst, do_register ? "RegisterDll" : "UnregisterDll",
+                         &strtable);
+    cleanup_register_strtable(&strtable);
+
+    if (FAILED(hr))
+        ERR("RegInstall failed: %08x\n", hr);
+
+    return hr;
+}
+
+HRESULT WINAPI DllRegisterServer(void)
+{
+    return register_server(TRUE);
+}
+
+HRESULT WINAPI DllUnregisterServer(void)
+{
+    return register_server(FALSE);
+}

reactos/dll/win32/qmgr/rsrc.rc

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2007 Google (Roy Shea)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/* @makedep: qmgr.inf */
+REGINST REGINST qmgr.inf

reactos/dll/win32/qmgr/service.c

@@ -0,0 +1,156 @@
+/*
+ * ServiceMain function for qmgr running within svchost
+ *
+ * Copyright 2007 (C) Google (Roy Shea)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "windef.h"
+#include "objbase.h"
+#include "winsvc.h"
+#include "bits.h"
+
+#include "qmgr.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
+
+HANDLE stop_event = NULL;
+
+static SERVICE_STATUS_HANDLE status_handle;
+static SERVICE_STATUS status;
+
+static VOID
+UpdateStatus(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint)
+{
+    status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+    status.dwCurrentState = dwCurrentState;
+    if (dwCurrentState == SERVICE_START_PENDING)
+        status.dwControlsAccepted = 0;
+    else
+        status.dwControlsAccepted
+            = (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE
+               | SERVICE_ACCEPT_SHUTDOWN);
+    status.dwWin32ExitCode = 0;
+    status.dwServiceSpecificExitCode = 0;
+    status.dwCheckPoint = 0;
+    status.dwWaitHint = dwWaitHint;
+
+    if (!SetServiceStatus(status_handle, &status)) {
+        ERR("failed to set service status\n");
+        SetEvent(stop_event);
+    }
+}
+
+/* Handle incoming ControlService signals */
+static DWORD WINAPI
+ServiceHandler(DWORD ctrl, DWORD event_type, LPVOID event_data, LPVOID context)
+{
+    switch (ctrl) {
+    case SERVICE_CONTROL_STOP:
+    case SERVICE_CONTROL_SHUTDOWN:
+        TRACE("shutting down service\n");
+        UpdateStatus(SERVICE_STOP_PENDING, NO_ERROR, 0);
+        SetEvent(stop_event);
+        break;
+    default:
+        FIXME("ignoring handle service ctrl %x\n", ctrl);
+        UpdateStatus(status.dwCurrentState, NO_ERROR, 0);
+        break;
+    }
+
+    return NO_ERROR;
+}
+
+/* Main thread of the service */
+static BOOL
+StartCount(void)
+{
+    HRESULT hr;
+    DWORD dwReg;
+
+    TRACE("\n");
+
+    hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+    if (FAILED(hr))
+        return FALSE;
+
+    hr = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE,
+                              RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE,
+                              NULL);
+    if (FAILED(hr))
+        return FALSE;
+
+    hr = CoRegisterClassObject(&CLSID_BackgroundCopyManager,
+                               (IUnknown *) &BITS_ClassFactory,
+                               CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE,
+                               &dwReg);
+    if (FAILED(hr))
+        return FALSE;
+
+    return TRUE;
+}
+
+/* Service entry point */
+VOID WINAPI
+ServiceMain(DWORD dwArgc, LPWSTR *lpszArgv)
+{
+    HANDLE fileTxThread;
+    static const WCHAR qmgr_nameW[] = {'B','I','T','S',0};
+    DWORD threadId;
+    TRACE("\n");
+
+    stop_event = CreateEventW(NULL, TRUE, FALSE, NULL);
+    if (!stop_event) {
+        ERR("failed to create stop_event\n");
+        return;
+    }
+
+    status_handle = RegisterServiceCtrlHandlerExW(qmgr_nameW, ServiceHandler, NULL);
+    if (!status_handle) {
+        ERR("failed to register handler: %u\n", GetLastError());
+        return;
+    }
+
+    UpdateStatus(SERVICE_START_PENDING, NO_ERROR, 3000);
+    if (!StartCount()) {
+        ERR("failed starting service thread\n");
+        UpdateStatus(SERVICE_STOPPED, NO_ERROR, 0);
+        return;
+    }
+
+    globalMgr.jobEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
+    if (!globalMgr.jobEvent) {
+        ERR("Couldn't create event: error %d\n", GetLastError());
+        UpdateStatus(SERVICE_STOPPED, NO_ERROR, 0);
+        return;
+    }
+
+    fileTxThread = CreateThread(NULL, 0, fileTransfer, NULL, 0, &threadId);
+    if (!fileTxThread)
+    {
+        ERR("Failed starting file transfer thread\n");
+        UpdateStatus(SERVICE_STOPPED, NO_ERROR, 0);
+        return;
+    }
+
+    UpdateStatus(SERVICE_RUNNING, NO_ERROR, 0);
+
+    WaitForSingleObject(fileTxThread, INFINITE);
+    UpdateStatus(SERVICE_STOPPED, NO_ERROR, 0);
+    CloseHandle(stop_event);
+    TRACE("service stoped\n");
+}

reactos/dll/win32/win32.rbuild

@@ -301,6 +301,9 @@
 <directory name="pstorec">
 	<xi:include href="pstorec/pstorec.rbuild" />
 </directory>
+<!--directory name="qmgr">
+	<xi:include href="qmgr/qmgr.rbuild" />
+</directory-->
 <directory name="rasapi32">
 	<xi:include href="rasapi32/rasapi32.rbuild" />
 </directory>

reactos/include/psdk/bits.idl

@@ -0,0 +1,411 @@
+/*
+ * Background Intelligent Transfer Service (BITS) interface
+ *
+ * Copyright 2007 Google (Roy Shea)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
+ */
+
+#ifndef DO_NO_IMPORTS
+import "unknwn.idl";
+#endif
+
+cpp_quote("#include \"bitsmsg.h\"")
+cpp_quote("#define BG_SIZE_UNKNOWN (UINT64)(-1)")
+cpp_quote("#define BG_NOTIFY_JOB_TRANSFERRED 0x0001")
+cpp_quote("#define BG_NOTIFY_JOB_ERROR 0x0002")
+cpp_quote("#define BG_NOTIFY_DISABLE 0x0004")
+cpp_quote("#define BG_NOTIFY_JOB_MODIFICATION 0x0008")
+
+
+#define BG_ENUM_SIZEIS(maxcount) maxcount
+#define BG_ENUM_LENGTHIS(maxcount,lengthptr) lengthptr ? *lengthptr : maxcount
+
+[
+    uuid(01b7bd23-fb88-4a77-8490-5891d3e4653a),
+    odl
+]
+interface IBackgroundCopyFile : IUnknown
+{
+    typedef struct _BG_FILE_PROGRESS {
+        UINT64 BytesTotal;
+        UINT64 BytesTransferred;
+        BOOL Completed;
+    } BG_FILE_PROGRESS;
+
+    HRESULT GetRemoteName(
+            [out] LPWSTR *pVal
+    );
+
+    HRESULT GetLocalName(
+            [out] LPWSTR *pVal
+    );
+
+    HRESULT GetProgress(
+            [out] BG_FILE_PROGRESS *pVal
+    );
+}
+
+
+[
+    uuid(ca51e165-c365-424c-8d41-24aaa4ff3c40),
+    odl
+]
+interface IEnumBackgroundCopyFiles: IUnknown
+{
+    HRESULT Next(
+            [in] ULONG celt,
+            [out,size_is(BG_ENUM_SIZEIS(celt)),length_is(BG_ENUM_LENGTHIS(celt,pceltFetched))] IBackgroundCopyFile **rgelt,
+            [in,out,unique] ULONG *pceltFetched
+    );
+
+    HRESULT Skip(
+            [in] ULONG celt
+    );
+
+    HRESULT Reset();
+
+    HRESULT Clone(
+            [out] IEnumBackgroundCopyFiles **ppenum
+    );
+
+    HRESULT GetCount(
+            [out] ULONG *puCount
+    );
+}
+
+
+[
+    uuid(19c613a0-fcb8-4f28-81ae-897c3d078f81),
+    odl
+]
+interface IBackgroundCopyError : IUnknown
+{
+    typedef enum {
+        BG_ERROR_CONTEXT_NONE = 0,
+        BG_ERROR_CONTEXT_UNKNOWN = 1,
+        BG_ERROR_CONTEXT_GENERAL_QUEUE_MANAGER = 2,
+        BG_ERROR_CONTEXT_QUEUE_MANAGER_NOTIFICATION =3,
+        BG_ERROR_CONTEXT_LOCAL_FILE = 4,
+        BG_ERROR_CONTEXT_REMOTE_FILE = 5,
+        BG_ERROR_CONTEXT_GENERAL_TRANSPORT = 6,
+        BG_ERROR_CONTEXT_REMOTE_APPLICATION =7,
+    } BG_ERROR_CONTEXT;
+
+    HRESULT GetError(
+            [out,ref] BG_ERROR_CONTEXT *pContext,
+            [out,ref] HRESULT *pCode
+    );
+
+    HRESULT GetFile(
+            [out] IBackgroundCopyFile **pVal
+    );
+
+    HRESULT GetErrorDescription(
+            [in] DWORD LanguageId,
+            [out,ref] LPWSTR *pErrorDescription
+    );
+
+    HRESULT GetErrorContextDescription(
+            [in] DWORD LanguageId,
+            [out,ref] LPWSTR *pContextDescription
+    );
+
+    HRESULT GetProtocol(
+            [out,ref] LPWSTR *pProtocol
+    );
+}
+
+
+
+[
+    uuid(37668d37-507e-4160-9316-26306d150b12),
+    odl
+]
+interface IBackgroundCopyJob : IUnknown
+{
+    typedef struct _BG_FILE_INFO {
+        LPWSTR RemoteName;
+        LPWSTR LocalName;
+    } BG_FILE_INFO;
+
+    typedef struct _BG_JOB_PROGRESS {
+        UINT64 BytesTotal;
+        UINT64 BytesTransferred;
+        ULONG FilesTotal;
+        ULONG FilesTransferred;
+    } BG_JOB_PROGRESS;
+
+    typedef struct _BG_JOB_TIMES {
+        FILETIME CreationTime;
+        FILETIME ModificationTime;
+        FILETIME TransferCompletionTime;
+    } BG_JOB_TIMES;
+
+    typedef enum {
+        BG_JOB_PRIORITY_FOREGROUND = 0,
+        BG_JOB_PRIORITY_HIGH = 1,
+        BG_JOB_PRIORITY_NORMAL = 2,
+        BG_JOB_PRIORITY_LOW = 3
+    } BG_JOB_PRIORITY;
+
+    typedef enum {
+        BG_JOB_STATE_QUEUED = 0,
+        BG_JOB_STATE_CONNECTING = 1,
+        BG_JOB_STATE_TRANSFERRING = 2,
+        BG_JOB_STATE_SUSPENDED = 3,
+        BG_JOB_STATE_ERROR = 4,
+        BG_JOB_STATE_TRANSIENT_ERROR = 5,
+        BG_JOB_STATE_TRANSFERRED = 6,
+        BG_JOB_STATE_ACKNOWLEDGED = 7,
+        BG_JOB_STATE_CANCELLED = 8
+    } BG_JOB_STATE;
+
+    typedef enum {
+       BG_JOB_TYPE_DOWNLOAD = 0,
+       BG_JOB_TYPE_UPLOAD = 1,
+       BG_JOB_TYPE_UPLOAD_REPLY = 2
+    } BG_JOB_TYPE;
+
+    typedef enum {
+        BG_JOB_PROXY_USAGE_PRECONFIG,
+        BG_JOB_PROXY_USAGE_NO_PROXY,
+        BG_JOB_PROXY_USAGE_OVERRIDE,
+        BG_JOB_PROXY_USAGE_AUTODETECT
+    } BG_JOB_PROXY_USAGE;
+
+
+    HRESULT AddFileSet(
+            [in] ULONG cFileCount,
+            [in,size_is(cFileCount)] BG_FILE_INFO *pFileSet
+    );
+
+    HRESULT AddFile(
+            [in] LPCWSTR RemoteUrl,
+            [in] LPCWSTR LocalName
+    );
+
+    HRESULT EnumFiles(
+            [out] IEnumBackgroundCopyFiles **pEnum
+    );
+
+    HRESULT Suspend();
+
+    HRESULT Resume();
+
+    HRESULT Cancel();
+
+    HRESULT Complete();
+
+    HRESULT GetId(
+            [out] GUID *pVal
+    );
+
+    HRESULT GetType(
+            [out] BG_JOB_TYPE *pVal
+    );
+
+    HRESULT GetProgress(
+            [out] BG_JOB_PROGRESS *pVal
+    );
+
+    HRESULT GetTimes(
+            [out] BG_JOB_TIMES *pVal
+    );
+
+    HRESULT GetState(
+            [out] BG_JOB_STATE *pVal
+    );
+
+    HRESULT GetError(
+            [out] IBackgroundCopyError **ppError
+    );
+
+    HRESULT GetOwner(
+            [out] LPWSTR *pVal
+    );
+
+    HRESULT SetDisplayName(
+            [in] LPCWSTR Val
+    );
+
+    HRESULT GetDisplayName(
+            [out] LPWSTR *pVal
+    );
+
+    HRESULT SetDescription(
+            [in] LPCWSTR Val
+    );
+
+    HRESULT GetDescription(
+            [out] LPWSTR *pVal
+    );
+
+    HRESULT SetPriority(
+            [in] BG_JOB_PRIORITY Val
+    );
+
+    HRESULT GetPriority(
+            [out] BG_JOB_PRIORITY *pVal
+    );
+
+    HRESULT SetNotifyFlags(
+            [in] ULONG Val
+    );
+
+    HRESULT GetNotifyFlags(
+            [out] ULONG *pVal
+    );
+
+    HRESULT SetNotifyInterface(
+            [in] IUnknown *Val
+    );
+
+    HRESULT GetNotifyInterface(
+            [out] IUnknown ** pVal
+    );
+
+    HRESULT SetMinimumRetryDelay(
+            [in] ULONG Seconds
+    );
+
+    HRESULT GetMinimumRetryDelay(
+            [out] ULONG *Seconds
+    );
+
+    HRESULT SetNoProgressTimeout(
+            [in] ULONG Seconds
+    );
+
+    HRESULT GetNoProgressTimeout(
+            [out] ULONG *Seconds
+    );
+
+    HRESULT GetErrorCount(
+            [out] ULONG *Errors
+    );
+
+    HRESULT SetProxySettings(
+            [in] BG_JOB_PROXY_USAGE ProxyUsage,
+            [in,string,unique] const WCHAR *ProxyList,
+            [in,string,unique] const WCHAR *ProxyBypassList
+    );
+
+    HRESULT GetProxySettings(
+            [out] BG_JOB_PROXY_USAGE *pProxyUsage,
+            [out] LPWSTR *pProxyList,
+            [out] LPWSTR *pProxyBypassList
+    );
+
+    HRESULT TakeOwnership();
+}
+
+[
+    uuid(1af4f612-3b71-466f-8f58-7b6f73ac57ad),
+    odl
+]
+interface IEnumBackgroundCopyJobs : IUnknown
+{
+    HRESULT Next(
+            [in] ULONG celt,
+            [out,size_is(BG_ENUM_SIZEIS(celt)),length_is(BG_ENUM_LENGTHIS(celt,pceltFetched))] IBackgroundCopyJob **rgelt,
+            [in,out,unique] ULONG *pceltFetched
+    );
+
+    HRESULT Skip(
+            [in] ULONG celt
+    );
+
+    HRESULT Reset();
+
+    HRESULT Clone(
+            [out] IEnumBackgroundCopyJobs **ppenum
+    );
+
+    HRESULT GetCount(
+            [out] ULONG *puCount
+    );
+}
+
+
+[
+    uuid(97ea99c7-0186-4ad4-8df9-c5b4e0ed6b22),
+    odl
+]
+interface IBackgroundCopyCallback : IUnknown
+{
+    HRESULT JobTransferred(
+            [in] IBackgroundCopyJob *pJob
+    );
+
+    HRESULT JobError(
+            [in] IBackgroundCopyJob *pJob,
+            [in] IBackgroundCopyError *pError
+    );
+
+    HRESULT JobModification(
+            [in] IBackgroundCopyJob *pJob,
+            [in] DWORD dwReserved
+    );
+}
+
+[
+    uuid(5ce34c0d-0dc9-4c1f-897c-daa1b78cee7c),
+    odl
+]
+interface IBackgroundCopyManager : IUnknown
+{
+    cpp_quote("#define BG_JOB_ENUM_ALL_USERS 0x0001")
+
+    HRESULT CreateJob(
+            [in] LPCWSTR DisplayName,
+            [in] BG_JOB_TYPE Type,
+            [out] GUID *pJobId,
+            [out] IBackgroundCopyJob **ppJob
+    );
+
+    HRESULT GetJob(
+            [in] REFGUID jobID,
+            [out] IBackgroundCopyJob **ppJob
+    );
+
+    HRESULT EnumJobs(
+            [in] DWORD dwFlags,
+            [out] IEnumBackgroundCopyJobs **ppEnum
+    );
+    HRESULT GetErrorDescription(
+            [in] HRESULT hResult,
+            [in] DWORD LanguageId,
+            [out] LPWSTR *pErrorDescription);
+}
+
+
+[
+    uuid(1deeb74f-7915-4560-b558-918c83f176a6),
+    version(1.0)
+]
+library BackgroundCopyManager
+{
+    [
+        uuid(4991d34b-80a1-4291-83b6-3328366b9097),
+    ]
+    coclass BackgroundCopyManager
+    {
+        [default] interface IBackgroundCopyManager;
+    };
+
+    interface IBackgroundCopyCallback;
+}

reactos/include/psdk/bits1_5.idl

@@ -0,0 +1,88 @@
+/*
+ * Background Intelligent Transfer Service (BITS) 1.5 interface
+ *
+ * Copyright 2008 Google (Dan Hipschman)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
+ */
+
+#ifndef DO_NO_IMPORTS
+import "bits.idl";
+#endif
+
+[
+    uuid(54b50739-686f-45eb-9dff-d6a9a0faa9af),
+    odl
+]
+interface IBackgroundCopyJob2 : IBackgroundCopyJob
+{
+    HRESULT SetNotifyCmdLine([unique] LPCWSTR prog, [unique] LPCWSTR params);
+    HRESULT GetNotifyCmdLine([out] LPWSTR *prog, [out] LPWSTR *params);
+
+    typedef struct _BG_JOB_REPLY_PROGRESS
+    {
+        UINT64 BytesTotal;
+        UINT64 BytesTransferred;
+    } BG_JOB_REPLY_PROGRESS;
+
+    HRESULT GetReplyProgress([in, out] BG_JOB_REPLY_PROGRESS *progress);
+    HRESULT GetReplyData([out, size_is( , (unsigned long) *pLength)] byte **pBuffer,
+                         [in, out, unique] UINT64 *pLength);
+    HRESULT SetReplyFileName([unique] LPCWSTR filename);
+    HRESULT GetReplyFileName([out] LPWSTR *pFilename);
+
+    typedef enum
+    {
+        BG_AUTH_TARGET_SERVER = 1,
+        BG_AUTH_TARGET_PROXY
+    } BG_AUTH_TARGET;
+
+    typedef enum
+    {
+        BG_AUTH_SCHEME_BASIC = 1,
+        BG_AUTH_SCHEME_DIGEST,
+        BG_AUTH_SCHEME_NTLM,
+        BG_AUTH_SCHEME_NEGOTIATE,
+        BG_AUTH_SCHEME_PASSPORT
+    } BG_AUTH_SCHEME;
+
+    typedef struct
+    {
+        LPWSTR UserName;
+        LPWSTR Password;
+    } BG_BASIC_CREDENTIALS;
+    typedef BG_BASIC_CREDENTIALS *PBG_BASIC_CREDENTIALS;
+
+    typedef [switch_type(BG_AUTH_SCHEME)] union
+    {
+        [case(BG_AUTH_SCHEME_BASIC, BG_AUTH_SCHEME_DIGEST, BG_AUTH_SCHEME_NTLM,
+              BG_AUTH_SCHEME_NEGOTIATE, BG_AUTH_SCHEME_PASSPORT)]
+        BG_BASIC_CREDENTIALS Basic;
+        [default]
+        ;
+    } BG_AUTH_CREDENTIALS_UNION;
+
+    typedef struct
+    {
+        BG_AUTH_TARGET Target;
+        BG_AUTH_SCHEME Scheme;
+        [switch_is(Scheme)] BG_AUTH_CREDENTIALS_UNION Credentials;
+    } BG_AUTH_CREDENTIALS;
+    typedef BG_AUTH_CREDENTIALS *PBG_AUTH_CREDENTIALS;
+
+    HRESULT SetCredentials(BG_AUTH_CREDENTIALS *cred);
+    HRESULT RemoveCredentials(BG_AUTH_TARGET target, BG_AUTH_SCHEME scheme);
+}

reactos/include/psdk/bitsmsg.h

@@ -0,0 +1,81 @@
+/*
+ * Standard return values that may be generated by BITS
+ *
+ * Copyright 2007 Google (Roy Shea)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __WINE_BITMSG_H__
+#define __WINE_BITMSG_H__
+
+#define BG_S_PARTIAL_COMPLETE                   0x00200017
+#define BG_S_UNABLE_TO_DELETE_FILES             0x0020001A
+#define BG_S_OVERRIDDEN_BY_POLICY               0x00200055
+
+#define BG_E_HTTP_ERROR_400                     0x80190190
+#define BG_E_HTTP_ERROR_401                     0x80190191
+#define BG_E_HTTP_ERROR_404                     0x80190194
+#define BG_E_HTTP_ERROR_407                     0x80190197
+#define BG_E_HTTP_ERROR_414                     0x8019019E
+#define BG_E_HTTP_ERROR_501                     0x801901F5
+#define BG_E_HTTP_ERROR_503                     0x801901F7
+#define BG_E_HTTP_ERROR_504                     0x801901F8
+#define BG_E_HTTP_ERROR_505                     0x801901F9
+
+#define BG_E_NOT_FOUND                          0x80200001
+#define BG_E_INVALID_STATE                      0x80200002
+#define BG_E_EMPTY                              0x80200003
+#define BG_E_FILE_NOT_AVAILABLE                 0x80200004
+#define BG_E_PROTOCOL_NOT_AVAILABLE             0x80200005
+#define BG_E_DESTINATION_LOCKED                 0x8020000D
+#define BG_E_VOLUME_CHANGED                     0x8020000E
+#define BG_E_ERROR_INFORMATION_UNAVAILABLE      0x8020000F
+#define BG_E_NETWORK_DISCONNECTED               0x80200010
+#define BG_E_MISSING_FILE_SIZE                  0x80200011
+#define BG_E_INSUFFICIENT_HTTP_SUPPORT          0x80200012
+#define BG_E_INSUFFICIENT_RANGE_SUPPORT         0x80200013
+#define BG_E_REMOTE_NOT_SUPPORTED               0x80200014
+#define BG_E_NEW_OWNER_DIFF_MAPPING             0x80200015
+#define BG_E_NEW_OWNER_NO_FILE_ACCESS           0x80200016
+#define BG_E_PROXY_LIST_TOO_LARGE               0x80200018
+#define BG_E_PROXY_BYPASS_LIST_TOO_LARGE        0x80200019
+#define BG_E_TOO_MANY_FILES                     0x8020001C
+#define BG_E_LOCAL_FILE_CHANGED                 0x8020001D
+#define BG_E_TOO_LARGE                          0x80200020
+#define BG_E_STRING_TOO_LONG                    0x80200021
+#define BG_E_CLIENT_SERVER_PROTOCOL_MISMATCH    0x80200022
+#define BG_E_SERVER_EXECUTE_ENABLED             0x80200023
+#define BG_E_USERNAME_TOO_LARGE                 0x80200025
+#define BG_E_PASSWORD_TOO_LARGE                 0x80200026
+#define BG_E_INVALID_AUTH_TARGET                0x80200027
+#define BG_E_INVALID_AUTH_SCHEME                0x80200028
+#define BG_E_INVALID_RANGE                      0x8020002B
+#define BG_E_OVERLAPPING_RANGES                 0x8020002C
+#define BG_E_BLOCKED_BY_POLICY                  0x8020003E
+#define BG_E_INVALID_PROXY_INFO                 0x8020003F
+#define BG_E_INVALID_CREDENTIALS                0x80200040
+#define BG_E_RECORD_DELETED                     0x80200042
+#define BG_E_UPNP_ERROR                         0x80200045
+#define BG_E_PEERCACHING_DISABLED               0x80200047
+#define BG_E_BUSYCACHERECORD                    0x80200048
+#define BG_E_TOO_MANY_JOBS_PER_USER             0x80200049
+#define BG_E_TOO_MANY_JOBS_PER_MACHINE          0x80200050
+#define BG_E_TOO_MANY_FILES_IN_JOB              0x80200051
+#define BG_E_TOO_MANY_RANGES_IN_FILE            0x80200052
+#define BG_E_VALIDATION_FAILED                  0x80200053
+#define BG_E_MAXDOWNLOAD_TIMEOUT                0x80200054
+
+#endif /* #ifndef __WINE_BITMSG_H__ */

reactos/include/psdk/psdk.rbuild

@@ -4,6 +4,8 @@
 	<file>activaut.idl</file>
 	<file>activdbg.idl</file>
 	<file>activscp.idl</file>
+	<file>bits1_5.idl</file>
+	<file>bits.idl</file>
 	<file>control.idl</file>
 	<file>ctxtcall.idl</file>
 	<file>dimm.idl</file>