dlls/wshom.ocx/shell.c

   1 /*
   2  * Copyright 2011 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "wshom_private.h"
  20 #include "wshom.h"
  21
  22 #include "shellapi.h"
  23 #include "shlobj.h"
  24 #include "dispex.h"
  25
  26 #include "wine/debug.h"
  27
  28 extern HRESULT WINAPI DoOpenPipeStream(HANDLE pipe, IOMode mode, ITextStream **stream);
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(wshom);
  31
  32 typedef struct
  33 {
  34     struct provideclassinfo classinfo;
  35     IWshShell3 IWshShell3_iface;
  36 } WshShellImpl;
  37 static WshShellImpl WshShell3;
  38
  39 typedef struct
  40 {
  41     struct provideclassinfo classinfo;
  42     IWshCollection IWshCollection_iface;
  43     LONG ref;
  44 } WshCollection;
  45
  46 typedef struct
  47 {
  48     struct provideclassinfo classinfo;
  49     IWshShortcut IWshShortcut_iface;
  50     LONG ref;
  51
  52     IShellLinkW *link;
  53     WCHAR *path_link;
  54 } WshShortcut;
  55
  56 typedef struct
  57 {
  58     struct provideclassinfo classinfo;
  59     IWshEnvironment IWshEnvironment_iface;
  60     LONG ref;
  61 } WshEnvironment;
  62
  63 typedef struct
  64 {
  65     struct provideclassinfo classinfo;
  66     IWshExec IWshExec_iface;
  67     LONG ref;
  68     PROCESS_INFORMATION info;
  69     ITextStream *stdin_stream;
  70     ITextStream *stdout_stream;
  71     ITextStream *stderr_stream;
  72 } WshExecImpl;
  73
  74 static inline WshCollection *impl_from_IWshCollection( IWshCollection *iface )
  75 {
  76     return CONTAINING_RECORD(iface, WshCollection, IWshCollection_iface);
  77 }
  78
  79 static inline WshShortcut *impl_from_IWshShortcut( IWshShortcut *iface )
  80 {
  81     return CONTAINING_RECORD(iface, WshShortcut, IWshShortcut_iface);
  82 }
  83
  84 static inline WshEnvironment *impl_from_IWshEnvironment( IWshEnvironment *iface )
  85 {
  86     return CONTAINING_RECORD(iface, WshEnvironment, IWshEnvironment_iface);
  87 }
  88
  89 static inline WshExecImpl *impl_from_IWshExec( IWshExec *iface )
  90 {
  91     return CONTAINING_RECORD(iface, WshExecImpl, IWshExec_iface);
  92 }
  93
  94 static HRESULT WINAPI WshExec_QueryInterface(IWshExec *iface, REFIID riid, void **obj)
  95 {
  96     WshExecImpl *This = impl_from_IWshExec(iface);
  97
  98     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
  99
 100     if (IsEqualGUID(riid, &IID_IDispatch) ||
 101         IsEqualGUID(riid, &IID_IWshExec) ||
 102         IsEqualGUID(riid, &IID_IUnknown))
 103     {
 104         *obj = iface;
 105     }
 106     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
 107     {
 108         *obj = &This->classinfo.IProvideClassInfo_iface;
 109     }
 110     else {
 111         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 112         *obj = NULL;
 113         return E_NOINTERFACE;
 114     }
 115
 116     IUnknown_AddRef((IUnknown *)*obj);
 117     return S_OK;
 118 }
 119
 120 static ULONG WINAPI WshExec_AddRef(IWshExec *iface)
 121 {
 122     WshExecImpl *This = impl_from_IWshExec(iface);
 123     LONG ref = InterlockedIncrement(&This->ref);
 124     TRACE("%p, refcount %ld.\n", iface, ref);
 125     return ref;
 126 }
 127
 128 static ULONG WINAPI WshExec_Release(IWshExec *iface)
 129 {
 130     WshExecImpl *exec = impl_from_IWshExec(iface);
 131     LONG ref = InterlockedDecrement(&exec->ref);
 132
 133     TRACE("%p, refcount %ld.\n", iface, ref);
 134
 135     if (!ref)
 136     {
 137         CloseHandle(exec->info.hThread);
 138         CloseHandle(exec->info.hProcess);
 139         if (exec->stdin_stream)
 140             ITextStream_Release(exec->stdin_stream);
 141         if (exec->stdout_stream)
 142             ITextStream_Release(exec->stdout_stream);
 143         if (exec->stderr_stream)
 144             ITextStream_Release(exec->stderr_stream);
 145         free(exec);
 146     }
 147
 148     return ref;
 149 }
 150
 151 static HRESULT WINAPI WshExec_GetTypeInfoCount(IWshExec *iface, UINT *pctinfo)
 152 {
 153     WshExecImpl *This = impl_from_IWshExec(iface);
 154     TRACE("(%p)->(%p)\n", This, pctinfo);
 155     *pctinfo = 1;
 156     return S_OK;
 157 }
 158
 159 static HRESULT WINAPI WshExec_GetTypeInfo(IWshExec *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 160 {
 161     TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 162
 163     return get_typeinfo(IWshExec_tid, ppTInfo);
 164 }
 165
 166 static HRESULT WINAPI WshExec_GetIDsOfNames(IWshExec *iface, REFIID riid, LPOLESTR *rgszNames,
 167         UINT cNames, LCID lcid, DISPID *rgDispId)
 168 {
 169     ITypeInfo *typeinfo;
 170     HRESULT hr;
 171
 172     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 173
 174     hr = get_typeinfo(IWshExec_tid, &typeinfo);
 175     if(SUCCEEDED(hr))
 176     {
 177         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 178         ITypeInfo_Release(typeinfo);
 179     }
 180
 181     return hr;
 182 }
 183
 184 static HRESULT WINAPI WshExec_Invoke(IWshExec *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 185         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 186 {
 187     ITypeInfo *typeinfo;
 188     HRESULT hr;
 189
 190     TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
 191           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 192
 193     hr = get_typeinfo(IWshExec_tid, &typeinfo);
 194     if(SUCCEEDED(hr))
 195     {
 196         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 197         ITypeInfo_Release(typeinfo);
 198     }
 199
 200     return hr;
 201 }
 202
 203 static HRESULT WINAPI WshExec_get_Status(IWshExec *iface, WshExecStatus *status)
 204 {
 205     WshExecImpl *This = impl_from_IWshExec(iface);
 206     DWORD code;
 207
 208     TRACE("(%p)->(%p)\n", This, status);
 209
 210     if (!status)
 211         return E_INVALIDARG;
 212
 213     if (!GetExitCodeProcess(This->info.hProcess, &code))
 214         return HRESULT_FROM_WIN32(GetLastError());
 215
 216     switch (code)
 217     {
 218     case 0:
 219         *status = WshFinished;
 220         break;
 221     case STILL_ACTIVE:
 222         *status = WshRunning;
 223         break;
 224     default:
 225         *status = WshFailed;
 226     }
 227
 228     return S_OK;
 229 }
 230
 231 static HRESULT WINAPI WshExec_get_StdIn(IWshExec *iface, ITextStream **stream)
 232 {
 233     WshExecImpl *exec = impl_from_IWshExec(iface);
 234
 235     TRACE("%p, %p.\n", iface, stream);
 236
 237     *stream = exec->stdin_stream;
 238     ITextStream_AddRef(*stream);
 239
 240     return S_OK;
 241 }
 242
 243 static HRESULT WINAPI WshExec_get_StdOut(IWshExec *iface, ITextStream **stream)
 244 {
 245     WshExecImpl *exec = impl_from_IWshExec(iface);
 246
 247     TRACE("%p, %p.\n", iface, stream);
 248
 249     *stream = exec->stdout_stream;
 250     ITextStream_AddRef(*stream);
 251
 252     return S_OK;
 253 }
 254
 255 static HRESULT WINAPI WshExec_get_StdErr(IWshExec *iface, ITextStream **stream)
 256 {
 257     WshExecImpl *exec = impl_from_IWshExec(iface);
 258
 259     TRACE("%p, %p.\n", iface, stream);
 260
 261     *stream = exec->stderr_stream;
 262     ITextStream_AddRef(*stream);
 263
 264     return S_OK;
 265 }
 266
 267 static HRESULT WINAPI WshExec_get_ProcessID(IWshExec *iface, int *pid)
 268 {
 269     WshExecImpl *This = impl_from_IWshExec(iface);
 270
 271     TRACE("(%p)->(%p)\n", This, pid);
 272
 273     if (!pid)
 274         return E_INVALIDARG;
 275
 276     *pid = This->info.dwProcessId;
 277     return S_OK;
 278 }
 279
 280 static HRESULT WINAPI WshExec_get_ExitCode(IWshExec *iface, int *code)
 281 {
 282     WshExecImpl *This = impl_from_IWshExec(iface);
 283
 284     FIXME("(%p)->(%p): stub\n", This, code);
 285
 286     return E_NOTIMPL;
 287 }
 288
 289 static BOOL CALLBACK enum_thread_wnd_proc(HWND hwnd, LPARAM lParam)
 290 {
 291     INT *count = (INT*)lParam;
 292
 293     (*count)++;
 294     PostMessageW(hwnd, WM_CLOSE, 0, 0);
 295     /* try to send it to all windows, even if failed for some */
 296     return TRUE;
 297 }
 298
 299 static HRESULT WINAPI WshExec_Terminate(IWshExec *iface)
 300 {
 301     WshExecImpl *This = impl_from_IWshExec(iface);
 302     BOOL ret, kill = FALSE;
 303     INT count = 0;
 304
 305     TRACE("(%p)\n", This);
 306
 307     ret = EnumThreadWindows(This->info.dwThreadId, enum_thread_wnd_proc, (LPARAM)&count);
 308     if (ret && count) {
 309         /* manual testing shows that it waits 2 seconds before forcing termination */
 310         if (WaitForSingleObject(This->info.hProcess, 2000) != WAIT_OBJECT_0)
 311             kill = TRUE;
 312     }
 313     else
 314         kill = TRUE;
 315
 316     if (kill)
 317         TerminateProcess(This->info.hProcess, 0);
 318
 319     return S_OK;
 320 }
 321
 322 static const IWshExecVtbl WshExecVtbl = {
 323     WshExec_QueryInterface,
 324     WshExec_AddRef,
 325     WshExec_Release,
 326     WshExec_GetTypeInfoCount,
 327     WshExec_GetTypeInfo,
 328     WshExec_GetIDsOfNames,
 329     WshExec_Invoke,
 330     WshExec_get_Status,
 331     WshExec_get_StdIn,
 332     WshExec_get_StdOut,
 333     WshExec_get_StdErr,
 334     WshExec_get_ProcessID,
 335     WshExec_get_ExitCode,
 336     WshExec_Terminate
 337 };
 338
 339 static HRESULT create_pipe(HANDLE *hread, HANDLE *hwrite)
 340 {
 341     SECURITY_ATTRIBUTES sa;
 342
 343     sa.nLength = sizeof(sa);
 344     sa.bInheritHandle = TRUE;
 345     sa.lpSecurityDescriptor = NULL;
 346
 347     *hread = *hwrite = NULL;
 348     if (!CreatePipe(hread, hwrite, &sa, 0))
 349         return HRESULT_FROM_WIN32(GetLastError());
 350     return S_OK;
 351 }
 352
 353 static void close_pipe(HANDLE *hread, HANDLE *hwrite)
 354 {
 355     CloseHandle(*hread);
 356     CloseHandle(*hwrite);
 357     *hread = *hwrite = NULL;
 358 }
 359
 360 static HRESULT WshExec_create(BSTR command, IWshExec **ret)
 361 {
 362     HANDLE stdout_read, stdout_write;
 363     HANDLE stderr_read, stderr_write;
 364     HANDLE stdin_read, stdin_write;
 365     STARTUPINFOW si = {0};
 366     WshExecImpl *object;
 367     HRESULT hr;
 368
 369     *ret = NULL;
 370
 371     if (!(object = calloc(1, sizeof(*object))))
 372         return E_OUTOFMEMORY;
 373
 374     object->IWshExec_iface.lpVtbl = &WshExecVtbl;
 375     object->ref = 1;
 376     init_classinfo(&CLSID_WshExec, (IUnknown *)&object->IWshExec_iface, &object->classinfo);
 377
 378     if (FAILED(hr = create_pipe(&stdin_read, &stdin_write)))
 379     {
 380         WARN("Failed to create stdin pipe.\n");
 381         goto failed;
 382     }
 383
 384     if (FAILED(hr = create_pipe(&stdout_read, &stdout_write)))
 385     {
 386         close_pipe(&stdin_read, &stdin_write);
 387         WARN("Failed to create stdout pipe.\n");
 388         goto failed;
 389     }
 390
 391     if (FAILED(hr = create_pipe(&stderr_read, &stderr_write)))
 392     {
 393         close_pipe(&stdin_read, &stdin_write);
 394         close_pipe(&stdout_read, &stdout_write);
 395         WARN("Failed to create stderr pipe.\n");
 396         goto failed;
 397     }
 398
 399     if (SUCCEEDED(hr))
 400     {
 401         SetHandleInformation(stdin_write, HANDLE_FLAG_INHERIT, 0);
 402         SetHandleInformation(stdout_read, HANDLE_FLAG_INHERIT, 0);
 403         SetHandleInformation(stderr_read, HANDLE_FLAG_INHERIT, 0);
 404     }
 405
 406     if (SUCCEEDED(hr))
 407         hr = DoOpenPipeStream(stdin_write, ForWriting, &object->stdin_stream);
 408     if (SUCCEEDED(hr))
 409         hr = DoOpenPipeStream(stdout_read, ForReading, &object->stdout_stream);
 410     if (SUCCEEDED(hr))
 411         hr = DoOpenPipeStream(stderr_read, ForReading, &object->stderr_stream);
 412
 413     si.cb = sizeof(si);
 414     si.hStdError = stderr_write;
 415     si.hStdOutput = stdout_write;
 416     si.hStdInput = stdin_read;
 417     si.dwFlags = STARTF_USESTDHANDLES;
 418
 419     if (SUCCEEDED(hr))
 420     {
 421         if (!CreateProcessW(NULL, command, NULL, NULL, FALSE, 0, NULL, NULL, &si, &object->info))
 422             hr = HRESULT_FROM_WIN32(GetLastError());
 423     }
 424
 425     CloseHandle(stderr_write);
 426     CloseHandle(stdout_write);
 427     CloseHandle(stdin_read);
 428
 429     if (SUCCEEDED(hr))
 430     {
 431         *ret = &object->IWshExec_iface;
 432
 433         return S_OK;
 434     }
 435
 436 failed:
 437
 438     IWshExec_Release(&object->IWshExec_iface);
 439
 440     return hr;
 441 }
 442
 443 static HRESULT WINAPI WshEnvironment_QueryInterface(IWshEnvironment *iface, REFIID riid, void **obj)
 444 {
 445     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 446
 447     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 448
 449     if (IsEqualGUID(riid, &IID_IUnknown)  ||
 450         IsEqualGUID(riid, &IID_IDispatch) ||
 451         IsEqualGUID(riid, &IID_IWshEnvironment))
 452     {
 453         *obj = iface;
 454     }
 455     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
 456     {
 457         *obj = &This->classinfo.IProvideClassInfo_iface;
 458     }
 459     else {
 460         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 461         *obj = NULL;
 462         return E_NOINTERFACE;
 463     }
 464
 465     IUnknown_AddRef((IUnknown*)*obj);
 466     return S_OK;
 467 }
 468
 469 static ULONG WINAPI WshEnvironment_AddRef(IWshEnvironment *iface)
 470 {
 471     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 472     LONG ref = InterlockedIncrement(&This->ref);
 473     TRACE("%p, refcount %ld.\n", iface, ref);
 474     return ref;
 475 }
 476
 477 static ULONG WINAPI WshEnvironment_Release(IWshEnvironment *iface)
 478 {
 479     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 480     LONG ref = InterlockedDecrement(&This->ref);
 481     TRACE("%p, refcount %ld.\n", iface, ref);
 482
 483     if (!ref)
 484         free(This);
 485
 486     return ref;
 487 }
 488
 489 static HRESULT WINAPI WshEnvironment_GetTypeInfoCount(IWshEnvironment *iface, UINT *pctinfo)
 490 {
 491     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 492     TRACE("(%p)->(%p)\n", This, pctinfo);
 493     *pctinfo = 1;
 494     return S_OK;
 495 }
 496
 497 static HRESULT WINAPI WshEnvironment_GetTypeInfo(IWshEnvironment *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 498 {
 499     TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 500
 501     return get_typeinfo(IWshEnvironment_tid, ppTInfo);
 502 }
 503
 504 static HRESULT WINAPI WshEnvironment_GetIDsOfNames(IWshEnvironment *iface, REFIID riid, LPOLESTR *rgszNames,
 505         UINT cNames, LCID lcid, DISPID *rgDispId)
 506 {
 507     ITypeInfo *typeinfo;
 508     HRESULT hr;
 509
 510     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 511
 512     hr = get_typeinfo(IWshEnvironment_tid, &typeinfo);
 513     if(SUCCEEDED(hr))
 514     {
 515         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 516         ITypeInfo_Release(typeinfo);
 517     }
 518
 519     return hr;
 520 }
 521
 522 static HRESULT WINAPI WshEnvironment_Invoke(IWshEnvironment *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 523         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 524 {
 525     ITypeInfo *typeinfo;
 526     HRESULT hr;
 527
 528     TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
 529           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 530
 531     hr = get_typeinfo(IWshEnvironment_tid, &typeinfo);
 532     if(SUCCEEDED(hr))
 533     {
 534         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 535         ITypeInfo_Release(typeinfo);
 536     }
 537
 538     return hr;
 539 }
 540
 541 static HRESULT WINAPI WshEnvironment_get_Item(IWshEnvironment *iface, BSTR name, BSTR *value)
 542 {
 543     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 544     DWORD len;
 545
 546     TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), value);
 547
 548     if (!value)
 549         return E_POINTER;
 550
 551     len = GetEnvironmentVariableW(name, NULL, 0);
 552     if (len)
 553     {
 554         *value = SysAllocStringLen(NULL, len - 1);
 555         if (*value)
 556             GetEnvironmentVariableW(name, *value, len);
 557     }
 558     else
 559         *value = SysAllocStringLen(NULL, 0);
 560
 561     return *value ? S_OK : E_OUTOFMEMORY;
 562 }
 563
 564 static HRESULT WINAPI WshEnvironment_put_Item(IWshEnvironment *iface, BSTR name, BSTR value)
 565 {
 566     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 567     FIXME("(%p)->(%s %s): stub\n", This, debugstr_w(name), debugstr_w(value));
 568     return E_NOTIMPL;
 569 }
 570
 571 static HRESULT WINAPI WshEnvironment_Count(IWshEnvironment *iface, LONG *count)
 572 {
 573     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 574     FIXME("(%p)->(%p): stub\n", This, count);
 575     return E_NOTIMPL;
 576 }
 577
 578 static HRESULT WINAPI WshEnvironment_get_length(IWshEnvironment *iface, LONG *len)
 579 {
 580     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 581     FIXME("(%p)->(%p): stub\n", This, len);
 582     return E_NOTIMPL;
 583 }
 584
 585 static HRESULT WINAPI WshEnvironment__NewEnum(IWshEnvironment *iface, IUnknown **penum)
 586 {
 587     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 588     FIXME("(%p)->(%p): stub\n", This, penum);
 589     return E_NOTIMPL;
 590 }
 591
 592 static HRESULT WINAPI WshEnvironment_Remove(IWshEnvironment *iface, BSTR name)
 593 {
 594     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 595     FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
 596     return E_NOTIMPL;
 597 }
 598
 599 static const IWshEnvironmentVtbl WshEnvironmentVtbl = {
 600     WshEnvironment_QueryInterface,
 601     WshEnvironment_AddRef,
 602     WshEnvironment_Release,
 603     WshEnvironment_GetTypeInfoCount,
 604     WshEnvironment_GetTypeInfo,
 605     WshEnvironment_GetIDsOfNames,
 606     WshEnvironment_Invoke,
 607     WshEnvironment_get_Item,
 608     WshEnvironment_put_Item,
 609     WshEnvironment_Count,
 610     WshEnvironment_get_length,
 611     WshEnvironment__NewEnum,
 612     WshEnvironment_Remove
 613 };
 614
 615 static HRESULT WshEnvironment_Create(IWshEnvironment **env)
 616 {
 617     WshEnvironment *object;
 618
 619     if (!(object = calloc(1, sizeof(*object))))
 620         return E_OUTOFMEMORY;
 621
 622     object->IWshEnvironment_iface.lpVtbl = &WshEnvironmentVtbl;
 623     object->ref = 1;
 624
 625     init_classinfo(&IID_IWshEnvironment, (IUnknown *)&object->IWshEnvironment_iface, &object->classinfo);
 626     *env = &object->IWshEnvironment_iface;
 627
 628     return S_OK;
 629 }
 630
 631 static HRESULT WINAPI WshCollection_QueryInterface(IWshCollection *iface, REFIID riid, void **ppv)
 632 {
 633     WshCollection *This = impl_from_IWshCollection(iface);
 634
 635     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 636
 637     if (IsEqualGUID(riid, &IID_IUnknown)  ||
 638         IsEqualGUID(riid, &IID_IDispatch) ||
 639         IsEqualGUID(riid, &IID_IWshCollection))
 640     {
 641         *ppv = iface;
 642     }
 643     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
 644     {
 645         *ppv = &This->classinfo.IProvideClassInfo_iface;
 646     }
 647     else {
 648         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 649         *ppv = NULL;
 650         return E_NOINTERFACE;
 651     }
 652
 653     IUnknown_AddRef((IUnknown*)*ppv);
 654     return S_OK;
 655 }
 656
 657 static ULONG WINAPI WshCollection_AddRef(IWshCollection *iface)
 658 {
 659     WshCollection *collection = impl_from_IWshCollection(iface);
 660     LONG ref = InterlockedIncrement(&collection->ref);
 661
 662     TRACE("%p, refcount %ld.\n", iface, ref);
 663
 664     return ref;
 665 }
 666
 667 static ULONG WINAPI WshCollection_Release(IWshCollection *iface)
 668 {
 669     WshCollection *collection = impl_from_IWshCollection(iface);
 670     LONG ref = InterlockedDecrement(&collection->ref);
 671     TRACE("%p, refcount %ld.\n", iface, ref);
 672
 673     if (!ref)
 674         free(collection);
 675
 676     return ref;
 677 }
 678
 679 static HRESULT WINAPI WshCollection_GetTypeInfoCount(IWshCollection *iface, UINT *pctinfo)
 680 {
 681     WshCollection *This = impl_from_IWshCollection(iface);
 682     TRACE("(%p)->(%p)\n", This, pctinfo);
 683     *pctinfo = 1;
 684     return S_OK;
 685 }
 686
 687 static HRESULT WINAPI WshCollection_GetTypeInfo(IWshCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 688 {
 689     TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 690
 691     return get_typeinfo(IWshCollection_tid, ppTInfo);
 692 }
 693
 694 static HRESULT WINAPI WshCollection_GetIDsOfNames(IWshCollection *iface, REFIID riid, LPOLESTR *rgszNames,
 695         UINT cNames, LCID lcid, DISPID *rgDispId)
 696 {
 697     ITypeInfo *typeinfo;
 698     HRESULT hr;
 699
 700     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 701
 702     hr = get_typeinfo(IWshCollection_tid, &typeinfo);
 703     if(SUCCEEDED(hr))
 704     {
 705         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 706         ITypeInfo_Release(typeinfo);
 707     }
 708
 709     return hr;
 710 }
 711
 712 static HRESULT WINAPI WshCollection_Invoke(IWshCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 713         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 714 {
 715     ITypeInfo *typeinfo;
 716     HRESULT hr;
 717
 718     TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
 719           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 720
 721     hr = get_typeinfo(IWshCollection_tid, &typeinfo);
 722     if(SUCCEEDED(hr))
 723     {
 724         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 725         ITypeInfo_Release(typeinfo);
 726     }
 727
 728     return hr;
 729 }
 730
 731 static HRESULT WINAPI WshCollection_Item(IWshCollection *iface, VARIANT *index, VARIANT *value)
 732 {
 733     WshCollection *This = impl_from_IWshCollection(iface);
 734     PIDLIST_ABSOLUTE pidl;
 735     WCHAR pathW[MAX_PATH];
 736     int kind = 0;
 737     BSTR folder;
 738     HRESULT hr;
 739
 740     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(index), value);
 741
 742     if (V_VT(index) != VT_BSTR)
 743     {
 744         FIXME("only BSTR index supported, got %d\n", V_VT(index));
 745         return E_NOTIMPL;
 746     }
 747
 748     folder = V_BSTR(index);
 749     if (!wcsicmp(folder, L"Desktop"))
 750         kind = CSIDL_DESKTOP;
 751     else if (!wcsicmp(folder, L"AllUsersDesktop"))
 752         kind = CSIDL_COMMON_DESKTOPDIRECTORY;
 753     else if (!wcsicmp(folder, L"AllUsersPrograms"))
 754         kind = CSIDL_COMMON_PROGRAMS;
 755     else
 756     {
 757         FIXME("folder kind %s not supported\n", debugstr_w(folder));
 758         return E_NOTIMPL;
 759     }
 760
 761     hr = SHGetSpecialFolderLocation(NULL, kind, &pidl);
 762     if (hr != S_OK) return hr;
 763
 764     if (SHGetPathFromIDListW(pidl, pathW))
 765     {
 766         V_VT(value) = VT_BSTR;
 767         V_BSTR(value) = SysAllocString(pathW);
 768         hr = V_BSTR(value) ? S_OK : E_OUTOFMEMORY;
 769     }
 770     else
 771         hr = E_FAIL;
 772
 773     CoTaskMemFree(pidl);
 774
 775     return hr;
 776 }
 777
 778 static HRESULT WINAPI WshCollection_Count(IWshCollection *iface, LONG *count)
 779 {
 780     WshCollection *This = impl_from_IWshCollection(iface);
 781     FIXME("(%p)->(%p): stub\n", This, count);
 782     return E_NOTIMPL;
 783 }
 784
 785 static HRESULT WINAPI WshCollection_get_length(IWshCollection *iface, LONG *count)
 786 {
 787     WshCollection *This = impl_from_IWshCollection(iface);
 788     FIXME("(%p)->(%p): stub\n", This, count);
 789     return E_NOTIMPL;
 790 }
 791
 792 static HRESULT WINAPI WshCollection__NewEnum(IWshCollection *iface, IUnknown **Enum)
 793 {
 794     WshCollection *This = impl_from_IWshCollection(iface);
 795     FIXME("(%p)->(%p): stub\n", This, Enum);
 796     return E_NOTIMPL;
 797 }
 798
 799 static const IWshCollectionVtbl WshCollectionVtbl = {
 800     WshCollection_QueryInterface,
 801     WshCollection_AddRef,
 802     WshCollection_Release,
 803     WshCollection_GetTypeInfoCount,
 804     WshCollection_GetTypeInfo,
 805     WshCollection_GetIDsOfNames,
 806     WshCollection_Invoke,
 807     WshCollection_Item,
 808     WshCollection_Count,
 809     WshCollection_get_length,
 810     WshCollection__NewEnum
 811 };
 812
 813 static HRESULT WshCollection_Create(IWshCollection **collection)
 814 {
 815     WshCollection *object;
 816
 817     if (!(object = calloc(1, sizeof(*object))))
 818         return E_OUTOFMEMORY;
 819
 820     object->IWshCollection_iface.lpVtbl = &WshCollectionVtbl;
 821     object->ref = 1;
 822
 823     init_classinfo(&IID_IWshCollection, (IUnknown *)&object->IWshCollection_iface, &object->classinfo);
 824     *collection = &object->IWshCollection_iface;
 825
 826     return S_OK;
 827 }
 828
 829 /* IWshShortcut */
 830 static HRESULT WINAPI WshShortcut_QueryInterface(IWshShortcut *iface, REFIID riid, void **ppv)
 831 {
 832     WshShortcut *This = impl_from_IWshShortcut(iface);
 833
 834     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 835
 836     if (IsEqualGUID(riid, &IID_IUnknown)  ||
 837         IsEqualGUID(riid, &IID_IDispatch) ||
 838         IsEqualGUID(riid, &IID_IWshShortcut))
 839     {
 840         *ppv = iface;
 841     }
 842     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
 843     {
 844         *ppv = &This->classinfo.IProvideClassInfo_iface;
 845     }
 846     else {
 847         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 848         *ppv = NULL;
 849         return E_NOINTERFACE;
 850     }
 851
 852     IUnknown_AddRef((IUnknown*)*ppv);
 853     return S_OK;
 854 }
 855
 856 static ULONG WINAPI WshShortcut_AddRef(IWshShortcut *iface)
 857 {
 858     WshShortcut *This = impl_from_IWshShortcut(iface);
 859     LONG ref = InterlockedIncrement(&This->ref);
 860     TRACE("%p, refcount %ld.\n", iface, ref);
 861     return ref;
 862 }
 863
 864 static ULONG WINAPI WshShortcut_Release(IWshShortcut *iface)
 865 {
 866     WshShortcut *This = impl_from_IWshShortcut(iface);
 867     LONG ref = InterlockedDecrement(&This->ref);
 868     TRACE("%p, refcount %ld.\n", iface, ref);
 869
 870     if (!ref)
 871     {
 872         IShellLinkW_Release(This->link);
 873         free(This->path_link);
 874         free(This);
 875     }
 876
 877     return ref;
 878 }
 879
 880 static HRESULT WINAPI WshShortcut_GetTypeInfoCount(IWshShortcut *iface, UINT *pctinfo)
 881 {
 882     WshShortcut *This = impl_from_IWshShortcut(iface);
 883     TRACE("(%p)->(%p)\n", This, pctinfo);
 884     *pctinfo = 1;
 885     return S_OK;
 886 }
 887
 888 static HRESULT WINAPI WshShortcut_GetTypeInfo(IWshShortcut *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 889 {
 890     TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 891
 892     return get_typeinfo(IWshShortcut_tid, ppTInfo);
 893 }
 894
 895 static HRESULT WINAPI WshShortcut_GetIDsOfNames(IWshShortcut *iface, REFIID riid, LPOLESTR *rgszNames,
 896         UINT cNames, LCID lcid, DISPID *rgDispId)
 897 {
 898     ITypeInfo *typeinfo;
 899     HRESULT hr;
 900
 901     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 902
 903     hr = get_typeinfo(IWshShortcut_tid, &typeinfo);
 904     if(SUCCEEDED(hr))
 905     {
 906         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 907         ITypeInfo_Release(typeinfo);
 908     }
 909
 910     return hr;
 911 }
 912
 913 static HRESULT WINAPI WshShortcut_Invoke(IWshShortcut *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 914         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 915 {
 916     ITypeInfo *typeinfo;
 917     HRESULT hr;
 918
 919     TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
 920           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 921
 922     hr = get_typeinfo(IWshShortcut_tid, &typeinfo);
 923     if(SUCCEEDED(hr))
 924     {
 925         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 926         ITypeInfo_Release(typeinfo);
 927     }
 928
 929     return hr;
 930 }
 931
 932 static HRESULT WINAPI WshShortcut_get_FullName(IWshShortcut *iface, BSTR *name)
 933 {
 934     WshShortcut *This = impl_from_IWshShortcut(iface);
 935     FIXME("(%p)->(%p): stub\n", This, name);
 936     return E_NOTIMPL;
 937 }
 938
 939 static HRESULT WINAPI WshShortcut_get_Arguments(IWshShortcut *iface, BSTR *Arguments)
 940 {
 941     WshShortcut *This = impl_from_IWshShortcut(iface);
 942     WCHAR buffW[INFOTIPSIZE];
 943     HRESULT hr;
 944
 945     TRACE("(%p)->(%p)\n", This, Arguments);
 946
 947     if (!Arguments)
 948         return E_POINTER;
 949
 950     *Arguments = NULL;
 951
 952     hr = IShellLinkW_GetArguments(This->link, buffW, ARRAY_SIZE(buffW));
 953     if (FAILED(hr))
 954         return hr;
 955
 956     *Arguments = SysAllocString(buffW);
 957     return *Arguments ? S_OK : E_OUTOFMEMORY;
 958 }
 959
 960 static HRESULT WINAPI WshShortcut_put_Arguments(IWshShortcut *iface, BSTR Arguments)
 961 {
 962     WshShortcut *This = impl_from_IWshShortcut(iface);
 963
 964     TRACE("(%p)->(%s)\n", This, debugstr_w(Arguments));
 965
 966     return IShellLinkW_SetArguments(This->link, Arguments);
 967 }
 968
 969 static HRESULT WINAPI WshShortcut_get_Description(IWshShortcut *iface, BSTR *Description)
 970 {
 971     WshShortcut *This = impl_from_IWshShortcut(iface);
 972     FIXME("(%p)->(%p): stub\n", This, Description);
 973     return E_NOTIMPL;
 974 }
 975
 976 static HRESULT WINAPI WshShortcut_put_Description(IWshShortcut *iface, BSTR Description)
 977 {
 978     WshShortcut *This = impl_from_IWshShortcut(iface);
 979     TRACE("(%p)->(%s)\n", This, debugstr_w(Description));
 980     return IShellLinkW_SetDescription(This->link, Description);
 981 }
 982
 983 static HRESULT WINAPI WshShortcut_get_Hotkey(IWshShortcut *iface, BSTR *Hotkey)
 984 {
 985     WshShortcut *This = impl_from_IWshShortcut(iface);
 986     FIXME("(%p)->(%p): stub\n", This, Hotkey);
 987     return E_NOTIMPL;
 988 }
 989
 990 static HRESULT WINAPI WshShortcut_put_Hotkey(IWshShortcut *iface, BSTR Hotkey)
 991 {
 992     WshShortcut *This = impl_from_IWshShortcut(iface);
 993     FIXME("(%p)->(%s): stub\n", This, debugstr_w(Hotkey));
 994     return E_NOTIMPL;
 995 }
 996
 997 static HRESULT WINAPI WshShortcut_get_IconLocation(IWshShortcut *iface, BSTR *IconPath)
 998 {
 999     WshShortcut *This = impl_from_IWshShortcut(iface);
1000     WCHAR buffW[MAX_PATH], pathW[MAX_PATH];
1001     INT icon = 0;
1002     HRESULT hr;
1003
1004     TRACE("(%p)->(%p)\n", This, IconPath);
1005
1006     if (!IconPath)
1007         return E_POINTER;
1008
1009     hr = IShellLinkW_GetIconLocation(This->link, buffW, ARRAY_SIZE(buffW), &icon);
1010     if (FAILED(hr)) return hr;
1011
1012     swprintf(pathW, ARRAY_SIZE(pathW), L"%s, %d", buffW, icon);
1013     *IconPath = SysAllocString(pathW);
1014     if (!*IconPath) return E_OUTOFMEMORY;
1015
1016     return S_OK;
1017 }
1018
1019 static HRESULT WINAPI WshShortcut_put_IconLocation(IWshShortcut *iface, BSTR IconPath)
1020 {
1021     WshShortcut *This = impl_from_IWshShortcut(iface);
1022     HRESULT hr;
1023     WCHAR *ptr;
1024     BSTR path;
1025     INT icon;
1026
1027     TRACE("(%p)->(%s)\n", This, debugstr_w(IconPath));
1028
1029     /* scan for icon id */
1030     ptr = wcsrchr(IconPath, ',');
1031     if (!ptr)
1032     {
1033         WARN("icon index not found\n");
1034         return E_FAIL;
1035     }
1036
1037     path = SysAllocStringLen(IconPath, ptr-IconPath);
1038
1039     /* skip spaces if any */
1040     while (iswspace(*++ptr))
1041         ;
1042
1043     icon = wcstol(ptr, NULL, 10);
1044
1045     hr = IShellLinkW_SetIconLocation(This->link, path, icon);
1046     SysFreeString(path);
1047
1048     return hr;
1049 }
1050
1051 static HRESULT WINAPI WshShortcut_put_RelativePath(IWshShortcut *iface, BSTR rhs)
1052 {
1053     WshShortcut *This = impl_from_IWshShortcut(iface);
1054     FIXME("(%p)->(%s): stub\n", This, debugstr_w(rhs));
1055     return E_NOTIMPL;
1056 }
1057
1058 static HRESULT WINAPI WshShortcut_get_TargetPath(IWshShortcut *iface, BSTR *Path)
1059 {
1060     WshShortcut *This = impl_from_IWshShortcut(iface);
1061     FIXME("(%p)->(%p): stub\n", This, Path);
1062     return E_NOTIMPL;
1063 }
1064
1065 static HRESULT WINAPI WshShortcut_put_TargetPath(IWshShortcut *iface, BSTR Path)
1066 {
1067     WshShortcut *This = impl_from_IWshShortcut(iface);
1068     TRACE("(%p)->(%s)\n", This, debugstr_w(Path));
1069     return IShellLinkW_SetPath(This->link, Path);
1070 }
1071
1072 static HRESULT WINAPI WshShortcut_get_WindowStyle(IWshShortcut *iface, int *ShowCmd)
1073 {
1074     WshShortcut *This = impl_from_IWshShortcut(iface);
1075     TRACE("(%p)->(%p)\n", This, ShowCmd);
1076     return IShellLinkW_GetShowCmd(This->link, ShowCmd);
1077 }
1078
1079 static HRESULT WINAPI WshShortcut_put_WindowStyle(IWshShortcut *iface, int ShowCmd)
1080 {
1081     WshShortcut *This = impl_from_IWshShortcut(iface);
1082     TRACE("(%p)->(%d)\n", This, ShowCmd);
1083     return IShellLinkW_SetShowCmd(This->link, ShowCmd);
1084 }
1085
1086 static HRESULT WINAPI WshShortcut_get_WorkingDirectory(IWshShortcut *iface, BSTR *WorkingDirectory)
1087 {
1088     WshShortcut *This = impl_from_IWshShortcut(iface);
1089     WCHAR buffW[MAX_PATH];
1090     HRESULT hr;
1091
1092     TRACE("(%p)->(%p)\n", This, WorkingDirectory);
1093
1094     if (!WorkingDirectory)
1095         return E_POINTER;
1096
1097     *WorkingDirectory = NULL;
1098     hr = IShellLinkW_GetWorkingDirectory(This->link, buffW, ARRAY_SIZE(buffW));
1099     if (FAILED(hr)) return hr;
1100
1101     *WorkingDirectory = SysAllocString(buffW);
1102     return *WorkingDirectory ? S_OK : E_OUTOFMEMORY;
1103 }
1104
1105 static HRESULT WINAPI WshShortcut_put_WorkingDirectory(IWshShortcut *iface, BSTR WorkingDirectory)
1106 {
1107     WshShortcut *This = impl_from_IWshShortcut(iface);
1108     TRACE("(%p)->(%s)\n", This, debugstr_w(WorkingDirectory));
1109     return IShellLinkW_SetWorkingDirectory(This->link, WorkingDirectory);
1110 }
1111
1112 static HRESULT WINAPI WshShortcut_Load(IWshShortcut *iface, BSTR PathLink)
1113 {
1114     WshShortcut *This = impl_from_IWshShortcut(iface);
1115     FIXME("(%p)->(%s): stub\n", This, debugstr_w(PathLink));
1116     return E_NOTIMPL;
1117 }
1118
1119 static HRESULT WINAPI WshShortcut_Save(IWshShortcut *iface)
1120 {
1121     WshShortcut *This = impl_from_IWshShortcut(iface);
1122     IPersistFile *file;
1123     HRESULT hr;
1124
1125     TRACE("(%p)\n", This);
1126
1127     IShellLinkW_QueryInterface(This->link, &IID_IPersistFile, (void**)&file);
1128     hr = IPersistFile_Save(file, This->path_link, TRUE);
1129     IPersistFile_Release(file);
1130
1131     return hr;
1132 }
1133
1134 static const IWshShortcutVtbl WshShortcutVtbl = {
1135     WshShortcut_QueryInterface,
1136     WshShortcut_AddRef,
1137     WshShortcut_Release,
1138     WshShortcut_GetTypeInfoCount,
1139     WshShortcut_GetTypeInfo,
1140     WshShortcut_GetIDsOfNames,
1141     WshShortcut_Invoke,
1142     WshShortcut_get_FullName,
1143     WshShortcut_get_Arguments,
1144     WshShortcut_put_Arguments,
1145     WshShortcut_get_Description,
1146     WshShortcut_put_Description,
1147     WshShortcut_get_Hotkey,
1148     WshShortcut_put_Hotkey,
1149     WshShortcut_get_IconLocation,
1150     WshShortcut_put_IconLocation,
1151     WshShortcut_put_RelativePath,
1152     WshShortcut_get_TargetPath,
1153     WshShortcut_put_TargetPath,
1154     WshShortcut_get_WindowStyle,
1155     WshShortcut_put_WindowStyle,
1156     WshShortcut_get_WorkingDirectory,
1157     WshShortcut_put_WorkingDirectory,
1158     WshShortcut_Load,
1159     WshShortcut_Save
1160 };
1161
1162 static HRESULT WshShortcut_Create(const WCHAR *path, IDispatch **shortcut)
1163 {
1164     WshShortcut *object;
1165     HRESULT hr;
1166
1167     *shortcut = NULL;
1168
1169     if (!(object = calloc(1, sizeof(*object))))
1170         return E_OUTOFMEMORY;
1171
1172     object->IWshShortcut_iface.lpVtbl = &WshShortcutVtbl;
1173     object->ref = 1;
1174
1175     hr = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, (void **)&object->link);
1176     if (FAILED(hr))
1177     {
1178         free(object);
1179         return hr;
1180     }
1181
1182     object->path_link = wcsdup(path);
1183     if (!object->path_link)
1184     {
1185         IShellLinkW_Release(object->link);
1186         free(object);
1187         return E_OUTOFMEMORY;
1188     }
1189
1190     init_classinfo(&IID_IWshShortcut, (IUnknown *)&object->IWshShortcut_iface, &object->classinfo);
1191     *shortcut = (IDispatch *)&object->IWshShortcut_iface;
1192
1193     return S_OK;
1194 }
1195
1196 static HRESULT WINAPI WshShell3_QueryInterface(IWshShell3 *iface, REFIID riid, void **ppv)
1197 {
1198     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1199
1200     *ppv = NULL;
1201
1202     if (IsEqualGUID(riid, &IID_IDispatch) ||
1203         IsEqualGUID(riid, &IID_IWshShell3) ||
1204         IsEqualGUID(riid, &IID_IWshShell2) ||
1205         IsEqualGUID(riid, &IID_IWshShell) ||
1206         IsEqualGUID(riid, &IID_IUnknown))
1207     {
1208         *ppv = iface;
1209     }
1210     else if (IsEqualGUID(riid, &IID_IDispatchEx))
1211     {
1212         return E_NOINTERFACE;
1213     }
1214     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
1215     {
1216         *ppv = &WshShell3.classinfo.IProvideClassInfo_iface;
1217     }
1218     else
1219     {
1220         WARN("unknown iface %s\n", debugstr_guid(riid));
1221         return E_NOINTERFACE;
1222     }
1223
1224     IUnknown_AddRef((IUnknown *)*ppv);
1225     return S_OK;
1226 }
1227
1228 static ULONG WINAPI WshShell3_AddRef(IWshShell3 *iface)
1229 {
1230     TRACE("()\n");
1231     return 2;
1232 }
1233
1234 static ULONG WINAPI WshShell3_Release(IWshShell3 *iface)
1235 {
1236     TRACE("()\n");
1237     return 2;
1238 }
1239
1240 static HRESULT WINAPI WshShell3_GetTypeInfoCount(IWshShell3 *iface, UINT *pctinfo)
1241 {
1242     TRACE("(%p)\n", pctinfo);
1243     *pctinfo = 1;
1244     return S_OK;
1245 }
1246
1247 static HRESULT WINAPI WshShell3_GetTypeInfo(IWshShell3 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1248 {
1249     TRACE("%u, %lx, %p.\n", iTInfo, lcid, ppTInfo);
1250
1251     return get_typeinfo(IWshShell3_tid, ppTInfo);
1252 }
1253
1254 static HRESULT WINAPI WshShell3_GetIDsOfNames(IWshShell3 *iface, REFIID riid, LPOLESTR *rgszNames,
1255         UINT cNames, LCID lcid, DISPID *rgDispId)
1256 {
1257     ITypeInfo *typeinfo;
1258     HRESULT hr;
1259
1260     TRACE("%s, %p, %u, %lx, %p.\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1261
1262     hr = get_typeinfo(IWshShell3_tid, &typeinfo);
1263     if(SUCCEEDED(hr))
1264     {
1265         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1266         ITypeInfo_Release(typeinfo);
1267     }
1268
1269     return hr;
1270 }
1271
1272 static HRESULT WINAPI WshShell3_Invoke(IWshShell3 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
1273         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1274 {
1275     ITypeInfo *typeinfo;
1276     HRESULT hr;
1277
1278     TRACE("%ld, %s, %lx, %d, %p, %p, %p, %p.\n", dispIdMember, debugstr_guid(riid),
1279           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1280
1281     hr = get_typeinfo(IWshShell3_tid, &typeinfo);
1282     if(SUCCEEDED(hr))
1283     {
1284         hr = ITypeInfo_Invoke(typeinfo, &WshShell3.IWshShell3_iface, dispIdMember, wFlags,
1285                 pDispParams, pVarResult, pExcepInfo, puArgErr);
1286         ITypeInfo_Release(typeinfo);
1287     }
1288
1289     return hr;
1290 }
1291
1292 static HRESULT WINAPI WshShell3_get_SpecialFolders(IWshShell3 *iface, IWshCollection **folders)
1293 {
1294     TRACE("(%p)\n", folders);
1295     return WshCollection_Create(folders);
1296 }
1297
1298 static HRESULT WINAPI WshShell3_get_Environment(IWshShell3 *iface, VARIANT *type, IWshEnvironment **env)
1299 {
1300     FIXME("(%s %p): semi-stub\n", debugstr_variant(type), env);
1301     return WshEnvironment_Create(env);
1302 }
1303
1304 static inline BOOL is_optional_argument(const VARIANT *arg)
1305 {
1306     return V_VT(arg) == VT_ERROR && V_ERROR(arg) == DISP_E_PARAMNOTFOUND;
1307 }
1308
1309 static WCHAR *split_command( BSTR cmd, WCHAR **params )
1310 {
1311     WCHAR *ret, *ptr;
1312     BOOL in_quotes = FALSE;
1313
1314     if (!(ret = malloc((lstrlenW(cmd) + 1) * sizeof(WCHAR)))) return NULL;
1315     lstrcpyW( ret, cmd );
1316
1317     *params = NULL;
1318     for (ptr = ret; *ptr; ptr++)
1319     {
1320         if (*ptr == '"') in_quotes = !in_quotes;
1321         else if (*ptr == ' ' && !in_quotes)
1322         {
1323             *ptr = 0;
1324             *params = ptr + 1;
1325             break;
1326         }
1327     }
1328
1329     return ret;
1330 }
1331
1332 static HRESULT WINAPI WshShell3_Run(IWshShell3 *iface, BSTR cmd, VARIANT *style, VARIANT *wait, int *exit_code)
1333 {
1334     SHELLEXECUTEINFOW info;
1335     int waitforprocess, show;
1336     WCHAR *file, *params;
1337     VARIANT v;
1338     HRESULT hr;
1339     BOOL ret;
1340
1341     TRACE("(%s %s %s %p)\n", debugstr_w(cmd), debugstr_variant(style), debugstr_variant(wait), exit_code);
1342
1343     if (!style || !wait || !exit_code)
1344         return E_POINTER;
1345
1346     if (is_optional_argument(style))
1347         show = SW_SHOWNORMAL;
1348     else {
1349         VariantInit(&v);
1350         hr = VariantChangeType(&v, style, 0, VT_I4);
1351         if (FAILED(hr))
1352             return hr;
1353
1354         show = V_I4(&v);
1355     }
1356
1357     if (is_optional_argument(wait))
1358         waitforprocess = 0;
1359     else {
1360         VariantInit(&v);
1361         hr = VariantChangeType(&v, wait, 0, VT_I4);
1362         if (FAILED(hr))
1363             return hr;
1364
1365         waitforprocess = V_I4(&v);
1366     }
1367
1368     if (!(file = split_command(cmd, &params))) return E_OUTOFMEMORY;
1369
1370     memset(&info, 0, sizeof(info));
1371     info.cbSize = sizeof(info);
1372     info.fMask = waitforprocess ? SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS : SEE_MASK_DEFAULT;
1373     info.lpFile = file;
1374     info.lpParameters = params;
1375     info.nShow = show;
1376
1377     ret = ShellExecuteExW(&info);
1378     free(file);
1379     if (!ret)
1380     {
1381         TRACE("ShellExecute failed, %ld\n", GetLastError());
1382         return HRESULT_FROM_WIN32(GetLastError());
1383     }
1384     else
1385     {
1386         if (waitforprocess)
1387         {
1388             DWORD code;
1389             WaitForSingleObject(info.hProcess, INFINITE);
1390             GetExitCodeProcess(info.hProcess, &code);
1391             CloseHandle(info.hProcess);
1392             *exit_code = code;
1393         }
1394         else
1395             *exit_code = 0;
1396
1397         return S_OK;
1398     }
1399 }
1400
1401 struct popup_thread_param
1402 {
1403     WCHAR *text;
1404     VARIANT title;
1405     VARIANT type;
1406     INT button;
1407 };
1408
1409 static DWORD WINAPI popup_thread_proc(void *arg)
1410 {
1411     struct popup_thread_param *param = (struct popup_thread_param *)arg;
1412
1413     param->button = MessageBoxW(NULL, param->text, is_optional_argument(&param->title) ?
1414             L"Windows Script Host" : V_BSTR(&param->title), V_I4(&param->type));
1415     return 0;
1416 }
1417
1418 static HRESULT WINAPI WshShell3_Popup(IWshShell3 *iface, BSTR text, VARIANT *seconds_to_wait, VARIANT *title,
1419         VARIANT *type, int *button)
1420 {
1421     struct popup_thread_param param;
1422     DWORD tid, status;
1423     VARIANT timeout;
1424     HANDLE hthread;
1425     HRESULT hr;
1426
1427     TRACE("(%s %s %s %s %p)\n", debugstr_w(text), debugstr_variant(seconds_to_wait), debugstr_variant(title),
1428         debugstr_variant(type), button);
1429
1430     if (!seconds_to_wait || !title || !type || !button)
1431         return E_POINTER;
1432
1433     VariantInit(&timeout);
1434     if (!is_optional_argument(seconds_to_wait))
1435     {
1436         hr = VariantChangeType(&timeout, seconds_to_wait, 0, VT_I4);
1437         if (FAILED(hr))
1438             return hr;
1439     }
1440
1441     VariantInit(&param.type);
1442     if (!is_optional_argument(type))
1443     {
1444         hr = VariantChangeType(&param.type, type, 0, VT_I4);
1445         if (FAILED(hr))
1446             return hr;
1447     }
1448
1449     if (is_optional_argument(title))
1450         param.title = *title;
1451     else
1452     {
1453         VariantInit(&param.title);
1454         hr = VariantChangeType(&param.title, title, 0, VT_BSTR);
1455         if (FAILED(hr))
1456             return hr;
1457     }
1458
1459     param.text = text;
1460     param.button = -1;
1461     hthread = CreateThread(NULL, 0, popup_thread_proc, &param, 0, &tid);
1462     status = MsgWaitForMultipleObjects(1, &hthread, FALSE, V_I4(&timeout) ? V_I4(&timeout) * 1000: INFINITE, 0);
1463     if (status == WAIT_TIMEOUT)
1464     {
1465         PostThreadMessageW(tid, WM_QUIT, 0, 0);
1466         MsgWaitForMultipleObjects(1, &hthread, FALSE, INFINITE, 0);
1467         param.button = -1;
1468     }
1469     *button = param.button;
1470
1471     VariantClear(&param.title);
1472     CloseHandle(hthread);
1473
1474     return S_OK;
1475 }
1476
1477 static HRESULT WINAPI WshShell3_CreateShortcut(IWshShell3 *iface, BSTR PathLink, IDispatch** Shortcut)
1478 {
1479     TRACE("(%s %p)\n", debugstr_w(PathLink), Shortcut);
1480     return WshShortcut_Create(PathLink, Shortcut);
1481 }
1482
1483 static HRESULT WINAPI WshShell3_ExpandEnvironmentStrings(IWshShell3 *iface, BSTR Src, BSTR* Dst)
1484 {
1485     DWORD ret;
1486
1487     TRACE("(%s %p)\n", debugstr_w(Src), Dst);
1488
1489     if (!Src || !Dst) return E_POINTER;
1490
1491     ret = ExpandEnvironmentStringsW(Src, NULL, 0);
1492     *Dst = SysAllocStringLen(NULL, ret);
1493     if (!*Dst) return E_OUTOFMEMORY;
1494
1495     if (ExpandEnvironmentStringsW(Src, *Dst, ret))
1496         return S_OK;
1497     else
1498     {
1499         SysFreeString(*Dst);
1500         *Dst = NULL;
1501         return HRESULT_FROM_WIN32(GetLastError());
1502     }
1503 }
1504
1505 static HKEY get_root_key(const WCHAR *path)
1506 {
1507     static const struct {
1508         const WCHAR full[20];
1509         const WCHAR abbrev[5];
1510         HKEY hkey;
1511     } rootkeys[] = {
1512         { L"HKEY_CURRENT_USER",   L"HKCU", HKEY_CURRENT_USER },
1513         { L"HKEY_LOCAL_MACHINE",  L"HKLM", HKEY_LOCAL_MACHINE },
1514         { L"HKEY_CLASSES_ROOT",   L"HKCR", HKEY_CLASSES_ROOT },
1515         { L"HKEY_USERS",          {0},     HKEY_USERS },
1516         { L"HKEY_CURRENT_CONFIG", {0},     HKEY_CURRENT_CONFIG }
1517     };
1518     int i;
1519
1520     for (i = 0; i < ARRAY_SIZE(rootkeys); i++) {
1521         if (!wcsncmp(path, rootkeys[i].full, lstrlenW(rootkeys[i].full)))
1522             return rootkeys[i].hkey;
1523         if (rootkeys[i].abbrev[0] && !wcsncmp(path, rootkeys[i].abbrev, lstrlenW(rootkeys[i].abbrev)))
1524             return rootkeys[i].hkey;
1525     }
1526
1527     return NULL;
1528 }
1529
1530 /* Caller is responsible to free 'subkey' if 'value' is not NULL */
1531 static HRESULT split_reg_path(const WCHAR *path, WCHAR **subkey, WCHAR **value)
1532 {
1533     *value = NULL;
1534
1535     /* at least one separator should be present */
1536     *subkey = wcschr(path, '\\');
1537     if (!*subkey)
1538         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
1539
1540     /* default value or not */
1541     if ((*subkey)[lstrlenW(*subkey)-1] == '\\') {
1542         (*subkey)++;
1543         *value = NULL;
1544     }
1545     else {
1546         *value = wcsrchr(*subkey, '\\');
1547         if (*value - *subkey > 1) {
1548             unsigned int len = *value - *subkey - 1;
1549             WCHAR *ret;
1550
1551             ret = malloc((len + 1)*sizeof(WCHAR));
1552             if (!ret)
1553                 return E_OUTOFMEMORY;
1554
1555             memcpy(ret, *subkey + 1, len*sizeof(WCHAR));
1556             ret[len] = 0;
1557             *subkey = ret;
1558         }
1559         (*value)++;
1560     }
1561
1562     return S_OK;
1563 }
1564
1565 static HRESULT WINAPI WshShell3_RegRead(IWshShell3 *iface, BSTR name, VARIANT *value)
1566 {
1567     DWORD type, datalen, ret;
1568     WCHAR *subkey, *val;
1569     HRESULT hr;
1570     HKEY root;
1571
1572     TRACE("(%s %p)\n", debugstr_w(name), value);
1573
1574     if (!name || !value)
1575         return E_POINTER;
1576
1577     root = get_root_key(name);
1578     if (!root)
1579         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
1580
1581     hr = split_reg_path(name, &subkey, &val);
1582     if (FAILED(hr))
1583         return hr;
1584
1585     type = REG_NONE;
1586     datalen = 0;
1587     ret = RegGetValueW(root, subkey, val, RRF_RT_ANY, &type, NULL, &datalen);
1588     if (ret == ERROR_SUCCESS) {
1589         void *data;
1590
1591         data = malloc(datalen);
1592         if (!data) {
1593             hr = E_OUTOFMEMORY;
1594             goto fail;
1595         }
1596
1597         ret = RegGetValueW(root, subkey, val, RRF_RT_ANY, &type, data, &datalen);
1598         if (ret) {
1599             free(data);
1600             hr = HRESULT_FROM_WIN32(ret);
1601             goto fail;
1602         }
1603
1604         switch (type) {
1605         case REG_SZ:
1606         case REG_EXPAND_SZ:
1607             V_VT(value) = VT_BSTR;
1608             V_BSTR(value) = SysAllocString((WCHAR*)data);
1609             if (!V_BSTR(value))
1610                 hr = E_OUTOFMEMORY;
1611             break;
1612         case REG_DWORD:
1613             V_VT(value) = VT_I4;
1614             V_I4(value) = *(DWORD*)data;
1615             break;
1616         case REG_BINARY:
1617         {
1618             BYTE *ptr = (BYTE*)data;
1619             SAFEARRAYBOUND bound;
1620             unsigned int i;
1621             SAFEARRAY *sa;
1622             VARIANT *v;
1623
1624             bound.lLbound = 0;
1625             bound.cElements = datalen;
1626             sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
1627             if (!sa)
1628                 break;
1629
1630             hr = SafeArrayAccessData(sa, (void**)&v);
1631             if (FAILED(hr)) {
1632                 SafeArrayDestroy(sa);
1633                 break;
1634             }
1635
1636             for (i = 0; i < datalen; i++) {
1637                 V_VT(&v[i]) = VT_UI1;
1638                 V_UI1(&v[i]) = ptr[i];
1639             }
1640             SafeArrayUnaccessData(sa);
1641
1642             V_VT(value) = VT_ARRAY|VT_VARIANT;
1643             V_ARRAY(value) = sa;
1644             break;
1645         }
1646         case REG_MULTI_SZ:
1647         {
1648             WCHAR *ptr = (WCHAR*)data;
1649             SAFEARRAYBOUND bound;
1650             SAFEARRAY *sa;
1651             VARIANT *v;
1652
1653             /* get element count first */
1654             bound.lLbound = 0;
1655             bound.cElements = 0;
1656             while (*ptr) {
1657                 bound.cElements++;
1658                 ptr += lstrlenW(ptr)+1;
1659             }
1660
1661             sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
1662             if (!sa)
1663                 break;
1664
1665             hr = SafeArrayAccessData(sa, (void**)&v);
1666             if (FAILED(hr)) {
1667                 SafeArrayDestroy(sa);
1668                 break;
1669             }
1670
1671             ptr = (WCHAR*)data;
1672             while (*ptr) {
1673                 V_VT(v) = VT_BSTR;
1674                 V_BSTR(v) = SysAllocString(ptr);
1675                 ptr += lstrlenW(ptr)+1;
1676                 v++;
1677             }
1678
1679             SafeArrayUnaccessData(sa);
1680             V_VT(value) = VT_ARRAY|VT_VARIANT;
1681             V_ARRAY(value) = sa;
1682             break;
1683         }
1684         default:
1685             FIXME("value type %ld not supported\n", type);
1686             hr = E_FAIL;
1687         };
1688
1689         free(data);
1690         if (FAILED(hr))
1691             VariantInit(value);
1692     }
1693     else
1694         hr = HRESULT_FROM_WIN32(ret);
1695
1696 fail:
1697     if (val)
1698         free(subkey);
1699     return hr;
1700 }
1701
1702 static HRESULT WINAPI WshShell3_RegWrite(IWshShell3 *iface, BSTR name, VARIANT *value, VARIANT *type)
1703 {
1704     DWORD regtype, data_len;
1705     WCHAR *subkey, *val;
1706     const BYTE *data;
1707     HRESULT hr;
1708     HKEY root;
1709     VARIANT v;
1710     LONG ret;
1711
1712     TRACE("(%s %s %s)\n", debugstr_w(name), debugstr_variant(value), debugstr_variant(type));
1713
1714     if (!name || !value || !type)
1715         return E_POINTER;
1716
1717     root = get_root_key(name);
1718     if (!root)
1719         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
1720
1721     /* value type */
1722     if (is_optional_argument(type))
1723         regtype = REG_SZ;
1724     else {
1725         if (V_VT(type) != VT_BSTR)
1726             return E_INVALIDARG;
1727
1728         if (!wcscmp(V_BSTR(type), L"REG_SZ"))
1729             regtype = REG_SZ;
1730         else if (!wcscmp(V_BSTR(type), L"REG_DWORD"))
1731             regtype = REG_DWORD;
1732         else if (!wcscmp(V_BSTR(type), L"REG_EXPAND_SZ"))
1733             regtype = REG_EXPAND_SZ;
1734         else if (!wcscmp(V_BSTR(type), L"REG_BINARY"))
1735             regtype = REG_BINARY;
1736         else {
1737             FIXME("unrecognized value type %s\n", debugstr_w(V_BSTR(type)));
1738             return E_FAIL;
1739         }
1740     }
1741
1742     /* it's always a string or a DWORD */
1743     VariantInit(&v);
1744     switch (regtype)
1745     {
1746     case REG_SZ:
1747     case REG_EXPAND_SZ:
1748         hr = VariantChangeType(&v, value, 0, VT_BSTR);
1749         if (hr == S_OK) {
1750             data = (BYTE*)V_BSTR(&v);
1751             data_len = SysStringByteLen(V_BSTR(&v)) + sizeof(WCHAR);
1752         }
1753         break;
1754     case REG_DWORD:
1755     case REG_BINARY:
1756         hr = VariantChangeType(&v, value, 0, VT_I4);
1757         data = (BYTE*)&V_I4(&v);
1758         data_len = sizeof(DWORD);
1759         break;
1760     default:
1761         FIXME("unexpected regtype %ld\n", regtype);
1762         return E_FAIL;
1763     };
1764
1765     if (FAILED(hr)) {
1766         FIXME("failed to convert value, regtype %ld, %#lx.\n", regtype, hr);
1767         return hr;
1768     }
1769
1770     hr = split_reg_path(name, &subkey, &val);
1771     if (FAILED(hr))
1772         goto fail;
1773
1774     ret = RegSetKeyValueW(root, subkey, val, regtype, data, data_len);
1775     if (ret)
1776         hr = HRESULT_FROM_WIN32(ret);
1777
1778 fail:
1779     VariantClear(&v);
1780     if (val)
1781         free(subkey);
1782     return hr;
1783 }
1784
1785 static HRESULT WINAPI WshShell3_RegDelete(IWshShell3 *iface, BSTR Name)
1786 {
1787     FIXME("(%s): stub\n", debugstr_w(Name));
1788     return E_NOTIMPL;
1789 }
1790
1791 static HRESULT WINAPI WshShell3_LogEvent(IWshShell3 *iface, VARIANT *Type, BSTR Message, BSTR Target, VARIANT_BOOL *out_Success)
1792 {
1793     FIXME("(%s %s %s %p): stub\n", debugstr_variant(Type), debugstr_w(Message), debugstr_w(Target), out_Success);
1794     return E_NOTIMPL;
1795 }
1796
1797 static HRESULT WINAPI WshShell3_AppActivate(IWshShell3 *iface, VARIANT *App, VARIANT *Wait, VARIANT_BOOL *out_Success)
1798 {
1799     FIXME("(%s %s %p): stub\n", debugstr_variant(App), debugstr_variant(Wait), out_Success);
1800     return E_NOTIMPL;
1801 }
1802
1803 static HRESULT WINAPI WshShell3_SendKeys(IWshShell3 *iface, BSTR Keys, VARIANT *Wait)
1804 {
1805     FIXME("(%s %p): stub\n", debugstr_w(Keys), Wait);
1806     return E_NOTIMPL;
1807 }
1808
1809 static HRESULT WINAPI WshShell3_Exec(IWshShell3 *iface, BSTR command, IWshExec **ret)
1810 {
1811     BSTR expandedcmd;
1812     HRESULT hr;
1813
1814     TRACE("(%s %p)\n", debugstr_w(command), ret);
1815
1816     if (!ret)
1817         return E_POINTER;
1818
1819     if (!command)
1820         return DISP_E_EXCEPTION;
1821
1822     hr = WshShell3_ExpandEnvironmentStrings(iface, command, &expandedcmd);
1823     if (FAILED(hr))
1824         return hr;
1825
1826     hr = WshExec_create(expandedcmd, ret);
1827     SysFreeString(expandedcmd);
1828     return hr;
1829 }
1830
1831 static HRESULT WINAPI WshShell3_get_CurrentDirectory(IWshShell3 *iface, BSTR *dir)
1832 {
1833     DWORD ret;
1834
1835     TRACE("(%p)\n", dir);
1836
1837     ret = GetCurrentDirectoryW(0, NULL);
1838     if (!ret)
1839         return HRESULT_FROM_WIN32(GetLastError());
1840
1841     *dir = SysAllocStringLen(NULL, ret-1);
1842     if (!*dir)
1843         return E_OUTOFMEMORY;
1844
1845     ret = GetCurrentDirectoryW(ret, *dir);
1846     if (!ret) {
1847         SysFreeString(*dir);
1848         *dir = NULL;
1849         return HRESULT_FROM_WIN32(GetLastError());
1850     }
1851
1852     return S_OK;
1853 }
1854
1855 static HRESULT WINAPI WshShell3_put_CurrentDirectory(IWshShell3 *iface, BSTR dir)
1856 {
1857     TRACE("(%s)\n", debugstr_w(dir));
1858
1859     if (!dir)
1860         return E_INVALIDARG;
1861
1862     if (!SetCurrentDirectoryW(dir))
1863         return HRESULT_FROM_WIN32(GetLastError());
1864
1865     return S_OK;
1866 }
1867
1868 static const IWshShell3Vtbl WshShell3Vtbl = {
1869     WshShell3_QueryInterface,
1870     WshShell3_AddRef,
1871     WshShell3_Release,
1872     WshShell3_GetTypeInfoCount,
1873     WshShell3_GetTypeInfo,
1874     WshShell3_GetIDsOfNames,
1875     WshShell3_Invoke,
1876     WshShell3_get_SpecialFolders,
1877     WshShell3_get_Environment,
1878     WshShell3_Run,
1879     WshShell3_Popup,
1880     WshShell3_CreateShortcut,
1881     WshShell3_ExpandEnvironmentStrings,
1882     WshShell3_RegRead,
1883     WshShell3_RegWrite,
1884     WshShell3_RegDelete,
1885     WshShell3_LogEvent,
1886     WshShell3_AppActivate,
1887     WshShell3_SendKeys,
1888     WshShell3_Exec,
1889     WshShell3_get_CurrentDirectory,
1890     WshShell3_put_CurrentDirectory
1891 };
1892
1893 HRESULT WINAPI WshShellFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1894 {
1895     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
1896
1897     WshShell3.IWshShell3_iface.lpVtbl = &WshShell3Vtbl;
1898     init_classinfo(&IID_IWshShell3, (IUnknown *)&WshShell3.IWshShell3_iface, &WshShell3.classinfo);
1899     return IWshShell3_QueryInterface(&WshShell3.IWshShell3_iface, riid, ppv);
1900 }