dlls/schedsvc/schedsvc.c

   1 /*
   2  * Task Scheduler Service
   3  *
   4  * Copyright 2014 Dmitry Timoshkov
   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 <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "schrpc.h"
  25 #include "taskschd.h"
  26 #include "wine/debug.h"
  27
  28 #include "schedsvc_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(schedsvc);
  31
  32 static const char bom_utf8[] = { 0xef,0xbb,0xbf };
  33
  34 HRESULT __cdecl SchRpcHighestVersion(DWORD *version)
  35 {
  36     TRACE("%p\n", version);
  37
  38     *version = MAKELONG(3, 1);
  39     return S_OK;
  40 }
  41
  42 static WCHAR *get_full_name(const WCHAR *path, WCHAR **relative_path)
  43 {
  44     static const WCHAR tasksW[] = { '\\','t','a','s','k','s','\\',0 };
  45     WCHAR *target;
  46     int len;
  47
  48     len = GetSystemDirectoryW(NULL, 0);
  49     len += strlenW(tasksW) + strlenW(path);
  50
  51     target = heap_alloc(len * sizeof(WCHAR));
  52     if (target)
  53     {
  54         GetSystemDirectoryW(target, len);
  55         strcatW(target, tasksW);
  56         if (relative_path)
  57             *relative_path = target + strlenW(target) - 1;
  58         while (*path == '\\') path++;
  59         strcatW(target, path);
  60     }
  61     return target;
  62 }
  63
  64 /*
  65  * Recursively create all directories in the path.
  66  */
  67 static HRESULT create_directory(const WCHAR *path)
  68 {
  69     HRESULT hr = S_OK;
  70     WCHAR *new_path;
  71     int len;
  72
  73     new_path = heap_alloc((strlenW(path) + 1) * sizeof(WCHAR));
  74     if (!new_path) return E_OUTOFMEMORY;
  75
  76     strcpyW(new_path, path);
  77
  78     len = strlenW(new_path);
  79     while (len && new_path[len - 1] == '\\')
  80     {
  81         new_path[len - 1] = 0;
  82         len--;
  83     }
  84
  85     while (!CreateDirectoryW(new_path, NULL))
  86     {
  87         WCHAR *slash;
  88         DWORD last_error = GetLastError();
  89
  90         if (last_error != ERROR_PATH_NOT_FOUND || !(slash = strrchrW(new_path, '\\')))
  91         {
  92             hr = HRESULT_FROM_WIN32(last_error);
  93             break;
  94         }
  95
  96         len = slash - new_path;
  97         new_path[len] = 0;
  98         hr = create_directory(new_path);
  99         if (hr != S_OK) break;
 100         new_path[len] = '\\';
 101     }
 102
 103     heap_free(new_path);
 104     return hr;
 105 }
 106
 107 static HRESULT write_xml_utf8(const WCHAR *name, DWORD disposition, const WCHAR *xmlW)
 108 {
 109     static const char comment[] = "<!-- Task definition created by Wine -->\n";
 110     HANDLE hfile;
 111     DWORD size;
 112     char *xml;
 113     HRESULT hr = S_OK;
 114
 115     hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, disposition, 0, 0);
 116     if (hfile == INVALID_HANDLE_VALUE)
 117     {
 118         if (GetLastError() == ERROR_FILE_EXISTS)
 119             return HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS);
 120
 121         return HRESULT_FROM_WIN32(GetLastError());
 122     }
 123
 124     size = WideCharToMultiByte(CP_UTF8, 0, xmlW, -1, NULL, 0, NULL, NULL);
 125     xml = heap_alloc(size);
 126     if (!xml)
 127     {
 128         CloseHandle(hfile);
 129         return E_OUTOFMEMORY;
 130     }
 131     WideCharToMultiByte(CP_UTF8, 0, xmlW, -1, xml, size, NULL, NULL);
 132
 133     if (!WriteFile(hfile, bom_utf8, sizeof(bom_utf8), &size, NULL))
 134     {
 135         hr = HRESULT_FROM_WIN32(GetLastError());
 136         goto failed;
 137     }
 138     if (!WriteFile(hfile, comment, strlen(comment), &size, NULL))
 139     {
 140         hr = HRESULT_FROM_WIN32(GetLastError());
 141         goto failed;
 142     }
 143
 144     /* skip XML declaration with UTF-16 specifier */
 145     if (!memcmp(xml, "<?xml", 5))
 146     {
 147         const char *p = strchr(xml, '>');
 148         if (p++) while (isspace(*p)) p++;
 149         else p = xml;
 150         if (!WriteFile(hfile, p, strlen(p), &size, NULL))
 151             hr = HRESULT_FROM_WIN32(GetLastError());
 152     }
 153     else
 154     {
 155         if (!WriteFile(hfile, xml, strlen(xml), &size, NULL))
 156             hr = HRESULT_FROM_WIN32(GetLastError());
 157     }
 158
 159 failed:
 160     heap_free(xml);
 161     CloseHandle(hfile);
 162     return hr;
 163 }
 164
 165 HRESULT __cdecl SchRpcRegisterTask(const WCHAR *path, const WCHAR *xml, DWORD flags, const WCHAR *sddl,
 166                                    DWORD task_logon_type, DWORD n_creds, const TASK_USER_CRED *creds,
 167                                    WCHAR **actual_path, TASK_XML_ERROR_INFO **xml_error_info)
 168 {
 169     WCHAR *full_name, *relative_path;
 170     DWORD disposition;
 171     HRESULT hr;
 172
 173     TRACE("%s,%s,%#x,%s,%u,%u,%p,%p,%p\n", debugstr_w(path), debugstr_w(xml), flags,
 174           debugstr_w(sddl), task_logon_type, n_creds, creds, actual_path, xml_error_info);
 175
 176     *actual_path = NULL;
 177     *xml_error_info = NULL;
 178
 179     /* FIXME: assume that validation is performed on the client side */
 180     if (flags & TASK_VALIDATE_ONLY) return S_OK;
 181
 182     if (path)
 183     {
 184         full_name = get_full_name(path, &relative_path);
 185         if (!full_name) return E_OUTOFMEMORY;
 186
 187         if (strchrW(path, '\\') || strchrW(path, '/'))
 188         {
 189             WCHAR *p = strrchrW(full_name, '/');
 190             if (!p) p = strrchrW(full_name, '\\');
 191             *p = 0;
 192             hr = create_directory(full_name);
 193             if (hr != S_OK && hr != HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS))
 194             {
 195                 heap_free(full_name);
 196                 return hr;
 197             }
 198             *p = '\\';
 199         }
 200     }
 201     else
 202     {
 203         IID iid;
 204         WCHAR uuid_str[39];
 205
 206         UuidCreate(&iid);
 207         StringFromGUID2(&iid, uuid_str, 39);
 208
 209         full_name = get_full_name(uuid_str, &relative_path);
 210         if (!full_name) return E_OUTOFMEMORY;
 211         /* skip leading '\' */
 212         relative_path++;
 213     }
 214
 215     switch (flags & (TASK_CREATE | TASK_UPDATE))
 216     {
 217     default:
 218     case TASK_CREATE:
 219         disposition = CREATE_NEW;
 220         break;
 221
 222     case TASK_UPDATE:
 223         disposition = OPEN_EXISTING;
 224         break;
 225
 226     case (TASK_CREATE | TASK_UPDATE):
 227         disposition = OPEN_ALWAYS;
 228         break;
 229     }
 230
 231     hr = write_xml_utf8(full_name, disposition, xml);
 232     if (hr == S_OK)
 233     {
 234         *actual_path = heap_strdupW(relative_path);
 235         schedsvc_auto_start();
 236     }
 237
 238     heap_free(full_name);
 239     return hr;
 240 }
 241
 242 static int detect_encoding(const void *buffer, DWORD size)
 243 {
 244     if (size >= sizeof(bom_utf8) && !memcmp(buffer, bom_utf8, sizeof(bom_utf8)))
 245         return CP_UTF8;
 246     else
 247     {
 248         int flags = IS_TEXT_UNICODE_SIGNATURE |
 249                     IS_TEXT_UNICODE_REVERSE_SIGNATURE |
 250                     IS_TEXT_UNICODE_ODD_LENGTH;
 251         IsTextUnicode(buffer, size, &flags);
 252         if (flags & IS_TEXT_UNICODE_SIGNATURE)
 253             return -1;
 254         if (flags & IS_TEXT_UNICODE_REVERSE_SIGNATURE)
 255             return -2;
 256         return CP_ACP;
 257     }
 258 }
 259
 260 static HRESULT read_xml(const WCHAR *name, WCHAR **xml)
 261 {
 262     char *src, *buff;
 263     HANDLE hfile;
 264     DWORD size, attrs;
 265     HRESULT hr = S_OK;
 266     int cp;
 267
 268     attrs = GetFileAttributesW(name);
 269     if (attrs == INVALID_FILE_ATTRIBUTES)
 270         return HRESULT_FROM_WIN32(GetLastError());
 271     if (attrs & FILE_ATTRIBUTE_DIRECTORY)
 272         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
 273
 274     hfile = CreateFileW(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 275     if (hfile == INVALID_HANDLE_VALUE)
 276         return HRESULT_FROM_WIN32(GetLastError());
 277
 278     size = GetFileSize(hfile, NULL);
 279     buff = src = heap_alloc(size + 2);
 280     if (!src)
 281     {
 282         CloseHandle(hfile);
 283         return E_OUTOFMEMORY;
 284     }
 285
 286     src[size] = 0;
 287     src[size + 1] = 0;
 288
 289     ReadFile(hfile, src, size, &size, NULL);
 290     CloseHandle(hfile);
 291
 292     cp = detect_encoding(src, size);
 293     if (cp < 0)
 294     {
 295         *xml = (WCHAR *)src;
 296         return S_OK;
 297     }
 298
 299     if (cp == CP_UTF8 && size >= sizeof(bom_utf8) && !memcmp(src, bom_utf8, sizeof(bom_utf8)))
 300         src += sizeof(bom_utf8);
 301
 302     size = MultiByteToWideChar(cp, 0, src, -1, NULL, 0);
 303     *xml = heap_alloc(size * sizeof(WCHAR));
 304     if (*xml)
 305         MultiByteToWideChar(cp, 0, src, -1, *xml, size);
 306     else
 307         hr = E_OUTOFMEMORY;
 308     heap_free(buff);
 309
 310     return hr;
 311 }
 312
 313 HRESULT __cdecl SchRpcRetrieveTask(const WCHAR *path, const WCHAR *languages, ULONG *n_languages, WCHAR **xml)
 314 {
 315     WCHAR *full_name;
 316     HRESULT hr;
 317
 318     TRACE("%s,%s,%p,%p\n", debugstr_w(path), debugstr_w(languages), n_languages, xml);
 319
 320     full_name = get_full_name(path, NULL);
 321     if (!full_name) return E_OUTOFMEMORY;
 322
 323     hr = read_xml(full_name, xml);
 324     if (hr != S_OK) *xml = NULL;
 325
 326     heap_free(full_name);
 327     return hr;
 328 }
 329
 330 HRESULT __cdecl SchRpcCreateFolder(const WCHAR *path, const WCHAR *sddl, DWORD flags)
 331 {
 332     WCHAR *full_name;
 333     HRESULT hr;
 334
 335     TRACE("%s,%s,%#x\n", debugstr_w(path), debugstr_w(sddl), flags);
 336
 337     if (flags) return E_INVALIDARG;
 338
 339     full_name = get_full_name(path, NULL);
 340     if (!full_name) return E_OUTOFMEMORY;
 341
 342     hr = create_directory(full_name);
 343
 344     heap_free(full_name);
 345     return hr;
 346 }
 347
 348 HRESULT __cdecl SchRpcSetSecurity(const WCHAR *path, const WCHAR *sddl, DWORD flags)
 349 {
 350     FIXME("%s,%s,%#x: stub\n", debugstr_w(path), debugstr_w(sddl), flags);
 351     return E_NOTIMPL;
 352 }
 353
 354 HRESULT __cdecl SchRpcGetSecurity(const WCHAR *path, DWORD flags, WCHAR **sddl)
 355 {
 356     FIXME("%s,%#x,%p: stub\n", debugstr_w(path), flags, sddl);
 357     return E_NOTIMPL;
 358 }
 359
 360 static void free_list(TASK_NAMES list, LONG count)
 361 {
 362     LONG i;
 363
 364     for (i = 0; i < count; i++)
 365         heap_free(list[i]);
 366
 367     heap_free(list);
 368 }
 369
 370 static inline BOOL is_directory(const WIN32_FIND_DATAW *data)
 371 {
 372     if (data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 373     {
 374         if (data->cFileName[0] == '.')
 375         {
 376             if (!data->cFileName[1] || (data->cFileName[1] == '.' && !data->cFileName[2]))
 377                 return FALSE;
 378         }
 379         return TRUE;
 380     }
 381     return FALSE;
 382 }
 383
 384 static inline BOOL is_file(const WIN32_FIND_DATAW *data)
 385 {
 386     return !(data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
 387 }
 388
 389 HRESULT __cdecl SchRpcEnumFolders(const WCHAR *path, DWORD flags, DWORD *start_index, DWORD n_requested,
 390                                   DWORD *n_names, TASK_NAMES *names)
 391 {
 392     static const WCHAR allW[] = {'\\','*',0};
 393     HRESULT hr = S_OK;
 394     WCHAR *full_name;
 395     WCHAR pathW[MAX_PATH];
 396     WIN32_FIND_DATAW data;
 397     HANDLE handle;
 398     DWORD allocated, count, index;
 399     TASK_NAMES list;
 400
 401     TRACE("%s,%#x,%u,%u,%p,%p\n", debugstr_w(path), flags, *start_index, n_requested, n_names, names);
 402
 403     *n_names = 0;
 404     *names = NULL;
 405
 406     if (flags & ~TASK_ENUM_HIDDEN) return E_INVALIDARG;
 407
 408     if (!n_requested) n_requested = ~0u;
 409
 410     full_name = get_full_name(path, NULL);
 411     if (!full_name) return E_OUTOFMEMORY;
 412
 413     if (strlenW(full_name) + 2 > MAX_PATH)
 414     {
 415         heap_free(full_name);
 416         return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
 417     }
 418
 419     strcpyW(pathW, full_name);
 420     strcatW(pathW, allW);
 421
 422     heap_free(full_name);
 423
 424     allocated = 64;
 425     list = heap_alloc(allocated * sizeof(list[0]));
 426     if (!list) return E_OUTOFMEMORY;
 427
 428     index = count = 0;
 429
 430     handle = FindFirstFileW(pathW, &data);
 431     if (handle == INVALID_HANDLE_VALUE)
 432     {
 433         heap_free(list);
 434         if (GetLastError() == ERROR_PATH_NOT_FOUND)
 435             return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 436         return HRESULT_FROM_WIN32(GetLastError());
 437     }
 438
 439     do
 440     {
 441         if (is_directory(&data) && index++ >= *start_index)
 442         {
 443             if (count >= allocated)
 444             {
 445                 TASK_NAMES new_list;
 446                 allocated *= 2;
 447                 new_list = heap_realloc(list, allocated * sizeof(list[0]));
 448                 if (!new_list)
 449                 {
 450                     hr = E_OUTOFMEMORY;
 451                     break;
 452                 }
 453                 list = new_list;
 454             }
 455
 456             TRACE("adding %s\n", debugstr_w(data.cFileName));
 457
 458             list[count] = heap_strdupW(data.cFileName);
 459             if (!list[count])
 460             {
 461                 hr = E_OUTOFMEMORY;
 462                 break;
 463             }
 464
 465             count++;
 466
 467             if (count >= n_requested)
 468             {
 469                 hr = S_FALSE;
 470                 break;
 471             }
 472         }
 473     } while (FindNextFileW(handle, &data));
 474
 475     FindClose(handle);
 476
 477     if (FAILED(hr))
 478     {
 479         free_list(list, count);
 480         return hr;
 481     }
 482
 483     *n_names = count;
 484
 485     if (count)
 486     {
 487         *names = list;
 488         *start_index = index;
 489         return hr;
 490     }
 491
 492     heap_free(list);
 493     *names = NULL;
 494     return *start_index ? S_FALSE : S_OK;
 495 }
 496
 497 HRESULT __cdecl SchRpcEnumTasks(const WCHAR *path, DWORD flags, DWORD *start_index, DWORD n_requested,
 498                                 DWORD *n_names, TASK_NAMES *names)
 499 {
 500     static const WCHAR allW[] = {'\\','*',0};
 501     HRESULT hr = S_OK;
 502     WCHAR *full_name;
 503     WCHAR pathW[MAX_PATH];
 504     WIN32_FIND_DATAW data;
 505     HANDLE handle;
 506     DWORD allocated, count, index;
 507     TASK_NAMES list;
 508
 509     TRACE("%s,%#x,%u,%u,%p,%p\n", debugstr_w(path), flags, *start_index, n_requested, n_names, names);
 510
 511     *n_names = 0;
 512     *names = NULL;
 513
 514     if (flags & ~TASK_ENUM_HIDDEN) return E_INVALIDARG;
 515
 516     if (!n_requested) n_requested = ~0u;
 517
 518     full_name = get_full_name(path, NULL);
 519     if (!full_name) return E_OUTOFMEMORY;
 520
 521     if (strlenW(full_name) + 2 > MAX_PATH)
 522     {
 523         heap_free(full_name);
 524         return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
 525     }
 526
 527     strcpyW(pathW, full_name);
 528     strcatW(pathW, allW);
 529
 530     heap_free(full_name);
 531
 532     allocated = 64;
 533     list = heap_alloc(allocated * sizeof(list[0]));
 534     if (!list) return E_OUTOFMEMORY;
 535
 536     index = count = 0;
 537
 538     handle = FindFirstFileW(pathW, &data);
 539     if (handle == INVALID_HANDLE_VALUE)
 540     {
 541         heap_free(list);
 542         if (GetLastError() == ERROR_PATH_NOT_FOUND)
 543             return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 544         return HRESULT_FROM_WIN32(GetLastError());
 545     }
 546
 547     do
 548     {
 549         if (is_file(&data) && index++ >= *start_index)
 550         {
 551             if (count >= allocated)
 552             {
 553                 TASK_NAMES new_list;
 554                 allocated *= 2;
 555                 new_list = heap_realloc(list, allocated * sizeof(list[0]));
 556                 if (!new_list)
 557                 {
 558                     hr = E_OUTOFMEMORY;
 559                     break;
 560                 }
 561                 list = new_list;
 562             }
 563
 564             TRACE("adding %s\n", debugstr_w(data.cFileName));
 565
 566             list[count] = heap_strdupW(data.cFileName);
 567             if (!list[count])
 568             {
 569                 hr = E_OUTOFMEMORY;
 570                 break;
 571             }
 572
 573             count++;
 574
 575             if (count >= n_requested)
 576             {
 577                 hr = S_FALSE;
 578                 break;
 579             }
 580         }
 581     } while (FindNextFileW(handle, &data));
 582
 583     FindClose(handle);
 584
 585     if (FAILED(hr))
 586     {
 587         free_list(list, count);
 588         return hr;
 589     }
 590
 591     *n_names = count;
 592
 593     if (count)
 594     {
 595         *names = list;
 596         *start_index = index;
 597         return hr;
 598     }
 599
 600     heap_free(list);
 601     *names = NULL;
 602     return *start_index ? S_FALSE : S_OK;
 603 }
 604
 605 HRESULT __cdecl SchRpcEnumInstances(const WCHAR *path, DWORD flags, DWORD *n_guids, GUID **guids)
 606 {
 607     FIXME("%s,%#x,%p,%p: stub\n", debugstr_w(path), flags, n_guids, guids);
 608     return E_NOTIMPL;
 609 }
 610
 611 HRESULT __cdecl SchRpcGetInstanceInfo(GUID guid, WCHAR **path, DWORD *task_state, WCHAR **action,
 612                                       WCHAR **info, DWORD *n_instances, GUID **instances, DWORD *pid)
 613 {
 614     FIXME("%s,%p,%p,%p,%p,%p,%p,%p: stub\n", wine_dbgstr_guid(&guid), path, task_state, action,
 615           info, n_instances, instances, pid);
 616     return E_NOTIMPL;
 617 }
 618
 619 HRESULT __cdecl SchRpcStopInstance(GUID guid, DWORD flags)
 620 {
 621     FIXME("%s,%#x: stub\n", wine_dbgstr_guid(&guid), flags);
 622     return E_NOTIMPL;
 623 }
 624
 625 HRESULT __cdecl SchRpcStop(const WCHAR *path, DWORD flags)
 626 {
 627     FIXME("%s,%#x: stub\n", debugstr_w(path), flags);
 628     return E_NOTIMPL;
 629 }
 630
 631 HRESULT __cdecl SchRpcRun(const WCHAR *path, DWORD n_args, const WCHAR **args, DWORD flags,
 632                           DWORD session_id, const WCHAR *user, GUID *guid)
 633 {
 634     FIXME("%s,%u,%p,%#x,%#x,%s,%p: stub\n", debugstr_w(path), n_args, args, flags,
 635           session_id, debugstr_w(user), guid);
 636     return E_NOTIMPL;
 637 }
 638
 639 HRESULT __cdecl SchRpcDelete(const WCHAR *path, DWORD flags)
 640 {
 641     WCHAR *full_name;
 642     HRESULT hr = S_OK;
 643
 644     TRACE("%s,%#x\n", debugstr_w(path), flags);
 645
 646     if (flags) return E_INVALIDARG;
 647
 648     while (*path == '\\' || *path == '/') path++;
 649     if (!*path) return E_ACCESSDENIED;
 650
 651     full_name = get_full_name(path, NULL);
 652     if (!full_name) return E_OUTOFMEMORY;
 653
 654     if (!RemoveDirectoryW(full_name))
 655     {
 656         hr = HRESULT_FROM_WIN32(GetLastError());
 657         if (hr == HRESULT_FROM_WIN32(ERROR_DIRECTORY))
 658             hr = DeleteFileW(full_name) ? S_OK : HRESULT_FROM_WIN32(GetLastError());
 659     }
 660
 661     heap_free(full_name);
 662     return hr;
 663 }
 664
 665 HRESULT __cdecl SchRpcRename(const WCHAR *path, const WCHAR *name, DWORD flags)
 666 {
 667     FIXME("%s,%s,%#x: stub\n", debugstr_w(path), debugstr_w(name), flags);
 668     return E_NOTIMPL;
 669 }
 670
 671 HRESULT __cdecl SchRpcScheduledRuntimes(const WCHAR *path, SYSTEMTIME *start, SYSTEMTIME *end, DWORD flags,
 672                                         DWORD n_requested, DWORD *n_runtimes, SYSTEMTIME **runtimes)
 673 {
 674     FIXME("%s,%p,%p,%#x,%u,%p,%p: stub\n", debugstr_w(path), start, end, flags,
 675           n_requested, n_runtimes, runtimes);
 676     return E_NOTIMPL;
 677 }
 678
 679 HRESULT __cdecl SchRpcGetLastRunInfo(const WCHAR *path, SYSTEMTIME *last_runtime, DWORD *last_return_code)
 680 {
 681     FIXME("%s,%p,%p: stub\n", debugstr_w(path), last_runtime, last_return_code);
 682     return E_NOTIMPL;
 683 }
 684
 685 HRESULT __cdecl SchRpcGetTaskInfo(const WCHAR *path, DWORD flags, DWORD *enabled, DWORD *task_state)
 686 {
 687     WCHAR *full_name, *xml;
 688     HRESULT hr;
 689
 690     FIXME("%s,%#x,%p,%p: stub\n", debugstr_w(path), flags, enabled, task_state);
 691
 692     full_name = get_full_name(path, NULL);
 693     if (!full_name) return E_OUTOFMEMORY;
 694
 695     hr = read_xml(full_name, &xml);
 696     heap_free(full_name);
 697     if (hr != S_OK) return hr;
 698     heap_free(xml);
 699
 700     *enabled = 0;
 701     *task_state = (flags & SCH_FLAG_STATE) ? TASK_STATE_DISABLED : TASK_STATE_UNKNOWN;
 702     return S_OK;
 703 }
 704
 705 HRESULT __cdecl SchRpcGetNumberOfMissedRuns(const WCHAR *path, DWORD *runs)
 706 {
 707     FIXME("%s,%p: stub\n", debugstr_w(path), runs);
 708     return E_NOTIMPL;
 709 }
 710
 711 HRESULT __cdecl SchRpcEnableTask(const WCHAR *path, DWORD enabled)
 712 {
 713     FIXME("%s,%u: stub\n", debugstr_w(path), enabled);
 714     return E_NOTIMPL;
 715 }