dll/win32/qmgr/qmgr.c

   1 /*
   2  * Queue Manager (BITS) core functions
   3  *
   4  * Copyright 2007, 2008 Google (Roy Shea, Dan Hipschman)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "qmgr.h"
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(qmgr);
  25
  26 /* Add a reference to the iface pointer */
  27 static ULONG WINAPI BITS_IBackgroundCopyManager_AddRef(
  28         IBackgroundCopyManager* iface)
  29 {
  30     return 2;
  31 }
  32
  33 /* Attempt to provide a new interface to interact with iface */
  34 static HRESULT WINAPI BITS_IBackgroundCopyManager_QueryInterface(
  35         IBackgroundCopyManager* iface,
  36         REFIID riid,
  37         LPVOID *ppvObject)
  38 {
  39     BackgroundCopyManagerImpl * This = (BackgroundCopyManagerImpl *)iface;
  40
  41     TRACE("IID: %s\n", debugstr_guid(riid));
  42
  43     if (IsEqualGUID(riid, &IID_IUnknown) ||
  44             IsEqualGUID(riid, &IID_IBackgroundCopyManager))
  45     {
  46         *ppvObject = &This->lpVtbl;
  47         BITS_IBackgroundCopyManager_AddRef(iface);
  48         return S_OK;
  49     }
  50
  51     *ppvObject = NULL;
  52     return E_NOINTERFACE;
  53 }
  54
  55 /* Release an interface to iface */
  56 static ULONG WINAPI BITS_IBackgroundCopyManager_Release(
  57         IBackgroundCopyManager* iface)
  58 {
  59     return 1;
  60 }
  61
  62 /*** IBackgroundCopyManager interface methods ***/
  63
  64 static HRESULT WINAPI BITS_IBackgroundCopyManager_CreateJob(
  65         IBackgroundCopyManager* iface,
  66         LPCWSTR DisplayName,
  67         BG_JOB_TYPE Type,
  68         GUID *pJobId,
  69         IBackgroundCopyJob **ppJob)
  70 {
  71     BackgroundCopyManagerImpl * This = (BackgroundCopyManagerImpl *) iface;
  72     BackgroundCopyJobImpl *job;
  73     HRESULT hres;
  74     TRACE("\n");
  75
  76     hres = BackgroundCopyJobConstructor(DisplayName, Type, pJobId,
  77                                         (LPVOID *) ppJob);
  78     if (FAILED(hres))
  79         return hres;
  80
  81     /* Add a reference to the job to job list */
  82     IBackgroundCopyJob_AddRef(*ppJob);
  83     job = (BackgroundCopyJobImpl *) *ppJob;
  84     EnterCriticalSection(&This->cs);
  85     list_add_head(&This->jobs, &job->entryFromQmgr);
  86     LeaveCriticalSection(&This->cs);
  87     return S_OK;
  88 }
  89
  90 static HRESULT WINAPI BITS_IBackgroundCopyManager_GetJob(
  91         IBackgroundCopyManager* iface,
  92         REFGUID jobID,
  93         IBackgroundCopyJob **ppJob)
  94 {
  95     FIXME("Not implemented\n");
  96     return E_NOTIMPL;
  97 }
  98
  99 static HRESULT WINAPI BITS_IBackgroundCopyManager_EnumJobs(
 100         IBackgroundCopyManager* iface,
 101         DWORD dwFlags,
 102         IEnumBackgroundCopyJobs **ppEnum)
 103 {
 104     TRACE("\n");
 105     return EnumBackgroundCopyJobsConstructor((LPVOID *) ppEnum, iface);
 106 }
 107
 108 static HRESULT WINAPI BITS_IBackgroundCopyManager_GetErrorDescription(
 109         IBackgroundCopyManager* iface,
 110         HRESULT hResult,
 111         DWORD LanguageId,
 112         LPWSTR *pErrorDescription)
 113 {
 114     FIXME("Not implemented\n");
 115     return E_NOTIMPL;
 116 }
 117
 118
 119 static const IBackgroundCopyManagerVtbl BITS_IBackgroundCopyManager_Vtbl =
 120 {
 121     BITS_IBackgroundCopyManager_QueryInterface,
 122     BITS_IBackgroundCopyManager_AddRef,
 123     BITS_IBackgroundCopyManager_Release,
 124     BITS_IBackgroundCopyManager_CreateJob,
 125     BITS_IBackgroundCopyManager_GetJob,
 126     BITS_IBackgroundCopyManager_EnumJobs,
 127     BITS_IBackgroundCopyManager_GetErrorDescription
 128 };
 129
 130 BackgroundCopyManagerImpl globalMgr = {
 131     &BITS_IBackgroundCopyManager_Vtbl,
 132     { NULL, -1, 0, 0, 0, 0 },
 133     NULL,
 134     LIST_INIT(globalMgr.jobs)
 135 };
 136
 137 /* Constructor for instances of background copy manager */
 138 HRESULT BackgroundCopyManagerConstructor(IUnknown *pUnkOuter, LPVOID *ppObj)
 139 {
 140     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 141     *ppObj = &globalMgr;
 142     return S_OK;
 143 }
 144
 145 DWORD WINAPI fileTransfer(void *param)
 146 {
 147     BackgroundCopyManagerImpl *qmgr = &globalMgr;
 148     HANDLE events[2];
 149
 150     events[0] = stop_event;
 151     events[1] = qmgr->jobEvent;
 152
 153     for (;;)
 154     {
 155         BackgroundCopyJobImpl *job, *jobCur;
 156         BOOL haveJob = FALSE;
 157
 158         /* Check if it's the stop_event */
 159         if (WaitForMultipleObjects(2, events, FALSE, INFINITE) == WAIT_OBJECT_0)
 160         {
 161             LIST_FOR_EACH_ENTRY_SAFE(job, jobCur, &qmgr->jobs, BackgroundCopyJobImpl, entryFromQmgr)
 162             {
 163                 list_remove(&job->entryFromQmgr);
 164                 IBackgroundCopyJob_Release((IBackgroundCopyJob *) job);
 165             }
 166             return 0;
 167         }
 168
 169         /* Note that other threads may add files to the job list, but only
 170            this thread ever deletes them so we don't need to worry about jobs
 171            magically disappearing from the list.  */
 172         EnterCriticalSection(&qmgr->cs);
 173
 174         LIST_FOR_EACH_ENTRY_SAFE(job, jobCur, &qmgr->jobs, BackgroundCopyJobImpl, entryFromQmgr)
 175         {
 176             if (job->state == BG_JOB_STATE_ACKNOWLEDGED || job->state == BG_JOB_STATE_CANCELLED)
 177             {
 178                 list_remove(&job->entryFromQmgr);
 179                 IBackgroundCopyJob_Release((IBackgroundCopyJob *) job);
 180             }
 181             else if (job->state == BG_JOB_STATE_QUEUED)
 182             {
 183                 haveJob = TRUE;
 184                 break;
 185             }
 186             else if (job->state == BG_JOB_STATE_CONNECTING
 187                      || job->state == BG_JOB_STATE_TRANSFERRING)
 188             {
 189                 ERR("Invalid state for job %p: %d\n", job, job->state);
 190             }
 191         }
 192
 193         if (!haveJob)
 194             ResetEvent(qmgr->jobEvent);
 195
 196         LeaveCriticalSection(&qmgr->cs);
 197
 198         if (haveJob)
 199             processJob(job);
 200     }
 201 }