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     HANDLE hfile;
 263     DWORD size, attrs;
 264     char *src;
 265     int cp;
 266
 267     attrs = GetFileAttributesW(name);
 268     if (attrs == INVALID_FILE_ATTRIBUTES)
 269         return HRESULT_FROM_WIN32(GetLastError());
 270     if (attrs & FILE_ATTRIBUTE_DIRECTORY)
 271         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
 272
 273     hfile = CreateFileW(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 274     if (hfile == INVALID_HANDLE_VALUE)
 275         return HRESULT_FROM_WIN32(GetLastError());
 276
 277     size = GetFileSize(hfile, NULL);
 278     src = heap_alloc(size + 2);
 279     if (!src)
 280     {
 281         CloseHandle(hfile);
 282         return E_OUTOFMEMORY;
 283     }
 284
 285     src[size] = 0;
 286     src[size + 1] = 0;
 287
 288     ReadFile(hfile, src, size, &size, NULL);
 289     CloseHandle(hfile);
 290
 291     cp = detect_encoding(src, size);
 292     if (cp < 0)
 293     {
 294         *xml = (WCHAR *)src;
 295         return S_OK;
 296     }
 297
 298     if (cp == CP_UTF8 && size >= sizeof(bom_utf8) && !memcmp(src, bom_utf8, sizeof(bom_utf8)))
 299         src += sizeof(bom_utf8);
 300
 301     size = MultiByteToWideChar(cp, 0, src, -1, NULL, 0);
 302     *xml = heap_alloc(size * sizeof(WCHAR));
 303     if (!*xml) return E_OUTOFMEMORY;
 304     MultiByteToWideChar(cp, 0, src, -1, *xml, size);
 305     return S_OK;
 306 }
 307
 308 HRESULT __cdecl SchRpcRetrieveTask(const WCHAR *path, const WCHAR *languages, ULONG *n_languages, WCHAR **xml)
 309 {
 310     WCHAR *full_name;
 311     HRESULT hr;
 312
 313     TRACE("%s,%s,%p,%p\n", debugstr_w(path), debugstr_w(languages), n_languages, xml);
 314
 315     full_name = get_full_name(path, NULL);
 316     if (!full_name) return E_OUTOFMEMORY;
 317
 318     hr = read_xml(full_name, xml);
 319     if (hr != S_OK) *xml = NULL;
 320
 321     heap_free(full_name);
 322     return hr;
 323 }
 324
 325 HRESULT __cdecl SchRpcCreateFolder(const WCHAR *path, const WCHAR *sddl, DWORD flags)
 326 {
 327     WCHAR *full_name;
 328     HRESULT hr;
 329
 330     TRACE("%s,%s,%#x\n", debugstr_w(path), debugstr_w(sddl), flags);
 331
 332     if (flags) return E_INVALIDARG;
 333
 334     full_name = get_full_name(path, NULL);
 335     if (!full_name) return E_OUTOFMEMORY;
 336
 337     hr = create_directory(full_name);
 338
 339     heap_free(full_name);
 340     return hr;
 341 }
 342
 343 HRESULT __cdecl SchRpcSetSecurity(const WCHAR *path, const WCHAR *sddl, DWORD flags)
 344 {
 345     FIXME("%s,%s,%#x: stub\n", debugstr_w(path), debugstr_w(sddl), flags);
 346     return E_NOTIMPL;
 347 }
 348
 349 HRESULT __cdecl SchRpcGetSecurity(const WCHAR *path, DWORD flags, WCHAR **sddl)
 350 {
 351     FIXME("%s,%#x,%p: stub\n", debugstr_w(path), flags, sddl);
 352     return E_NOTIMPL;
 353 }
 354
 355 static void free_list(TASK_NAMES list, LONG count)
 356 {
 357     LONG i;
 358
 359     for (i = 0; i < count; i++)
 360         heap_free(list[i]);
 361
 362     heap_free(list);
 363 }
 364
 365 static inline BOOL is_directory(const WIN32_FIND_DATAW *data)
 366 {
 367     if (data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 368     {
 369         if (data->cFileName[0] == '.')
 370         {
 371             if (!data->cFileName[1] || (data->cFileName[1] == '.' && !data->cFileName[2]))
 372                 return FALSE;
 373         }
 374         return TRUE;
 375     }
 376     return FALSE;
 377 }
 378
 379 static inline BOOL is_file(const WIN32_FIND_DATAW *data)
 380 {
 381     return !(data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
 382 }
 383
 384 HRESULT __cdecl SchRpcEnumFolders(const WCHAR *path, DWORD flags, DWORD *start_index, DWORD n_requested,
 385                                   DWORD *n_names, TASK_NAMES *names)
 386 {
 387     static const WCHAR allW[] = {'\\','*',0};
 388     HRESULT hr = S_OK;
 389     WCHAR *full_name;
 390     WCHAR pathW[MAX_PATH];
 391     WIN32_FIND_DATAW data;
 392     HANDLE handle;
 393     DWORD allocated, count, index;
 394     TASK_NAMES list;
 395
 396     TRACE("%s,%#x,%u,%u,%p,%p\n", debugstr_w(path), flags, *start_index, n_requested, n_names, names);
 397
 398     *n_names = 0;
 399     *names = NULL;
 400
 401     if (flags & ~TASK_ENUM_HIDDEN) return E_INVALIDARG;
 402
 403     if (!n_requested) n_requested = ~0u;
 404
 405     full_name = get_full_name(path, NULL);
 406     if (!full_name) return E_OUTOFMEMORY;
 407
 408     if (strlenW(full_name) + 2 > MAX_PATH)
 409     {
 410         heap_free(full_name);
 411         return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
 412     }
 413
 414     strcpyW(pathW, full_name);
 415     strcatW(pathW, allW);
 416
 417     heap_free(full_name);
 418
 419     allocated = 64;
 420     list = heap_alloc(allocated * sizeof(list[0]));
 421     if (!list) return E_OUTOFMEMORY;
 422
 423     index = count = 0;
 424
 425     handle = FindFirstFileW(pathW, &data);
 426     if (handle == INVALID_HANDLE_VALUE)
 427     {
 428         heap_free(list);
 429         if (GetLastError() == ERROR_PATH_NOT_FOUND)
 430             return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 431         return HRESULT_FROM_WIN32(GetLastError());
 432     }
 433
 434     do
 435     {
 436         if (is_directory(&data) && index++ >= *start_index)
 437         {
 438             if (count >= allocated)
 439             {
 440                 TASK_NAMES new_list;
 441                 allocated *= 2;
 442                 new_list = heap_realloc(list, allocated * sizeof(list[0]));
 443                 if (!new_list)
 444                 {
 445                     hr = E_OUTOFMEMORY;
 446                     break;
 447                 }
 448                 list = new_list;
 449             }
 450
 451             TRACE("adding %s\n", debugstr_w(data.cFileName));
 452
 453             list[count] = heap_strdupW(data.cFileName);
 454             if (!list[count])
 455             {
 456                 hr = E_OUTOFMEMORY;
 457                 break;
 458             }
 459
 460             count++;
 461
 462             if (count >= n_requested)
 463             {
 464                 hr = S_FALSE;
 465                 break;
 466             }
 467         }
 468     } while (FindNextFileW(handle, &data));
 469
 470     FindClose(handle);
 471
 472     if (FAILED(hr))
 473     {
 474         free_list(list, count);
 475         return hr;
 476     }
 477
 478     *n_names = count;
 479
 480     if (count)
 481     {
 482         *names = list;
 483         *start_index = index;
 484         return hr;
 485     }
 486
 487     heap_free(list);
 488     *names = NULL;
 489     return *start_index ? S_FALSE : S_OK;
 490 }
 491
 492 HRESULT __cdecl SchRpcEnumTasks(const WCHAR *path, DWORD flags, DWORD *start_index, DWORD n_requested,
 493                                 DWORD *n_names, TASK_NAMES *names)
 494 {
 495     static const WCHAR allW[] = {'\\','*',0};
 496     HRESULT hr = S_OK;
 497     WCHAR *full_name;
 498     WCHAR pathW[MAX_PATH];
 499     WIN32_FIND_DATAW data;
 500     HANDLE handle;
 501     DWORD allocated, count, index;
 502     TASK_NAMES list;
 503
 504     TRACE("%s,%#x,%u,%u,%p,%p\n", debugstr_w(path), flags, *start_index, n_requested, n_names, names);
 505
 506     *n_names = 0;
 507     *names = NULL;
 508
 509     if (flags & ~TASK_ENUM_HIDDEN) return E_INVALIDARG;
 510
 511     if (!n_requested) n_requested = ~0u;
 512
 513     full_name = get_full_name(path, NULL);
 514     if (!full_name) return E_OUTOFMEMORY;
 515
 516     if (strlenW(full_name) + 2 > MAX_PATH)
 517     {
 518         heap_free(full_name);
 519         return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
 520     }
 521
 522     strcpyW(pathW, full_name);
 523     strcatW(pathW, allW);
 524
 525     heap_free(full_name);
 526
 527     allocated = 64;
 528     list = heap_alloc(allocated * sizeof(list[0]));
 529     if (!list) return E_OUTOFMEMORY;
 530
 531     index = count = 0;
 532
 533     handle = FindFirstFileW(pathW, &data);
 534     if (handle == INVALID_HANDLE_VALUE)
 535     {
 536         heap_free(list);
 537         if (GetLastError() == ERROR_PATH_NOT_FOUND)
 538             return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 539         return HRESULT_FROM_WIN32(GetLastError());
 540     }
 541
 542     do
 543     {
 544         if (is_file(&data) && index++ >= *start_index)
 545         {
 546             if (count >= allocated)
 547             {
 548                 TASK_NAMES new_list;
 549                 allocated *= 2;
 550                 new_list = heap_realloc(list, allocated * sizeof(list[0]));
 551                 if (!new_list)
 552                 {
 553                     hr = E_OUTOFMEMORY;
 554                     break;
 555                 }
 556                 list = new_list;
 557             }
 558
 559             TRACE("adding %s\n", debugstr_w(data.cFileName));
 560
 561             list[count] = heap_strdupW(data.cFileName);
 562             if (!list[count])
 563             {
 564                 hr = E_OUTOFMEMORY;
 565                 break;
 566             }
 567
 568             count++;
 569
 570             if (count >= n_requested)
 571             {
 572                 hr = S_FALSE;
 573                 break;
 574             }
 575         }
 576     } while (FindNextFileW(handle, &data));
 577
 578     FindClose(handle);
 579
 580     if (FAILED(hr))
 581     {
 582         free_list(list, count);
 583         return hr;
 584     }
 585
 586     *n_names = count;
 587
 588     if (count)
 589     {
 590         *names = list;
 591         *start_index = index;
 592         return hr;
 593     }
 594
 595     heap_free(list);
 596     *names = NULL;
 597     return *start_index ? S_FALSE : S_OK;
 598 }
 599
 600 HRESULT __cdecl SchRpcEnumInstances(const WCHAR *path, DWORD flags, DWORD *n_guids, GUID **guids)
 601 {
 602     FIXME("%s,%#x,%p,%p: stub\n", debugstr_w(path), flags, n_guids, guids);
 603     return E_NOTIMPL;
 604 }
 605
 606 HRESULT __cdecl SchRpcGetInstanceInfo(GUID guid, WCHAR **path, DWORD *task_state, WCHAR **action,
 607                                       WCHAR **info, DWORD *n_instances, GUID **instances, DWORD *pid)
 608 {
 609     FIXME("%s,%p,%p,%p,%p,%p,%p,%p: stub\n", wine_dbgstr_guid(&guid), path, task_state, action,
 610           info, n_instances, instances, pid);
 611     return E_NOTIMPL;
 612 }
 613
 614 HRESULT __cdecl SchRpcStopInstance(GUID guid, DWORD flags)
 615 {
 616     FIXME("%s,%#x: stub\n", wine_dbgstr_guid(&guid), flags);
 617     return E_NOTIMPL;
 618 }
 619
 620 HRESULT __cdecl SchRpcStop(const WCHAR *path, DWORD flags)
 621 {
 622     FIXME("%s,%#x: stub\n", debugstr_w(path), flags);
 623     return E_NOTIMPL;
 624 }
 625
 626 HRESULT __cdecl SchRpcRun(const WCHAR *path, DWORD n_args, const WCHAR **args, DWORD flags,
 627                           DWORD session_id, const WCHAR *user, GUID *guid)
 628 {
 629     FIXME("%s,%u,%p,%#x,%#x,%s,%p: stub\n", debugstr_w(path), n_args, args, flags,
 630           session_id, debugstr_w(user), guid);
 631     return E_NOTIMPL;
 632 }
 633
 634 HRESULT __cdecl SchRpcDelete(const WCHAR *path, DWORD flags)
 635 {
 636     WCHAR *full_name;
 637     HRESULT hr = S_OK;
 638
 639     TRACE("%s,%#x\n", debugstr_w(path), flags);
 640
 641     if (flags) return E_INVALIDARG;
 642
 643     while (*path == '\\' || *path == '/') path++;
 644     if (!*path) return E_ACCESSDENIED;
 645
 646     full_name = get_full_name(path, NULL);
 647     if (!full_name) return E_OUTOFMEMORY;
 648
 649     if (!RemoveDirectoryW(full_name))
 650     {
 651         hr = HRESULT_FROM_WIN32(GetLastError());
 652         if (hr == HRESULT_FROM_WIN32(ERROR_DIRECTORY))
 653             hr = DeleteFileW(full_name) ? S_OK : HRESULT_FROM_WIN32(GetLastError());
 654     }
 655
 656     heap_free(full_name);
 657     return hr;
 658 }
 659
 660 HRESULT __cdecl SchRpcRename(const WCHAR *path, const WCHAR *name, DWORD flags)
 661 {
 662     FIXME("%s,%s,%#x: stub\n", debugstr_w(path), debugstr_w(name), flags);
 663     return E_NOTIMPL;
 664 }
 665
 666 HRESULT __cdecl SchRpcScheduledRuntimes(const WCHAR *path, SYSTEMTIME *start, SYSTEMTIME *end, DWORD flags,
 667                                         DWORD n_requested, DWORD *n_runtimes, SYSTEMTIME **runtimes)
 668 {
 669     FIXME("%s,%p,%p,%#x,%u,%p,%p: stub\n", debugstr_w(path), start, end, flags,
 670           n_requested, n_runtimes, runtimes);
 671     return E_NOTIMPL;
 672 }
 673
 674 HRESULT __cdecl SchRpcGetLastRunInfo(const WCHAR *path, SYSTEMTIME *last_runtime, DWORD *last_return_code)
 675 {
 676     FIXME("%s,%p,%p: stub\n", debugstr_w(path), last_runtime, last_return_code);
 677     return E_NOTIMPL;
 678 }
 679
 680 HRESULT __cdecl SchRpcGetTaskInfo(const WCHAR *path, DWORD flags, DWORD *enabled, DWORD *task_state)
 681 {
 682     WCHAR *full_name, *xml;
 683     HRESULT hr;
 684
 685     FIXME("%s,%#x,%p,%p: stub\n", debugstr_w(path), flags, enabled, task_state);
 686
 687     full_name = get_full_name(path, NULL);
 688     if (!full_name) return E_OUTOFMEMORY;
 689
 690     hr = read_xml(full_name, &xml);
 691     heap_free(full_name);
 692     if (hr != S_OK) return hr;
 693     heap_free(xml);
 694
 695     *enabled = 0;
 696     *task_state = (flags & SCH_FLAG_STATE) ? TASK_STATE_DISABLED : TASK_STATE_UNKNOWN;
 697     return S_OK;
 698 }
 699
 700 HRESULT __cdecl SchRpcGetNumberOfMissedRuns(const WCHAR *path, DWORD *runs)
 701 {
 702     FIXME("%s,%p: stub\n", debugstr_w(path), runs);
 703     return E_NOTIMPL;
 704 }
 705
 706 HRESULT __cdecl SchRpcEnableTask(const WCHAR *path, DWORD enabled)
 707 {
 708     FIXME("%s,%u: stub\n", debugstr_w(path), enabled);
 709     return E_NOTIMPL;
 710 }