dlls/mstask/task.c

   1 /*
   2  * Copyright (C) 2008 Google (Roy Shea)
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "mstask_private.h"
  20 #include "wine/debug.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(mstask);
  23
  24 static void TaskDestructor(TaskImpl *This)
  25 {
  26     TRACE("%p\n", This);
  27     HeapFree(GetProcessHeap(), 0, This->taskName);
  28     HeapFree(GetProcessHeap(), 0, This);
  29     InterlockedDecrement(&dll_ref);
  30 }
  31
  32 static HRESULT WINAPI MSTASK_ITask_QueryInterface(
  33         ITask* iface,
  34         REFIID riid,
  35         void **ppvObject)
  36 {
  37     TaskImpl * This = (TaskImpl *)iface;
  38
  39     TRACE("IID: %s\n", debugstr_guid(riid));
  40     if (ppvObject == NULL)
  41         return E_POINTER;
  42
  43     if (IsEqualGUID(riid, &IID_IUnknown) ||
  44             IsEqualGUID(riid, &IID_ITask))
  45     {
  46         *ppvObject = &This->lpVtbl;
  47         ITask_AddRef(iface);
  48         return S_OK;
  49     }
  50
  51     WARN("Unknown interface: %s\n", debugstr_guid(riid));
  52     *ppvObject = NULL;
  53     return E_NOINTERFACE;
  54 }
  55
  56 static ULONG WINAPI MSTASK_ITask_AddRef(
  57         ITask* iface)
  58 {
  59     TaskImpl *This = (TaskImpl *)iface;
  60     ULONG ref;
  61     TRACE("\n");
  62     ref = InterlockedIncrement(&This->ref);
  63     return ref;
  64 }
  65
  66 static ULONG WINAPI MSTASK_ITask_Release(
  67         ITask* iface)
  68 {
  69     TaskImpl * This = (TaskImpl *)iface;
  70     ULONG ref;
  71     TRACE("\n");
  72     ref = InterlockedDecrement(&This->ref);
  73     if (ref == 0)
  74         TaskDestructor(This);
  75     return ref;
  76 }
  77
  78 static HRESULT WINAPI MSTASK_ITask_CreateTrigger(
  79         ITask* iface,
  80         WORD *piNewTrigger,
  81         ITaskTrigger **ppTrigger)
  82 {
  83     FIXME("(%p, %p, %p): stub\n", iface, piNewTrigger, ppTrigger);
  84     return E_NOTIMPL;
  85 }
  86
  87 static HRESULT WINAPI MSTASK_ITask_DeleteTrigger(
  88         ITask* iface,
  89         WORD iTrigger)
  90 {
  91     FIXME("(%p, %d): stub\n", iface, iTrigger);
  92     return E_NOTIMPL;
  93 }
  94
  95 static HRESULT WINAPI MSTASK_ITask_GetTriggerCount(
  96         ITask* iface,
  97         WORD *plCount)
  98 {
  99     FIXME("(%p, %p): stub\n", iface, plCount);
 100     return E_NOTIMPL;
 101 }
 102
 103 static HRESULT WINAPI MSTASK_ITask_GetTrigger(
 104         ITask* iface,
 105         WORD iTrigger,
 106         ITaskTrigger **ppTrigger)
 107 {
 108     FIXME("(%p, %d, %p): stub\n", iface, iTrigger, ppTrigger);
 109     return E_NOTIMPL;
 110 }
 111
 112 static HRESULT WINAPI MSTASK_ITask_GetTriggerString(
 113         ITask* iface,
 114         WORD iTrigger,
 115         LPWSTR *ppwszTrigger)
 116 {
 117     FIXME("(%p, %d, %p): stub\n", iface, iTrigger, ppwszTrigger);
 118     return E_NOTIMPL;
 119 }
 120
 121 static HRESULT WINAPI MSTASK_ITask_GetRunTimes(
 122         ITask* iface,
 123         const LPSYSTEMTIME pstBegin,
 124         const LPSYSTEMTIME pstEnd,
 125         WORD *pCount,
 126         LPSYSTEMTIME *rgstTaskTimes)
 127 {
 128     FIXME("(%p, %p, %p, %p, %p): stub\n", iface, pstBegin, pstEnd, pCount,
 129             rgstTaskTimes);
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI MSTASK_ITask_GetNextRunTime(
 134         ITask* iface,
 135         SYSTEMTIME *pstNextRun)
 136 {
 137     FIXME("(%p, %p): stub\n", iface, pstNextRun);
 138     return E_NOTIMPL;
 139 }
 140
 141 static HRESULT WINAPI MSTASK_ITask_SetIdleWait(
 142         ITask* iface,
 143         WORD wIdleMinutes,
 144         WORD wDeadlineMinutes)
 145 {
 146     FIXME("(%p, %d, %d): stub\n", iface, wIdleMinutes, wDeadlineMinutes);
 147     return E_NOTIMPL;
 148 }
 149
 150 static HRESULT WINAPI MSTASK_ITask_GetIdleWait(
 151         ITask* iface,
 152         WORD *pwIdleMinutes,
 153         WORD *pwDeadlineMinutes)
 154 {
 155     FIXME("(%p, %p, %p): stub\n", iface, pwIdleMinutes, pwDeadlineMinutes);
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI MSTASK_ITask_Run(
 160         ITask* iface)
 161 {
 162     FIXME("(%p): stub\n", iface);
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI MSTASK_ITask_Terminate(
 167         ITask* iface)
 168 {
 169     FIXME("(%p): stub\n", iface);
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT WINAPI MSTASK_ITask_EditWorkItem(
 174         ITask* iface,
 175         HWND hParent,
 176         DWORD dwReserved)
 177 {
 178     FIXME("(%p, %p, %d): stub\n", iface, hParent, dwReserved);
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT WINAPI MSTASK_ITask_GetMostRecentRunTime(
 183         ITask* iface,
 184         SYSTEMTIME *pstLastRun)
 185 {
 186     FIXME("(%p, %p): stub\n", iface, pstLastRun);
 187     return E_NOTIMPL;
 188 }
 189
 190 static HRESULT WINAPI MSTASK_ITask_GetStatus(
 191         ITask* iface,
 192         HRESULT *phrStatus)
 193 {
 194     FIXME("(%p, %p): stub\n", iface, phrStatus);
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI MSTASK_ITask_GetExitCode(
 199         ITask* iface,
 200         DWORD *pdwExitCode)
 201 {
 202     FIXME("(%p, %p): stub\n", iface, pdwExitCode);
 203     return E_NOTIMPL;
 204 }
 205
 206 static HRESULT WINAPI MSTASK_ITask_SetComment(
 207         ITask* iface,
 208         LPCWSTR pwszComment)
 209 {
 210     FIXME("(%p, %s): stub\n", iface, debugstr_w(pwszComment));
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI MSTASK_ITask_GetComment(
 215         ITask* iface,
 216         LPWSTR *ppwszComment)
 217 {
 218     FIXME("(%p, %p): stub\n", iface, ppwszComment);
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI MSTASK_ITask_SetCreator(
 223         ITask* iface,
 224         LPCWSTR pwszCreator)
 225 {
 226     FIXME("(%p, %p): stub\n", iface, pwszCreator);
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI MSTASK_ITask_GetCreator(
 231         ITask* iface,
 232         LPWSTR *ppwszCreator)
 233 {
 234     FIXME("(%p, %p): stub\n", iface, ppwszCreator);
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT WINAPI MSTASK_ITask_SetWorkItemData(
 239         ITask* iface,
 240         WORD cBytes,
 241         BYTE rgbData[])
 242 {
 243     FIXME("(%p, %d, %p): stub\n", iface, cBytes, rgbData);
 244     return E_NOTIMPL;
 245 }
 246
 247 static HRESULT WINAPI MSTASK_ITask_GetWorkItemData(
 248         ITask* iface,
 249         WORD *pcBytes,
 250         BYTE **ppBytes)
 251 {
 252     FIXME("(%p, %p, %p): stub\n", iface, pcBytes, ppBytes);
 253     return E_NOTIMPL;
 254 }
 255
 256 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryCount(
 257         ITask* iface,
 258         WORD wRetryCount)
 259 {
 260     FIXME("(%p, %d): stub\n", iface, wRetryCount);
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryCount(
 265         ITask* iface,
 266         WORD *pwRetryCount)
 267 {
 268     FIXME("(%p, %p): stub\n", iface, pwRetryCount);
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryInterval(
 273         ITask* iface,
 274         WORD wRetryInterval)
 275 {
 276     FIXME("(%p, %d): stub\n", iface, wRetryInterval);
 277     return E_NOTIMPL;
 278 }
 279
 280 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryInterval(
 281         ITask* iface,
 282         WORD *pwRetryInterval)
 283 {
 284     FIXME("(%p, %p): stub\n", iface, pwRetryInterval);
 285     return E_NOTIMPL;
 286 }
 287
 288 static HRESULT WINAPI MSTASK_ITask_SetFlags(
 289         ITask* iface,
 290         DWORD dwFlags)
 291 {
 292     FIXME("(%p, 0x%08x): stub\n", iface, dwFlags);
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI MSTASK_ITask_GetFlags(
 297         ITask* iface,
 298         DWORD *pdwFlags)
 299 {
 300     FIXME("(%p, %p): stub\n", iface, pdwFlags);
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI MSTASK_ITask_SetAccountInformation(
 305         ITask* iface,
 306         LPCWSTR pwszAccountName,
 307         LPCWSTR pwszPassword)
 308 {
 309     FIXME("(%p, %s, %s): stub\n", iface, debugstr_w(pwszAccountName),
 310             debugstr_w(pwszPassword));
 311     return E_NOTIMPL;
 312 }
 313
 314 static HRESULT WINAPI MSTASK_ITask_GetAccountInformation(
 315         ITask* iface,
 316         LPWSTR *ppwszAccountName)
 317 {
 318     FIXME("(%p, %p): stub\n", iface, ppwszAccountName);
 319     return E_NOTIMPL;
 320 }
 321
 322 static HRESULT WINAPI MSTASK_ITask_SetApplicationName(
 323         ITask* iface,
 324         LPCWSTR pwszApplicationName)
 325 {
 326     DWORD n;
 327     TaskImpl *This = (TaskImpl *)iface;
 328     LPWSTR tmp_name;
 329
 330     TRACE("(%p, %s)\n", iface, debugstr_w(pwszApplicationName));
 331
 332     /* Empty application name */
 333     if (pwszApplicationName[0] == 0)
 334     {
 335         HeapFree(GetProcessHeap(), 0, This->applicationName);
 336         This->applicationName = NULL;
 337         return S_OK;
 338     }
 339
 340     /* Attempt to set pwszApplicationName to a path resolved application name */
 341     n = SearchPathW(NULL, pwszApplicationName, NULL, 0, NULL, NULL);
 342     if (n)
 343     {
 344         tmp_name = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
 345         if (!tmp_name)
 346             return E_OUTOFMEMORY;
 347         n = SearchPathW(NULL, pwszApplicationName, NULL, n, tmp_name, NULL);
 348         if (n)
 349         {
 350             HeapFree(GetProcessHeap(), 0, This->applicationName);
 351             This->applicationName = tmp_name;
 352             return S_OK;
 353         }
 354         else
 355             HeapFree(GetProcessHeap(), 0, tmp_name);
 356     }
 357
 358     /* If unable to path resolve name, simply set to pwszApplicationName */
 359     n = (lstrlenW(pwszApplicationName) + 1);
 360     tmp_name = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
 361     if (!tmp_name)
 362         return E_OUTOFMEMORY;
 363     lstrcpyW(tmp_name, pwszApplicationName);
 364     HeapFree(GetProcessHeap(), 0, This->applicationName);
 365     This->applicationName = tmp_name;
 366     return S_OK;
 367 }
 368
 369 static HRESULT WINAPI MSTASK_ITask_GetApplicationName(
 370         ITask* iface,
 371         LPWSTR *ppwszApplicationName)
 372 {
 373     DWORD n;
 374     TaskImpl *This = (TaskImpl *)iface;
 375
 376     TRACE("(%p, %p)\n", iface, ppwszApplicationName);
 377
 378     n = This->applicationName ? lstrlenW(This->applicationName) + 1 : 1;
 379     *ppwszApplicationName = CoTaskMemAlloc(n * sizeof(WCHAR));
 380     if (!*ppwszApplicationName)
 381         return E_OUTOFMEMORY;
 382
 383     if (!This->applicationName)
 384         *ppwszApplicationName[0] = 0;
 385     else
 386         lstrcpyW(*ppwszApplicationName, This->applicationName);
 387
 388     return S_OK;
 389 }
 390
 391 static HRESULT WINAPI MSTASK_ITask_SetParameters(
 392         ITask* iface,
 393         LPCWSTR pwszParameters)
 394 {
 395     FIXME("(%p, %s): stub\n", iface, debugstr_w(pwszParameters));
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT WINAPI MSTASK_ITask_GetParameters(
 400         ITask* iface,
 401         LPWSTR *ppwszParameters)
 402 {
 403     FIXME("(%p, %p): stub\n", iface, ppwszParameters);
 404     return E_NOTIMPL;
 405 }
 406
 407 static HRESULT WINAPI MSTASK_ITask_SetWorkingDirectory(
 408         ITask* iface,
 409         LPCWSTR pwszWorkingDirectory)
 410 {
 411     FIXME("(%p, %s): stub\n", iface, debugstr_w(pwszWorkingDirectory));
 412     return E_NOTIMPL;
 413 }
 414
 415 static HRESULT WINAPI MSTASK_ITask_GetWorkingDirectory(
 416         ITask* iface,
 417         LPWSTR *ppwszWorkingDirectory)
 418 {
 419     FIXME("(%p, %p): stub\n", iface, ppwszWorkingDirectory);
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI MSTASK_ITask_SetPriority(
 424         ITask* iface,
 425         DWORD dwPriority)
 426 {
 427     FIXME("(%p, 0x%08x): stub\n", iface, dwPriority);
 428     return E_NOTIMPL;
 429 }
 430
 431 static HRESULT WINAPI MSTASK_ITask_GetPriority(
 432         ITask* iface,
 433         DWORD *pdwPriority)
 434 {
 435     FIXME("(%p, %p): stub\n", iface, pdwPriority);
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI MSTASK_ITask_SetTaskFlags(
 440         ITask* iface,
 441         DWORD dwFlags)
 442 {
 443     FIXME("(%p, 0x%08x): stub\n", iface, dwFlags);
 444     return E_NOTIMPL;
 445 }
 446
 447 static HRESULT WINAPI MSTASK_ITask_GetTaskFlags(
 448         ITask* iface,
 449         DWORD *pdwFlags)
 450 {
 451     FIXME("(%p, %p): stub\n", iface, pdwFlags);
 452     return E_NOTIMPL;
 453 }
 454
 455 static HRESULT WINAPI MSTASK_ITask_SetMaxRunTime(
 456         ITask* iface,
 457         DWORD dwMaxRunTime)
 458 {
 459     FIXME("(%p, %d): stub\n", iface, dwMaxRunTime);
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI MSTASK_ITask_GetMaxRunTime(
 464         ITask* iface,
 465         DWORD *pdwMaxRunTime)
 466 {
 467     FIXME("(%p, %p): stub\n", iface, pdwMaxRunTime);
 468     return E_NOTIMPL;
 469 }
 470
 471 static HRESULT WINAPI MSTASK_IPersistFile_QueryInterface(
 472         IPersistFile* iface,
 473         REFIID riid,
 474         void **ppvObject)
 475 {
 476     FIXME("(%p, %s, %p): stub\n", iface, debugstr_guid(riid), ppvObject);
 477     return E_NOTIMPL;
 478 }
 479
 480 static ULONG WINAPI MSTASK_IPersistFile_AddRef(
 481         IPersistFile* iface)
 482 {
 483     FIXME("(%p): stub\n", iface);
 484     return E_NOTIMPL;
 485 }
 486
 487 static ULONG WINAPI MSTASK_IPersistFile_Release(
 488         IPersistFile* iface)
 489 {
 490     FIXME("(%p): stub\n", iface);
 491     return E_NOTIMPL;
 492 }
 493
 494 static HRESULT WINAPI MSTASK_IPersistFile_GetClassID(
 495         IPersistFile* iface,
 496         CLSID *pClassID)
 497 {
 498     FIXME("(%p, %p): stub\n", iface, pClassID);
 499     return E_NOTIMPL;
 500 }
 501
 502 static HRESULT WINAPI MSTASK_IPersistFile_IsDirty(
 503         IPersistFile* iface)
 504 {
 505     FIXME("(%p): stub\n", iface);
 506     return E_NOTIMPL;
 507 }
 508
 509 static HRESULT WINAPI MSTASK_IPersistFile_Load(
 510         IPersistFile* iface,
 511         LPCOLESTR pszFileName,
 512         DWORD dwMode)
 513 {
 514     FIXME("(%p, %p, 0x%08x): stub\n", iface, pszFileName, dwMode);
 515     return E_NOTIMPL;
 516 }
 517
 518 static HRESULT WINAPI MSTASK_IPersistFile_Save(
 519         IPersistFile* iface,
 520         LPCOLESTR pszFileName,
 521         BOOL fRemember)
 522 {
 523     FIXME("(%p, %p, %d): stub\n", iface, pszFileName, fRemember);
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT WINAPI MSTASK_IPersistFile_SaveCompleted(
 528         IPersistFile* iface,
 529         LPCOLESTR pszFileName)
 530 {
 531     FIXME("(%p, %p): stub\n", iface, pszFileName);
 532     return E_NOTIMPL;
 533 }
 534
 535 static HRESULT WINAPI MSTASK_IPersistFile_GetCurFile(
 536         IPersistFile* iface,
 537         LPOLESTR *ppszFileName)
 538 {
 539     FIXME("(%p, %p): stub\n", iface, ppszFileName);
 540     return E_NOTIMPL;
 541 }
 542
 543
 544 static const ITaskVtbl MSTASK_ITaskVtbl =
 545 {
 546     MSTASK_ITask_QueryInterface,
 547     MSTASK_ITask_AddRef,
 548     MSTASK_ITask_Release,
 549     MSTASK_ITask_CreateTrigger,
 550     MSTASK_ITask_DeleteTrigger,
 551     MSTASK_ITask_GetTriggerCount,
 552     MSTASK_ITask_GetTrigger,
 553     MSTASK_ITask_GetTriggerString,
 554     MSTASK_ITask_GetRunTimes,
 555     MSTASK_ITask_GetNextRunTime,
 556     MSTASK_ITask_SetIdleWait,
 557     MSTASK_ITask_GetIdleWait,
 558     MSTASK_ITask_Run,
 559     MSTASK_ITask_Terminate,
 560     MSTASK_ITask_EditWorkItem,
 561     MSTASK_ITask_GetMostRecentRunTime,
 562     MSTASK_ITask_GetStatus,
 563     MSTASK_ITask_GetExitCode,
 564     MSTASK_ITask_SetComment,
 565     MSTASK_ITask_GetComment,
 566     MSTASK_ITask_SetCreator,
 567     MSTASK_ITask_GetCreator,
 568     MSTASK_ITask_SetWorkItemData,
 569     MSTASK_ITask_GetWorkItemData,
 570     MSTASK_ITask_SetErrorRetryCount,
 571     MSTASK_ITask_GetErrorRetryCount,
 572     MSTASK_ITask_SetErrorRetryInterval,
 573     MSTASK_ITask_GetErrorRetryInterval,
 574     MSTASK_ITask_SetFlags,
 575     MSTASK_ITask_GetFlags,
 576     MSTASK_ITask_SetAccountInformation,
 577     MSTASK_ITask_GetAccountInformation,
 578     MSTASK_ITask_SetApplicationName,
 579     MSTASK_ITask_GetApplicationName,
 580     MSTASK_ITask_SetParameters,
 581     MSTASK_ITask_GetParameters,
 582     MSTASK_ITask_SetWorkingDirectory,
 583     MSTASK_ITask_GetWorkingDirectory,
 584     MSTASK_ITask_SetPriority,
 585     MSTASK_ITask_GetPriority,
 586     MSTASK_ITask_SetTaskFlags,
 587     MSTASK_ITask_GetTaskFlags,
 588     MSTASK_ITask_SetMaxRunTime,
 589     MSTASK_ITask_GetMaxRunTime
 590 };
 591
 592 static const IPersistFileVtbl MSTASK_IPersistFileVtbl =
 593 {
 594     MSTASK_IPersistFile_QueryInterface,
 595     MSTASK_IPersistFile_AddRef,
 596     MSTASK_IPersistFile_Release,
 597     MSTASK_IPersistFile_GetClassID,
 598     MSTASK_IPersistFile_IsDirty,
 599     MSTASK_IPersistFile_Load,
 600     MSTASK_IPersistFile_Save,
 601     MSTASK_IPersistFile_SaveCompleted,
 602     MSTASK_IPersistFile_GetCurFile
 603 };
 604
 605 HRESULT TaskConstructor(LPCWSTR pwszTaskName, LPVOID *ppObj)
 606 {
 607     TaskImpl *This;
 608     int n;
 609
 610     TRACE("(%s, %p)\n", debugstr_w(pwszTaskName), ppObj);
 611
 612     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 613     if (!This)
 614         return E_OUTOFMEMORY;
 615
 616     This->lpVtbl = &MSTASK_ITaskVtbl;
 617     This->persistVtbl = &MSTASK_IPersistFileVtbl;
 618     This->ref = 1;
 619     n = (lstrlenW(pwszTaskName) + 1) * sizeof(WCHAR);
 620     This->taskName = HeapAlloc(GetProcessHeap(), 0, n);
 621     if (!This->taskName)
 622     {
 623         HeapFree(GetProcessHeap(), 0, This);
 624         return E_OUTOFMEMORY;
 625     }
 626     lstrcpyW(This->taskName, pwszTaskName);
 627     This->applicationName = NULL;
 628
 629     *ppObj = &This->lpVtbl;
 630     InterlockedIncrement(&dll_ref);
 631     return S_OK;
 632 }