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