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 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "initguid.h"
  27 #include "objbase.h"
  28 #include "xmllite.h"
  29 #include "schrpc.h"
  30 #include "taskschd.h"
  31 #include "wine/debug.h"
  32
  33 #include "schedsvc_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(schedsvc);
  36
  37 static const char bom_utf8[] = { 0xef,0xbb,0xbf };
  38
  39 struct task_info
  40 {
  41     BOOL enabled;
  42 };
  43
  44 HRESULT __cdecl SchRpcHighestVersion(DWORD *version)
  45 {
  46     TRACE("%p\n", version);
  47
  48     *version = MAKELONG(3, 1);
  49     return S_OK;
  50 }
  51
  52 static WCHAR *get_full_name(const WCHAR *path, WCHAR **relative_path)
  53 {
  54     static const WCHAR tasksW[] = { '\\','t','a','s','k','s','\\',0 };
  55     WCHAR *target;
  56     int len;
  57
  58     len = GetSystemDirectoryW(NULL, 0);
  59     len += lstrlenW(tasksW) + lstrlenW(path);
  60
  61     target = malloc(len * sizeof(WCHAR));
  62     if (target)
  63     {
  64         GetSystemDirectoryW(target, len);
  65         lstrcatW(target, tasksW);
  66         if (relative_path)
  67             *relative_path = target + lstrlenW(target) - 1;
  68         while (*path == '\\') path++;
  69         lstrcatW(target, path);
  70     }
  71     return target;
  72 }
  73
  74 /*
  75  * Recursively create all directories in the path.
  76  */
  77 static HRESULT create_directory(const WCHAR *path)
  78 {
  79     HRESULT hr = S_OK;
  80     WCHAR *new_path;
  81     int len;
  82
  83     new_path = malloc((lstrlenW(path) + 1) * sizeof(WCHAR));
  84     if (!new_path) return E_OUTOFMEMORY;
  85
  86     lstrcpyW(new_path, path);
  87
  88     len = lstrlenW(new_path);
  89     while (len && new_path[len - 1] == '\\')
  90     {
  91         new_path[len - 1] = 0;
  92         len--;
  93     }
  94
  95     while (!CreateDirectoryW(new_path, NULL))
  96     {
  97         WCHAR *slash;
  98         DWORD last_error = GetLastError();
  99
 100         if (last_error != ERROR_PATH_NOT_FOUND || !(slash = wcsrchr(new_path, '\\')))
 101         {
 102             hr = HRESULT_FROM_WIN32(last_error);
 103             break;
 104         }
 105
 106         len = slash - new_path;
 107         new_path[len] = 0;
 108         hr = create_directory(new_path);
 109         if (hr != S_OK) break;
 110         new_path[len] = '\\';
 111     }
 112
 113     free(new_path);
 114     return hr;
 115 }
 116
 117 static HRESULT write_xml_utf8(const WCHAR *name, DWORD disposition, const WCHAR *xmlW)
 118 {
 119     static const char comment[] = "<!-- Task definition created by Wine -->\n";
 120     HANDLE hfile;
 121     DWORD size;
 122     char *xml;
 123     HRESULT hr = S_OK;
 124
 125     hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, disposition, 0, 0);
 126     if (hfile == INVALID_HANDLE_VALUE)
 127     {
 128         if (GetLastError() == ERROR_FILE_EXISTS)
 129             return HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS);
 130
 131         return HRESULT_FROM_WIN32(GetLastError());
 132     }
 133
 134     size = WideCharToMultiByte(CP_UTF8, 0, xmlW, -1, NULL, 0, NULL, NULL);
 135     xml = malloc(size);
 136     if (!xml)
 137     {
 138         CloseHandle(hfile);
 139         return E_OUTOFMEMORY;
 140     }
 141     WideCharToMultiByte(CP_UTF8, 0, xmlW, -1, xml, size, NULL, NULL);
 142
 143     if (!WriteFile(hfile, bom_utf8, sizeof(bom_utf8), &size, NULL))
 144     {
 145         hr = HRESULT_FROM_WIN32(GetLastError());
 146         goto failed;
 147     }
 148     if (!WriteFile(hfile, comment, strlen(comment), &size, NULL))
 149     {
 150         hr = HRESULT_FROM_WIN32(GetLastError());
 151         goto failed;
 152     }
 153
 154     /* skip XML declaration with UTF-16 specifier */
 155     if (!memcmp(xml, "<?xml", 5))
 156     {
 157         const char *p = strchr(xml, '>');
 158         if (p++) while (isspace(*p)) p++;
 159         else p = xml;
 160         if (!WriteFile(hfile, p, strlen(p), &size, NULL))
 161             hr = HRESULT_FROM_WIN32(GetLastError());
 162     }
 163     else
 164     {
 165         if (!WriteFile(hfile, xml, strlen(xml), &size, NULL))
 166             hr = HRESULT_FROM_WIN32(GetLastError());
 167     }
 168
 169 failed:
 170     free(xml);
 171     CloseHandle(hfile);
 172     return hr;
 173 }
 174
 175 HRESULT __cdecl SchRpcRegisterTask(const WCHAR *path, const WCHAR *xml, DWORD flags, const WCHAR *sddl,
 176                                    DWORD task_logon_type, DWORD n_creds, const TASK_USER_CRED *creds,
 177                                    WCHAR **actual_path, TASK_XML_ERROR_INFO **xml_error_info)
 178 {
 179     WCHAR *full_name, *relative_path;
 180     DWORD disposition;
 181     HRESULT hr;
 182
 183     TRACE("%s,%s,%#lx,%s,%lu,%lu,%p,%p,%p\n", debugstr_w(path), debugstr_w(xml), flags,
 184           debugstr_w(sddl), task_logon_type, n_creds, creds, actual_path, xml_error_info);
 185
 186     *actual_path = NULL;
 187     *xml_error_info = NULL;
 188
 189     /* FIXME: assume that validation is performed on the client side */
 190     if (flags & TASK_VALIDATE_ONLY) return S_OK;
 191
 192     if (path)
 193     {
 194         full_name = get_full_name(path, &relative_path);
 195         if (!full_name) return E_OUTOFMEMORY;
 196
 197         if (wcschr(path, '\\') || wcschr(path, '/'))
 198         {
 199             WCHAR *p = wcsrchr(full_name, '/');
 200             if (!p) p = wcsrchr(full_name, '\\');
 201             *p = 0;
 202             hr = create_directory(full_name);
 203             if (hr != S_OK && hr != HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS))
 204             {
 205                 free(full_name);
 206                 return hr;
 207             }
 208             *p = '\\';
 209         }
 210     }
 211     else
 212     {
 213         IID iid;
 214         WCHAR uuid_str[39];
 215
 216         UuidCreate(&iid);
 217         StringFromGUID2(&iid, uuid_str, 39);
 218
 219         full_name = get_full_name(uuid_str, &relative_path);
 220         if (!full_name) return E_OUTOFMEMORY;
 221         /* skip leading '\' */
 222         relative_path++;
 223     }
 224
 225     switch (flags & (TASK_CREATE | TASK_UPDATE))
 226     {
 227     default:
 228     case TASK_CREATE:
 229         disposition = CREATE_NEW;
 230         break;
 231
 232     case TASK_UPDATE:
 233         disposition = OPEN_EXISTING;
 234         break;
 235
 236     case (TASK_CREATE | TASK_UPDATE):
 237         disposition = OPEN_ALWAYS;
 238         break;
 239     }
 240
 241     hr = write_xml_utf8(full_name, disposition, xml);
 242     if (hr == S_OK)
 243     {
 244         *actual_path = wcsdup(relative_path);
 245         schedsvc_auto_start();
 246     }
 247
 248     free(full_name);
 249     return hr;
 250 }
 251
 252 static int detect_encoding(const void *buffer, DWORD size)
 253 {
 254     if (size >= sizeof(bom_utf8) && !memcmp(buffer, bom_utf8, sizeof(bom_utf8)))
 255         return CP_UTF8;
 256     else
 257     {
 258         int flags = IS_TEXT_UNICODE_SIGNATURE |
 259                     IS_TEXT_UNICODE_REVERSE_SIGNATURE |
 260                     IS_TEXT_UNICODE_ODD_LENGTH;
 261         IsTextUnicode(buffer, size, &flags);
 262         if (flags & IS_TEXT_UNICODE_SIGNATURE)
 263             return -1;
 264         if (flags & IS_TEXT_UNICODE_REVERSE_SIGNATURE)
 265             return -2;
 266         return CP_ACP;
 267     }
 268 }
 269
 270 static HRESULT read_xml(const WCHAR *name, WCHAR **xml)
 271 {
 272     char *src, *buff;
 273     HANDLE hfile;
 274     DWORD size, attrs;
 275     HRESULT hr = S_OK;
 276     int cp;
 277
 278     attrs = GetFileAttributesW(name);
 279     if (attrs == INVALID_FILE_ATTRIBUTES)
 280         return HRESULT_FROM_WIN32(GetLastError());
 281     if (attrs & FILE_ATTRIBUTE_DIRECTORY)
 282         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
 283
 284     hfile = CreateFileW(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 285     if (hfile == INVALID_HANDLE_VALUE)
 286         return HRESULT_FROM_WIN32(GetLastError());
 287
 288     size = GetFileSize(hfile, NULL);
 289     buff = src = malloc(size + 2);
 290     if (!src)
 291     {
 292         CloseHandle(hfile);
 293         return E_OUTOFMEMORY;
 294     }
 295
 296     src[size] = 0;
 297     src[size + 1] = 0;
 298
 299     ReadFile(hfile, src, size, &size, NULL);
 300     CloseHandle(hfile);
 301
 302     cp = detect_encoding(src, size);
 303     if (cp < 0)
 304     {
 305         *xml = (WCHAR *)src;
 306         return S_OK;
 307     }
 308
 309     if (cp == CP_UTF8 && size >= sizeof(bom_utf8) && !memcmp(src, bom_utf8, sizeof(bom_utf8)))
 310         src += sizeof(bom_utf8);
 311
 312     size = MultiByteToWideChar(cp, 0, src, -1, NULL, 0);
 313     *xml = malloc(size * sizeof(WCHAR));
 314     if (*xml)
 315         MultiByteToWideChar(cp, 0, src, -1, *xml, size);
 316     else
 317         hr = E_OUTOFMEMORY;
 318     free(buff);
 319
 320     return hr;
 321 }
 322
 323 static HRESULT read_text_value(IXmlReader *reader, WCHAR **value)
 324 {
 325     HRESULT hr;
 326     XmlNodeType type;
 327
 328     while (IXmlReader_Read(reader, &type) == S_OK)
 329     {
 330         switch (type)
 331         {
 332             case XmlNodeType_Text:
 333                 if (FAILED(hr = IXmlReader_GetValue(reader, (const WCHAR **)value, NULL)))
 334                     return hr;
 335                 TRACE("%s\n", debugstr_w(*value));
 336                 return S_OK;
 337
 338             case XmlNodeType_Whitespace:
 339             case XmlNodeType_Comment:
 340                 break;
 341
 342             default:
 343                 FIXME("unexpected node type %d\n", type);
 344                 return E_FAIL;
 345         }
 346     }
 347
 348     return E_FAIL;
 349 }
 350
 351 static HRESULT read_variantbool_value(IXmlReader *reader, VARIANT_BOOL *vbool)
 352 {
 353     WCHAR *value;
 354     HRESULT hr;
 355
 356     *vbool = VARIANT_FALSE;
 357
 358     if (FAILED(hr = read_text_value(reader, &value)))
 359         return hr;
 360
 361     if (!wcscmp(value, L"true"))
 362     {
 363         *vbool = VARIANT_TRUE;
 364     }
 365     else if (wcscmp(value, L"false"))
 366     {
 367         WARN("unexpected bool value %s\n", debugstr_w(value));
 368         return SCHED_E_INVALIDVALUE;
 369     }
 370
 371     return S_OK;
 372 }
 373
 374 static HRESULT read_task_settings(IXmlReader *reader, struct task_info *info)
 375 {
 376     VARIANT_BOOL bool_val;
 377     const WCHAR *name;
 378     XmlNodeType type;
 379     HRESULT hr;
 380
 381     if (IXmlReader_IsEmptyElement(reader))
 382     {
 383         TRACE("Settings is empty.\n");
 384         return S_OK;
 385     }
 386
 387     while (IXmlReader_Read(reader, &type) == S_OK)
 388     {
 389         switch (type)
 390         {
 391             case XmlNodeType_EndElement:
 392                 hr = IXmlReader_GetLocalName(reader, &name, NULL);
 393                 if (hr != S_OK) return hr;
 394
 395                 TRACE("/%s\n", debugstr_w(name));
 396
 397                 if (!wcscmp(name, L"Settings"))
 398                     return S_OK;
 399
 400                 break;
 401
 402             case XmlNodeType_Element:
 403                 hr = IXmlReader_GetLocalName(reader, &name, NULL);
 404                 if (hr != S_OK) return hr;
 405
 406                 TRACE("Element: %s\n", debugstr_w(name));
 407
 408                 if (!wcscmp(name, L"Enabled"))
 409                 {
 410                     if (FAILED(hr = read_variantbool_value(reader, &bool_val)))
 411                         return hr;
 412                     info->enabled = !!bool_val;
 413                 }
 414                 break;
 415             default:
 416                 break;
 417         }
 418     }
 419
 420     WARN("Settings was not terminated\n");
 421     return SCHED_E_MALFORMEDXML;
 422 }
 423
 424 static HRESULT read_task_info(IXmlReader *reader, struct task_info *info)
 425 {
 426     const WCHAR *name;
 427     XmlNodeType type;
 428     HRESULT hr;
 429
 430     if (IXmlReader_IsEmptyElement(reader))
 431     {
 432         TRACE("Task is empty\n");
 433         return S_OK;
 434     }
 435     while (IXmlReader_Read(reader, &type) == S_OK)
 436     {
 437         switch (type)
 438         {
 439             case XmlNodeType_EndElement:
 440                 if (FAILED(hr = IXmlReader_GetLocalName(reader, &name, NULL)))
 441                     return hr;
 442
 443                 if (!wcscmp(name, L"Task"))
 444                     return S_OK;
 445                 break;
 446
 447             case XmlNodeType_Element:
 448                 if (FAILED(hr = IXmlReader_GetLocalName(reader, &name, NULL)))
 449                     return hr;
 450
 451                 TRACE("Element: %s\n", debugstr_w(name));
 452
 453                 if (!wcscmp(name, L"Settings"))
 454                 {
 455                     if (FAILED(hr = read_task_settings(reader, info)))
 456                         return hr;
 457                 }
 458                 break;
 459
 460             default:
 461                 break;
 462         }
 463     }
 464
 465     WARN("Task was not terminated\n");
 466     return SCHED_E_MALFORMEDXML;
 467
 468 }
 469
 470 static HRESULT read_task_info_from_xml(const WCHAR *xml, struct task_info *info)
 471 {
 472     IXmlReader *reader;
 473     const WCHAR *name;
 474     XmlNodeType type;
 475     IStream *stream;
 476     HGLOBAL hmem;
 477     HRESULT hr;
 478     void *buf;
 479
 480     memset(info, 0, sizeof(*info));
 481
 482     if (!(hmem = GlobalAlloc(0, wcslen(xml) * sizeof(WCHAR))))
 483         return E_OUTOFMEMORY;
 484
 485     buf = GlobalLock(hmem);
 486     memcpy(buf, xml, lstrlenW(xml) * sizeof(WCHAR));
 487     GlobalUnlock(hmem);
 488
 489     if (FAILED(hr = CreateStreamOnHGlobal(hmem, TRUE, &stream)))
 490     {
 491         GlobalFree(hmem);
 492         return hr;
 493     }
 494
 495     if (FAILED(hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL)))
 496     {
 497         IStream_Release(stream);
 498         return hr;
 499     }
 500
 501     if (FAILED(hr = IXmlReader_SetInput(reader, (IUnknown *)stream)))
 502         goto done;
 503
 504     while (IXmlReader_Read(reader, &type) == S_OK)
 505     {
 506         if (type != XmlNodeType_Element) continue;
 507         if (FAILED(hr = IXmlReader_GetLocalName(reader, &name, NULL)))
 508             goto done;
 509
 510         TRACE("Element: %s\n", debugstr_w(name));
 511         if (wcscmp(name, L"Task"))
 512             continue;
 513
 514         hr = read_task_info(reader, info);
 515         break;
 516     }
 517
 518 done:
 519     IXmlReader_Release(reader);
 520     IStream_Release(stream);
 521     if (FAILED(hr))
 522     {
 523         WARN("Failed parsing xml, hr %#lx.\n", hr);
 524         return SCHED_E_MALFORMEDXML;
 525     }
 526     return S_OK;
 527 }
 528
 529 HRESULT __cdecl SchRpcRetrieveTask(const WCHAR *path, const WCHAR *languages, ULONG *n_languages, WCHAR **xml)
 530 {
 531     WCHAR *full_name;
 532     HRESULT hr;
 533
 534     TRACE("%s,%s,%p,%p\n", debugstr_w(path), debugstr_w(languages), n_languages, xml);
 535
 536     full_name = get_full_name(path, NULL);
 537     if (!full_name) return E_OUTOFMEMORY;
 538
 539     hr = read_xml(full_name, xml);
 540     if (hr != S_OK) *xml = NULL;
 541
 542     free(full_name);
 543     return hr;
 544 }
 545
 546 HRESULT __cdecl SchRpcCreateFolder(const WCHAR *path, const WCHAR *sddl, DWORD flags)
 547 {
 548     WCHAR *full_name;
 549     HRESULT hr;
 550
 551     TRACE("%s,%s,%#lx\n", debugstr_w(path), debugstr_w(sddl), flags);
 552
 553     if (flags) return E_INVALIDARG;
 554
 555     full_name = get_full_name(path, NULL);
 556     if (!full_name) return E_OUTOFMEMORY;
 557
 558     hr = create_directory(full_name);
 559
 560     free(full_name);
 561     return hr;
 562 }
 563
 564 HRESULT __cdecl SchRpcSetSecurity(const WCHAR *path, const WCHAR *sddl, DWORD flags)
 565 {
 566     FIXME("%s,%s,%#lx: stub\n", debugstr_w(path), debugstr_w(sddl), flags);
 567     return E_NOTIMPL;
 568 }
 569
 570 HRESULT __cdecl SchRpcGetSecurity(const WCHAR *path, DWORD flags, WCHAR **sddl)
 571 {
 572     FIXME("%s,%#lx,%p: stub\n", debugstr_w(path), flags, sddl);
 573     return E_NOTIMPL;
 574 }
 575
 576 static void free_list(TASK_NAMES list, LONG count)
 577 {
 578     LONG i;
 579
 580     for (i = 0; i < count; i++)
 581         free(list[i]);
 582
 583     free(list);
 584 }
 585
 586 static inline BOOL is_directory(const WIN32_FIND_DATAW *data)
 587 {
 588     if (data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 589     {
 590         if (data->cFileName[0] == '.')
 591         {
 592             if (!data->cFileName[1] || (data->cFileName[1] == '.' && !data->cFileName[2]))
 593                 return FALSE;
 594         }
 595         return TRUE;
 596     }
 597     return FALSE;
 598 }
 599
 600 static inline BOOL is_file(const WIN32_FIND_DATAW *data)
 601 {
 602     return !(data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
 603 }
 604
 605 HRESULT __cdecl SchRpcEnumFolders(const WCHAR *path, DWORD flags, DWORD *start_index, DWORD n_requested,
 606                                   DWORD *n_names, TASK_NAMES *names)
 607 {
 608     static const WCHAR allW[] = {'\\','*',0};
 609     HRESULT hr = S_OK;
 610     WCHAR *full_name;
 611     WCHAR pathW[MAX_PATH];
 612     WIN32_FIND_DATAW data;
 613     HANDLE handle;
 614     DWORD allocated, count, index;
 615     TASK_NAMES list;
 616
 617     TRACE("%s,%#lx,%lu,%lu,%p,%p\n", debugstr_w(path), flags, *start_index, n_requested, n_names, names);
 618
 619     *n_names = 0;
 620     *names = NULL;
 621
 622     if (flags & ~TASK_ENUM_HIDDEN) return E_INVALIDARG;
 623
 624     if (!n_requested) n_requested = ~0u;
 625
 626     full_name = get_full_name(path, NULL);
 627     if (!full_name) return E_OUTOFMEMORY;
 628
 629     if (lstrlenW(full_name) + 2 > MAX_PATH)
 630     {
 631         free(full_name);
 632         return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
 633     }
 634
 635     lstrcpyW(pathW, full_name);
 636     lstrcatW(pathW, allW);
 637
 638     free(full_name);
 639
 640     allocated = 64;
 641     list = malloc(allocated * sizeof(list[0]));
 642     if (!list) return E_OUTOFMEMORY;
 643
 644     index = count = 0;
 645
 646     handle = FindFirstFileW(pathW, &data);
 647     if (handle == INVALID_HANDLE_VALUE)
 648     {
 649         free(list);
 650         if (GetLastError() == ERROR_PATH_NOT_FOUND)
 651             return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 652         return HRESULT_FROM_WIN32(GetLastError());
 653     }
 654
 655     do
 656     {
 657         if (is_directory(&data) && index++ >= *start_index)
 658         {
 659             if (count >= allocated)
 660             {
 661                 TASK_NAMES new_list;
 662                 allocated *= 2;
 663                 new_list = realloc(list, allocated * sizeof(list[0]));
 664                 if (!new_list)
 665                 {
 666                     hr = E_OUTOFMEMORY;
 667                     break;
 668                 }
 669                 list = new_list;
 670             }
 671
 672             TRACE("adding %s\n", debugstr_w(data.cFileName));
 673
 674             list[count] = wcsdup(data.cFileName);
 675             if (!list[count])
 676             {
 677                 hr = E_OUTOFMEMORY;
 678                 break;
 679             }
 680
 681             count++;
 682
 683             if (count >= n_requested)
 684             {
 685                 hr = S_FALSE;
 686                 break;
 687             }
 688         }
 689     } while (FindNextFileW(handle, &data));
 690
 691     FindClose(handle);
 692
 693     if (FAILED(hr))
 694     {
 695         free_list(list, count);
 696         return hr;
 697     }
 698
 699     *n_names = count;
 700
 701     if (count)
 702     {
 703         *names = list;
 704         *start_index = index;
 705         return hr;
 706     }
 707
 708     free(list);
 709     *names = NULL;
 710     return *start_index ? S_FALSE : S_OK;
 711 }
 712
 713 HRESULT __cdecl SchRpcEnumTasks(const WCHAR *path, DWORD flags, DWORD *start_index, DWORD n_requested,
 714                                 DWORD *n_names, TASK_NAMES *names)
 715 {
 716     static const WCHAR allW[] = {'\\','*',0};
 717     HRESULT hr = S_OK;
 718     WCHAR *full_name;
 719     WCHAR pathW[MAX_PATH];
 720     WIN32_FIND_DATAW data;
 721     HANDLE handle;
 722     DWORD allocated, count, index;
 723     TASK_NAMES list;
 724
 725     TRACE("%s,%#lx,%lu,%lu,%p,%p\n", debugstr_w(path), flags, *start_index, n_requested, n_names, names);
 726
 727     *n_names = 0;
 728     *names = NULL;
 729
 730     if (flags & ~TASK_ENUM_HIDDEN) return E_INVALIDARG;
 731
 732     if (!n_requested) n_requested = ~0u;
 733
 734     full_name = get_full_name(path, NULL);
 735     if (!full_name) return E_OUTOFMEMORY;
 736
 737     if (lstrlenW(full_name) + 2 > MAX_PATH)
 738     {
 739         free(full_name);
 740         return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
 741     }
 742
 743     lstrcpyW(pathW, full_name);
 744     lstrcatW(pathW, allW);
 745
 746     free(full_name);
 747
 748     allocated = 64;
 749     list = malloc(allocated * sizeof(list[0]));
 750     if (!list) return E_OUTOFMEMORY;
 751
 752     index = count = 0;
 753
 754     handle = FindFirstFileW(pathW, &data);
 755     if (handle == INVALID_HANDLE_VALUE)
 756     {
 757         free(list);
 758         if (GetLastError() == ERROR_PATH_NOT_FOUND)
 759             return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 760         return HRESULT_FROM_WIN32(GetLastError());
 761     }
 762
 763     do
 764     {
 765         if (is_file(&data) && index++ >= *start_index)
 766         {
 767             if (count >= allocated)
 768             {
 769                 TASK_NAMES new_list;
 770                 allocated *= 2;
 771                 new_list = realloc(list, allocated * sizeof(list[0]));
 772                 if (!new_list)
 773                 {
 774                     hr = E_OUTOFMEMORY;
 775                     break;
 776                 }
 777                 list = new_list;
 778             }
 779
 780             TRACE("adding %s\n", debugstr_w(data.cFileName));
 781
 782             list[count] = wcsdup(data.cFileName);
 783             if (!list[count])
 784             {
 785                 hr = E_OUTOFMEMORY;
 786                 break;
 787             }
 788
 789             count++;
 790
 791             if (count >= n_requested)
 792             {
 793                 hr = S_FALSE;
 794                 break;
 795             }
 796         }
 797     } while (FindNextFileW(handle, &data));
 798
 799     FindClose(handle);
 800
 801     if (FAILED(hr))
 802     {
 803         free_list(list, count);
 804         return hr;
 805     }
 806
 807     *n_names = count;
 808
 809     if (count)
 810     {
 811         *names = list;
 812         *start_index = index;
 813         return hr;
 814     }
 815
 816     free(list);
 817     *names = NULL;
 818     return *start_index ? S_FALSE : S_OK;
 819 }
 820
 821 HRESULT __cdecl SchRpcEnumInstances(const WCHAR *path, DWORD flags, DWORD *n_guids, GUID **guids)
 822 {
 823     FIXME("%s,%#lx,%p,%p: stub\n", debugstr_w(path), flags, n_guids, guids);
 824     return E_NOTIMPL;
 825 }
 826
 827 HRESULT __cdecl SchRpcGetInstanceInfo(GUID guid, WCHAR **path, DWORD *task_state, WCHAR **action,
 828                                       WCHAR **info, DWORD *n_instances, GUID **instances, DWORD *pid)
 829 {
 830     FIXME("%s,%p,%p,%p,%p,%p,%p,%p: stub\n", wine_dbgstr_guid(&guid), path, task_state, action,
 831           info, n_instances, instances, pid);
 832     return E_NOTIMPL;
 833 }
 834
 835 HRESULT __cdecl SchRpcStopInstance(GUID guid, DWORD flags)
 836 {
 837     FIXME("%s,%#lx: stub\n", wine_dbgstr_guid(&guid), flags);
 838     return E_NOTIMPL;
 839 }
 840
 841 HRESULT __cdecl SchRpcStop(const WCHAR *path, DWORD flags)
 842 {
 843     FIXME("%s,%#lx: stub\n", debugstr_w(path), flags);
 844     return E_NOTIMPL;
 845 }
 846
 847 HRESULT __cdecl SchRpcRun(const WCHAR *path, DWORD n_args, const WCHAR **args, DWORD flags,
 848                           DWORD session_id, const WCHAR *user, GUID *guid)
 849 {
 850     FIXME("%s,%lu,%p,%#lx,%#lx,%s,%p: stub\n", debugstr_w(path), n_args, args, flags,
 851           session_id, debugstr_w(user), guid);
 852     return E_NOTIMPL;
 853 }
 854
 855 HRESULT __cdecl SchRpcDelete(const WCHAR *path, DWORD flags)
 856 {
 857     WCHAR *full_name;
 858     HRESULT hr = S_OK;
 859
 860     TRACE("%s,%#lx\n", debugstr_w(path), flags);
 861
 862     if (flags) return E_INVALIDARG;
 863
 864     while (*path == '\\' || *path == '/') path++;
 865     if (!*path) return E_ACCESSDENIED;
 866
 867     full_name = get_full_name(path, NULL);
 868     if (!full_name) return E_OUTOFMEMORY;
 869
 870     if (!RemoveDirectoryW(full_name))
 871     {
 872         hr = HRESULT_FROM_WIN32(GetLastError());
 873         if (hr == HRESULT_FROM_WIN32(ERROR_DIRECTORY))
 874             hr = DeleteFileW(full_name) ? S_OK : HRESULT_FROM_WIN32(GetLastError());
 875     }
 876
 877     free(full_name);
 878     return hr;
 879 }
 880
 881 HRESULT __cdecl SchRpcRename(const WCHAR *path, const WCHAR *name, DWORD flags)
 882 {
 883     FIXME("%s,%s,%#lx: stub\n", debugstr_w(path), debugstr_w(name), flags);
 884     return E_NOTIMPL;
 885 }
 886
 887 HRESULT __cdecl SchRpcScheduledRuntimes(const WCHAR *path, SYSTEMTIME *start, SYSTEMTIME *end, DWORD flags,
 888                                         DWORD n_requested, DWORD *n_runtimes, SYSTEMTIME **runtimes)
 889 {
 890     FIXME("%s,%p,%p,%#lx,%lu,%p,%p: stub\n", debugstr_w(path), start, end, flags,
 891           n_requested, n_runtimes, runtimes);
 892     return E_NOTIMPL;
 893 }
 894
 895 HRESULT __cdecl SchRpcGetLastRunInfo(const WCHAR *path, SYSTEMTIME *last_runtime, DWORD *last_return_code)
 896 {
 897     FIXME("%s,%p,%p: stub\n", debugstr_w(path), last_runtime, last_return_code);
 898     return E_NOTIMPL;
 899 }
 900
 901 HRESULT __cdecl SchRpcGetTaskInfo(const WCHAR *path, DWORD flags, DWORD *enabled, DWORD *task_state)
 902 {
 903     WCHAR *full_name, *xml;
 904     struct task_info info;
 905     HRESULT hr;
 906
 907     FIXME("%s,%#lx,%p,%p: stub\n", debugstr_w(path), flags, enabled, task_state);
 908
 909     full_name = get_full_name(path, NULL);
 910     if (!full_name) return E_OUTOFMEMORY;
 911
 912     hr = read_xml(full_name, &xml);
 913     free(full_name);
 914     if (hr != S_OK) return hr;
 915     hr = read_task_info_from_xml(xml, &info);
 916     free(xml);
 917     if (FAILED(hr)) return hr;
 918
 919     *enabled = info.enabled;
 920     if (flags & SCH_FLAG_STATE)
 921         *task_state = *enabled ? TASK_STATE_READY : TASK_STATE_DISABLED;
 922     else
 923         *task_state = TASK_STATE_UNKNOWN;
 924     return S_OK;
 925 }
 926
 927 HRESULT __cdecl SchRpcGetNumberOfMissedRuns(const WCHAR *path, DWORD *runs)
 928 {
 929     FIXME("%s,%p: stub\n", debugstr_w(path), runs);
 930     return E_NOTIMPL;
 931 }
 932
 933 HRESULT __cdecl SchRpcEnableTask(const WCHAR *path, DWORD enabled)
 934 {
 935     FIXME("%s,%lu: stub\n", debugstr_w(path), enabled);
 936     return E_NOTIMPL;
 937 }