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 HRESULT get_env_var(const WCHAR *name, BSTR *value)
 542 {
 543     DWORD len;
 544
 545     len = GetEnvironmentVariableW(name, NULL, 0);
 546     if (len)
 547     {
 548         *value = SysAllocStringLen(NULL, len - 1);
 549         if (*value)
 550             GetEnvironmentVariableW(name, *value, len);
 551     }
 552     else
 553         *value = SysAllocStringLen(NULL, 0);
 554
 555     return *value ? S_OK : E_OUTOFMEMORY;
 556 }
 557
 558 static HRESULT WINAPI WshEnvironment_get_Item(IWshEnvironment *iface, BSTR name, BSTR *value)
 559 {
 560     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 561
 562     TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), value);
 563
 564     if (!value)
 565         return E_POINTER;
 566
 567     return get_env_var(name, value);
 568 }
 569
 570 static HRESULT WINAPI WshEnvironment_put_Item(IWshEnvironment *iface, BSTR name, BSTR value)
 571 {
 572     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 573     FIXME("(%p)->(%s %s): stub\n", This, debugstr_w(name), debugstr_w(value));
 574     return E_NOTIMPL;
 575 }
 576
 577 static HRESULT WINAPI WshEnvironment_Count(IWshEnvironment *iface, LONG *count)
 578 {
 579     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 580     FIXME("(%p)->(%p): stub\n", This, count);
 581     return E_NOTIMPL;
 582 }
 583
 584 static HRESULT WINAPI WshEnvironment_get_length(IWshEnvironment *iface, LONG *len)
 585 {
 586     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 587     FIXME("(%p)->(%p): stub\n", This, len);
 588     return E_NOTIMPL;
 589 }
 590
 591 static HRESULT WINAPI WshEnvironment__NewEnum(IWshEnvironment *iface, IUnknown **penum)
 592 {
 593     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 594     FIXME("(%p)->(%p): stub\n", This, penum);
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI WshEnvironment_Remove(IWshEnvironment *iface, BSTR name)
 599 {
 600     WshEnvironment *This = impl_from_IWshEnvironment(iface);
 601     FIXME("(%p)->(%s): stub\n", This, debugstr_w(name));
 602     return E_NOTIMPL;
 603 }
 604
 605 static const IWshEnvironmentVtbl WshEnvironmentVtbl = {
 606     WshEnvironment_QueryInterface,
 607     WshEnvironment_AddRef,
 608     WshEnvironment_Release,
 609     WshEnvironment_GetTypeInfoCount,
 610     WshEnvironment_GetTypeInfo,
 611     WshEnvironment_GetIDsOfNames,
 612     WshEnvironment_Invoke,
 613     WshEnvironment_get_Item,
 614     WshEnvironment_put_Item,
 615     WshEnvironment_Count,
 616     WshEnvironment_get_length,
 617     WshEnvironment__NewEnum,
 618     WshEnvironment_Remove
 619 };
 620
 621 static HRESULT WshEnvironment_Create(IWshEnvironment **env)
 622 {
 623     WshEnvironment *object;
 624
 625     if (!(object = calloc(1, sizeof(*object))))
 626         return E_OUTOFMEMORY;
 627
 628     object->IWshEnvironment_iface.lpVtbl = &WshEnvironmentVtbl;
 629     object->ref = 1;
 630
 631     init_classinfo(&IID_IWshEnvironment, (IUnknown *)&object->IWshEnvironment_iface, &object->classinfo);
 632     *env = &object->IWshEnvironment_iface;
 633
 634     return S_OK;
 635 }
 636
 637 static HRESULT WINAPI WshCollection_QueryInterface(IWshCollection *iface, REFIID riid, void **ppv)
 638 {
 639     WshCollection *This = impl_from_IWshCollection(iface);
 640
 641     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 642
 643     if (IsEqualGUID(riid, &IID_IUnknown)  ||
 644         IsEqualGUID(riid, &IID_IDispatch) ||
 645         IsEqualGUID(riid, &IID_IWshCollection))
 646     {
 647         *ppv = iface;
 648     }
 649     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
 650     {
 651         *ppv = &This->classinfo.IProvideClassInfo_iface;
 652     }
 653     else {
 654         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 655         *ppv = NULL;
 656         return E_NOINTERFACE;
 657     }
 658
 659     IUnknown_AddRef((IUnknown*)*ppv);
 660     return S_OK;
 661 }
 662
 663 static ULONG WINAPI WshCollection_AddRef(IWshCollection *iface)
 664 {
 665     WshCollection *collection = impl_from_IWshCollection(iface);
 666     LONG ref = InterlockedIncrement(&collection->ref);
 667
 668     TRACE("%p, refcount %ld.\n", iface, ref);
 669
 670     return ref;
 671 }
 672
 673 static ULONG WINAPI WshCollection_Release(IWshCollection *iface)
 674 {
 675     WshCollection *collection = impl_from_IWshCollection(iface);
 676     LONG ref = InterlockedDecrement(&collection->ref);
 677     TRACE("%p, refcount %ld.\n", iface, ref);
 678
 679     if (!ref)
 680         free(collection);
 681
 682     return ref;
 683 }
 684
 685 static HRESULT WINAPI WshCollection_GetTypeInfoCount(IWshCollection *iface, UINT *pctinfo)
 686 {
 687     WshCollection *This = impl_from_IWshCollection(iface);
 688     TRACE("(%p)->(%p)\n", This, pctinfo);
 689     *pctinfo = 1;
 690     return S_OK;
 691 }
 692
 693 static HRESULT WINAPI WshCollection_GetTypeInfo(IWshCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 694 {
 695     TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 696
 697     return get_typeinfo(IWshCollection_tid, ppTInfo);
 698 }
 699
 700 static HRESULT WINAPI WshCollection_GetIDsOfNames(IWshCollection *iface, REFIID riid, LPOLESTR *rgszNames,
 701         UINT cNames, LCID lcid, DISPID *rgDispId)
 702 {
 703     ITypeInfo *typeinfo;
 704     HRESULT hr;
 705
 706     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 707
 708     hr = get_typeinfo(IWshCollection_tid, &typeinfo);
 709     if(SUCCEEDED(hr))
 710     {
 711         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 712         ITypeInfo_Release(typeinfo);
 713     }
 714
 715     return hr;
 716 }
 717
 718 static HRESULT WINAPI WshCollection_Invoke(IWshCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 719         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 720 {
 721     ITypeInfo *typeinfo;
 722     HRESULT hr;
 723
 724     TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
 725           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 726
 727     hr = get_typeinfo(IWshCollection_tid, &typeinfo);
 728     if(SUCCEEDED(hr))
 729     {
 730         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 731         ITypeInfo_Release(typeinfo);
 732     }
 733
 734     return hr;
 735 }
 736
 737 static HRESULT WINAPI WshCollection_Item(IWshCollection *iface, VARIANT *index, VARIANT *value)
 738 {
 739     WshCollection *This = impl_from_IWshCollection(iface);
 740     PIDLIST_ABSOLUTE pidl;
 741     WCHAR pathW[MAX_PATH];
 742     int kind = 0;
 743     BSTR folder;
 744     HRESULT hr;
 745
 746     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(index), value);
 747
 748     if (V_VT(index) != VT_BSTR)
 749     {
 750         FIXME("only BSTR index supported, got %d\n", V_VT(index));
 751         return E_NOTIMPL;
 752     }
 753
 754     folder = V_BSTR(index);
 755     if (!wcsicmp(folder, L"Desktop"))
 756         kind = CSIDL_DESKTOP;
 757     else if (!wcsicmp(folder, L"AllUsersDesktop"))
 758         kind = CSIDL_COMMON_DESKTOPDIRECTORY;
 759     else if (!wcsicmp(folder, L"AllUsersPrograms"))
 760         kind = CSIDL_COMMON_PROGRAMS;
 761     else
 762     {
 763         FIXME("folder kind %s not supported\n", debugstr_w(folder));
 764         return E_NOTIMPL;
 765     }
 766
 767     hr = SHGetSpecialFolderLocation(NULL, kind, &pidl);
 768     if (hr != S_OK) return hr;
 769
 770     if (SHGetPathFromIDListW(pidl, pathW))
 771     {
 772         V_VT(value) = VT_BSTR;
 773         V_BSTR(value) = SysAllocString(pathW);
 774         hr = V_BSTR(value) ? S_OK : E_OUTOFMEMORY;
 775     }
 776     else
 777         hr = E_FAIL;
 778
 779     CoTaskMemFree(pidl);
 780
 781     return hr;
 782 }
 783
 784 static HRESULT WINAPI WshCollection_Count(IWshCollection *iface, LONG *count)
 785 {
 786     WshCollection *This = impl_from_IWshCollection(iface);
 787     FIXME("(%p)->(%p): stub\n", This, count);
 788     return E_NOTIMPL;
 789 }
 790
 791 static HRESULT WINAPI WshCollection_get_length(IWshCollection *iface, LONG *count)
 792 {
 793     WshCollection *This = impl_from_IWshCollection(iface);
 794     FIXME("(%p)->(%p): stub\n", This, count);
 795     return E_NOTIMPL;
 796 }
 797
 798 static HRESULT WINAPI WshCollection__NewEnum(IWshCollection *iface, IUnknown **Enum)
 799 {
 800     WshCollection *This = impl_from_IWshCollection(iface);
 801     FIXME("(%p)->(%p): stub\n", This, Enum);
 802     return E_NOTIMPL;
 803 }
 804
 805 static const IWshCollectionVtbl WshCollectionVtbl = {
 806     WshCollection_QueryInterface,
 807     WshCollection_AddRef,
 808     WshCollection_Release,
 809     WshCollection_GetTypeInfoCount,
 810     WshCollection_GetTypeInfo,
 811     WshCollection_GetIDsOfNames,
 812     WshCollection_Invoke,
 813     WshCollection_Item,
 814     WshCollection_Count,
 815     WshCollection_get_length,
 816     WshCollection__NewEnum
 817 };
 818
 819 static HRESULT WshCollection_Create(IWshCollection **collection)
 820 {
 821     WshCollection *object;
 822
 823     if (!(object = calloc(1, sizeof(*object))))
 824         return E_OUTOFMEMORY;
 825
 826     object->IWshCollection_iface.lpVtbl = &WshCollectionVtbl;
 827     object->ref = 1;
 828
 829     init_classinfo(&IID_IWshCollection, (IUnknown *)&object->IWshCollection_iface, &object->classinfo);
 830     *collection = &object->IWshCollection_iface;
 831
 832     return S_OK;
 833 }
 834
 835 /* IWshShortcut */
 836 static HRESULT WINAPI WshShortcut_QueryInterface(IWshShortcut *iface, REFIID riid, void **ppv)
 837 {
 838     WshShortcut *This = impl_from_IWshShortcut(iface);
 839
 840     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 841
 842     if (IsEqualGUID(riid, &IID_IUnknown)  ||
 843         IsEqualGUID(riid, &IID_IDispatch) ||
 844         IsEqualGUID(riid, &IID_IWshShortcut))
 845     {
 846         *ppv = iface;
 847     }
 848     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
 849     {
 850         *ppv = &This->classinfo.IProvideClassInfo_iface;
 851     }
 852     else {
 853         FIXME("Unknown iface %s\n", debugstr_guid(riid));
 854         *ppv = NULL;
 855         return E_NOINTERFACE;
 856     }
 857
 858     IUnknown_AddRef((IUnknown*)*ppv);
 859     return S_OK;
 860 }
 861
 862 static ULONG WINAPI WshShortcut_AddRef(IWshShortcut *iface)
 863 {
 864     WshShortcut *This = impl_from_IWshShortcut(iface);
 865     LONG ref = InterlockedIncrement(&This->ref);
 866     TRACE("%p, refcount %ld.\n", iface, ref);
 867     return ref;
 868 }
 869
 870 static ULONG WINAPI WshShortcut_Release(IWshShortcut *iface)
 871 {
 872     WshShortcut *This = impl_from_IWshShortcut(iface);
 873     LONG ref = InterlockedDecrement(&This->ref);
 874     TRACE("%p, refcount %ld.\n", iface, ref);
 875
 876     if (!ref)
 877     {
 878         IShellLinkW_Release(This->link);
 879         free(This->path_link);
 880         free(This);
 881     }
 882
 883     return ref;
 884 }
 885
 886 static HRESULT WINAPI WshShortcut_GetTypeInfoCount(IWshShortcut *iface, UINT *pctinfo)
 887 {
 888     WshShortcut *This = impl_from_IWshShortcut(iface);
 889     TRACE("(%p)->(%p)\n", This, pctinfo);
 890     *pctinfo = 1;
 891     return S_OK;
 892 }
 893
 894 static HRESULT WINAPI WshShortcut_GetTypeInfo(IWshShortcut *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 895 {
 896     TRACE("%p, %u, %lx, %p.\n", iface, iTInfo, lcid, ppTInfo);
 897
 898     return get_typeinfo(IWshShortcut_tid, ppTInfo);
 899 }
 900
 901 static HRESULT WINAPI WshShortcut_GetIDsOfNames(IWshShortcut *iface, REFIID riid, LPOLESTR *rgszNames,
 902         UINT cNames, LCID lcid, DISPID *rgDispId)
 903 {
 904     ITypeInfo *typeinfo;
 905     HRESULT hr;
 906
 907     TRACE("%p, %s, %p, %u, %lx, %p.\n", iface, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 908
 909     hr = get_typeinfo(IWshShortcut_tid, &typeinfo);
 910     if(SUCCEEDED(hr))
 911     {
 912         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 913         ITypeInfo_Release(typeinfo);
 914     }
 915
 916     return hr;
 917 }
 918
 919 static HRESULT WINAPI WshShortcut_Invoke(IWshShortcut *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 920         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 921 {
 922     ITypeInfo *typeinfo;
 923     HRESULT hr;
 924
 925     TRACE("%p, %ld, %s, %lx, %d, %p, %p, %p, %p.\n", iface, dispIdMember, debugstr_guid(riid),
 926           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 927
 928     hr = get_typeinfo(IWshShortcut_tid, &typeinfo);
 929     if(SUCCEEDED(hr))
 930     {
 931         hr = ITypeInfo_Invoke(typeinfo, iface, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 932         ITypeInfo_Release(typeinfo);
 933     }
 934
 935     return hr;
 936 }
 937
 938 static HRESULT WINAPI WshShortcut_get_FullName(IWshShortcut *iface, BSTR *name)
 939 {
 940     WshShortcut *This = impl_from_IWshShortcut(iface);
 941     FIXME("(%p)->(%p): stub\n", This, name);
 942     return E_NOTIMPL;
 943 }
 944
 945 static HRESULT WINAPI WshShortcut_get_Arguments(IWshShortcut *iface, BSTR *Arguments)
 946 {
 947     WshShortcut *This = impl_from_IWshShortcut(iface);
 948     WCHAR buffW[INFOTIPSIZE];
 949     HRESULT hr;
 950
 951     TRACE("(%p)->(%p)\n", This, Arguments);
 952
 953     if (!Arguments)
 954         return E_POINTER;
 955
 956     *Arguments = NULL;
 957
 958     hr = IShellLinkW_GetArguments(This->link, buffW, ARRAY_SIZE(buffW));
 959     if (FAILED(hr))
 960         return hr;
 961
 962     *Arguments = SysAllocString(buffW);
 963     return *Arguments ? S_OK : E_OUTOFMEMORY;
 964 }
 965
 966 static HRESULT WINAPI WshShortcut_put_Arguments(IWshShortcut *iface, BSTR Arguments)
 967 {
 968     WshShortcut *This = impl_from_IWshShortcut(iface);
 969
 970     TRACE("(%p)->(%s)\n", This, debugstr_w(Arguments));
 971
 972     return IShellLinkW_SetArguments(This->link, Arguments);
 973 }
 974
 975 static HRESULT WINAPI WshShortcut_get_Description(IWshShortcut *iface, BSTR *Description)
 976 {
 977     WshShortcut *This = impl_from_IWshShortcut(iface);
 978     FIXME("(%p)->(%p): stub\n", This, Description);
 979     return E_NOTIMPL;
 980 }
 981
 982 static HRESULT WINAPI WshShortcut_put_Description(IWshShortcut *iface, BSTR Description)
 983 {
 984     WshShortcut *This = impl_from_IWshShortcut(iface);
 985     TRACE("(%p)->(%s)\n", This, debugstr_w(Description));
 986     return IShellLinkW_SetDescription(This->link, Description);
 987 }
 988
 989 static HRESULT WINAPI WshShortcut_get_Hotkey(IWshShortcut *iface, BSTR *Hotkey)
 990 {
 991     WshShortcut *This = impl_from_IWshShortcut(iface);
 992     FIXME("(%p)->(%p): stub\n", This, Hotkey);
 993     return E_NOTIMPL;
 994 }
 995
 996 static HRESULT WINAPI WshShortcut_put_Hotkey(IWshShortcut *iface, BSTR Hotkey)
 997 {
 998     WshShortcut *This = impl_from_IWshShortcut(iface);
 999     FIXME("(%p)->(%s): stub\n", This, debugstr_w(Hotkey));
1000     return E_NOTIMPL;
1001 }
1002
1003 static HRESULT WINAPI WshShortcut_get_IconLocation(IWshShortcut *iface, BSTR *IconPath)
1004 {
1005     WshShortcut *This = impl_from_IWshShortcut(iface);
1006     WCHAR buffW[MAX_PATH], pathW[MAX_PATH];
1007     INT icon = 0;
1008     HRESULT hr;
1009
1010     TRACE("(%p)->(%p)\n", This, IconPath);
1011
1012     if (!IconPath)
1013         return E_POINTER;
1014
1015     hr = IShellLinkW_GetIconLocation(This->link, buffW, ARRAY_SIZE(buffW), &icon);
1016     if (FAILED(hr)) return hr;
1017
1018     swprintf(pathW, ARRAY_SIZE(pathW), L"%s, %d", buffW, icon);
1019     *IconPath = SysAllocString(pathW);
1020     if (!*IconPath) return E_OUTOFMEMORY;
1021
1022     return S_OK;
1023 }
1024
1025 static HRESULT WINAPI WshShortcut_put_IconLocation(IWshShortcut *iface, BSTR IconPath)
1026 {
1027     WshShortcut *This = impl_from_IWshShortcut(iface);
1028     HRESULT hr;
1029     WCHAR *ptr;
1030     BSTR path;
1031     INT icon;
1032
1033     TRACE("(%p)->(%s)\n", This, debugstr_w(IconPath));
1034
1035     /* scan for icon id */
1036     ptr = wcsrchr(IconPath, ',');
1037     if (!ptr)
1038     {
1039         WARN("icon index not found\n");
1040         return E_FAIL;
1041     }
1042
1043     path = SysAllocStringLen(IconPath, ptr-IconPath);
1044
1045     /* skip spaces if any */
1046     while (iswspace(*++ptr))
1047         ;
1048
1049     icon = wcstol(ptr, NULL, 10);
1050
1051     hr = IShellLinkW_SetIconLocation(This->link, path, icon);
1052     SysFreeString(path);
1053
1054     return hr;
1055 }
1056
1057 static HRESULT WINAPI WshShortcut_put_RelativePath(IWshShortcut *iface, BSTR rhs)
1058 {
1059     WshShortcut *This = impl_from_IWshShortcut(iface);
1060     FIXME("(%p)->(%s): stub\n", This, debugstr_w(rhs));
1061     return E_NOTIMPL;
1062 }
1063
1064 static HRESULT WINAPI WshShortcut_get_TargetPath(IWshShortcut *iface, BSTR *Path)
1065 {
1066     WshShortcut *This = impl_from_IWshShortcut(iface);
1067     FIXME("(%p)->(%p): stub\n", This, Path);
1068     return E_NOTIMPL;
1069 }
1070
1071 static HRESULT WINAPI WshShortcut_put_TargetPath(IWshShortcut *iface, BSTR Path)
1072 {
1073     WshShortcut *This = impl_from_IWshShortcut(iface);
1074     TRACE("(%p)->(%s)\n", This, debugstr_w(Path));
1075     return IShellLinkW_SetPath(This->link, Path);
1076 }
1077
1078 static HRESULT WINAPI WshShortcut_get_WindowStyle(IWshShortcut *iface, int *ShowCmd)
1079 {
1080     WshShortcut *This = impl_from_IWshShortcut(iface);
1081     TRACE("(%p)->(%p)\n", This, ShowCmd);
1082     return IShellLinkW_GetShowCmd(This->link, ShowCmd);
1083 }
1084
1085 static HRESULT WINAPI WshShortcut_put_WindowStyle(IWshShortcut *iface, int ShowCmd)
1086 {
1087     WshShortcut *This = impl_from_IWshShortcut(iface);
1088     TRACE("(%p)->(%d)\n", This, ShowCmd);
1089     return IShellLinkW_SetShowCmd(This->link, ShowCmd);
1090 }
1091
1092 static HRESULT WINAPI WshShortcut_get_WorkingDirectory(IWshShortcut *iface, BSTR *WorkingDirectory)
1093 {
1094     WshShortcut *This = impl_from_IWshShortcut(iface);
1095     WCHAR buffW[MAX_PATH];
1096     HRESULT hr;
1097
1098     TRACE("(%p)->(%p)\n", This, WorkingDirectory);
1099
1100     if (!WorkingDirectory)
1101         return E_POINTER;
1102
1103     *WorkingDirectory = NULL;
1104     hr = IShellLinkW_GetWorkingDirectory(This->link, buffW, ARRAY_SIZE(buffW));
1105     if (FAILED(hr)) return hr;
1106
1107     *WorkingDirectory = SysAllocString(buffW);
1108     return *WorkingDirectory ? S_OK : E_OUTOFMEMORY;
1109 }
1110
1111 static HRESULT WINAPI WshShortcut_put_WorkingDirectory(IWshShortcut *iface, BSTR WorkingDirectory)
1112 {
1113     WshShortcut *This = impl_from_IWshShortcut(iface);
1114     TRACE("(%p)->(%s)\n", This, debugstr_w(WorkingDirectory));
1115     return IShellLinkW_SetWorkingDirectory(This->link, WorkingDirectory);
1116 }
1117
1118 static HRESULT WINAPI WshShortcut_Load(IWshShortcut *iface, BSTR PathLink)
1119 {
1120     WshShortcut *This = impl_from_IWshShortcut(iface);
1121     FIXME("(%p)->(%s): stub\n", This, debugstr_w(PathLink));
1122     return E_NOTIMPL;
1123 }
1124
1125 static HRESULT WINAPI WshShortcut_Save(IWshShortcut *iface)
1126 {
1127     WshShortcut *This = impl_from_IWshShortcut(iface);
1128     IPersistFile *file;
1129     HRESULT hr;
1130
1131     TRACE("(%p)\n", This);
1132
1133     IShellLinkW_QueryInterface(This->link, &IID_IPersistFile, (void**)&file);
1134     hr = IPersistFile_Save(file, This->path_link, TRUE);
1135     IPersistFile_Release(file);
1136
1137     return hr;
1138 }
1139
1140 static const IWshShortcutVtbl WshShortcutVtbl = {
1141     WshShortcut_QueryInterface,
1142     WshShortcut_AddRef,
1143     WshShortcut_Release,
1144     WshShortcut_GetTypeInfoCount,
1145     WshShortcut_GetTypeInfo,
1146     WshShortcut_GetIDsOfNames,
1147     WshShortcut_Invoke,
1148     WshShortcut_get_FullName,
1149     WshShortcut_get_Arguments,
1150     WshShortcut_put_Arguments,
1151     WshShortcut_get_Description,
1152     WshShortcut_put_Description,
1153     WshShortcut_get_Hotkey,
1154     WshShortcut_put_Hotkey,
1155     WshShortcut_get_IconLocation,
1156     WshShortcut_put_IconLocation,
1157     WshShortcut_put_RelativePath,
1158     WshShortcut_get_TargetPath,
1159     WshShortcut_put_TargetPath,
1160     WshShortcut_get_WindowStyle,
1161     WshShortcut_put_WindowStyle,
1162     WshShortcut_get_WorkingDirectory,
1163     WshShortcut_put_WorkingDirectory,
1164     WshShortcut_Load,
1165     WshShortcut_Save
1166 };
1167
1168 static HRESULT WshShortcut_Create(const WCHAR *path, IDispatch **shortcut)
1169 {
1170     WshShortcut *object;
1171     HRESULT hr;
1172
1173     *shortcut = NULL;
1174
1175     if (!(object = calloc(1, sizeof(*object))))
1176         return E_OUTOFMEMORY;
1177
1178     object->IWshShortcut_iface.lpVtbl = &WshShortcutVtbl;
1179     object->ref = 1;
1180
1181     hr = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, (void **)&object->link);
1182     if (FAILED(hr))
1183     {
1184         free(object);
1185         return hr;
1186     }
1187
1188     object->path_link = wcsdup(path);
1189     if (!object->path_link)
1190     {
1191         IShellLinkW_Release(object->link);
1192         free(object);
1193         return E_OUTOFMEMORY;
1194     }
1195
1196     init_classinfo(&IID_IWshShortcut, (IUnknown *)&object->IWshShortcut_iface, &object->classinfo);
1197     *shortcut = (IDispatch *)&object->IWshShortcut_iface;
1198
1199     return S_OK;
1200 }
1201
1202 static HRESULT WINAPI WshShell3_QueryInterface(IWshShell3 *iface, REFIID riid, void **ppv)
1203 {
1204     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1205
1206     *ppv = NULL;
1207
1208     if (IsEqualGUID(riid, &IID_IDispatch) ||
1209         IsEqualGUID(riid, &IID_IWshShell3) ||
1210         IsEqualGUID(riid, &IID_IWshShell2) ||
1211         IsEqualGUID(riid, &IID_IWshShell) ||
1212         IsEqualGUID(riid, &IID_IUnknown))
1213     {
1214         *ppv = iface;
1215     }
1216     else if (IsEqualGUID(riid, &IID_IDispatchEx))
1217     {
1218         return E_NOINTERFACE;
1219     }
1220     else if (IsEqualIID(riid, &IID_IProvideClassInfo))
1221     {
1222         *ppv = &WshShell3.classinfo.IProvideClassInfo_iface;
1223     }
1224     else
1225     {
1226         WARN("unknown iface %s\n", debugstr_guid(riid));
1227         return E_NOINTERFACE;
1228     }
1229
1230     IUnknown_AddRef((IUnknown *)*ppv);
1231     return S_OK;
1232 }
1233
1234 static ULONG WINAPI WshShell3_AddRef(IWshShell3 *iface)
1235 {
1236     TRACE("()\n");
1237     return 2;
1238 }
1239
1240 static ULONG WINAPI WshShell3_Release(IWshShell3 *iface)
1241 {
1242     TRACE("()\n");
1243     return 2;
1244 }
1245
1246 static HRESULT WINAPI WshShell3_GetTypeInfoCount(IWshShell3 *iface, UINT *pctinfo)
1247 {
1248     TRACE("(%p)\n", pctinfo);
1249     *pctinfo = 1;
1250     return S_OK;
1251 }
1252
1253 static HRESULT WINAPI WshShell3_GetTypeInfo(IWshShell3 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1254 {
1255     TRACE("%u, %lx, %p.\n", iTInfo, lcid, ppTInfo);
1256
1257     return get_typeinfo(IWshShell3_tid, ppTInfo);
1258 }
1259
1260 static HRESULT WINAPI WshShell3_GetIDsOfNames(IWshShell3 *iface, REFIID riid, LPOLESTR *rgszNames,
1261         UINT cNames, LCID lcid, DISPID *rgDispId)
1262 {
1263     ITypeInfo *typeinfo;
1264     HRESULT hr;
1265
1266     TRACE("%s, %p, %u, %lx, %p.\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
1267
1268     hr = get_typeinfo(IWshShell3_tid, &typeinfo);
1269     if(SUCCEEDED(hr))
1270     {
1271         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1272         ITypeInfo_Release(typeinfo);
1273     }
1274
1275     return hr;
1276 }
1277
1278 static HRESULT WINAPI WshShell3_Invoke(IWshShell3 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
1279         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1280 {
1281     ITypeInfo *typeinfo;
1282     HRESULT hr;
1283
1284     TRACE("%ld, %s, %lx, %d, %p, %p, %p, %p.\n", dispIdMember, debugstr_guid(riid),
1285           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1286
1287     hr = get_typeinfo(IWshShell3_tid, &typeinfo);
1288     if(SUCCEEDED(hr))
1289     {
1290         hr = ITypeInfo_Invoke(typeinfo, &WshShell3.IWshShell3_iface, dispIdMember, wFlags,
1291                 pDispParams, pVarResult, pExcepInfo, puArgErr);
1292         ITypeInfo_Release(typeinfo);
1293     }
1294
1295     return hr;
1296 }
1297
1298 static HRESULT WINAPI WshShell3_get_SpecialFolders(IWshShell3 *iface, IWshCollection **folders)
1299 {
1300     TRACE("(%p)\n", folders);
1301     return WshCollection_Create(folders);
1302 }
1303
1304 static HRESULT WINAPI WshShell3_get_Environment(IWshShell3 *iface, VARIANT *type, IWshEnvironment **env)
1305 {
1306     FIXME("(%s %p): semi-stub\n", debugstr_variant(type), env);
1307     return WshEnvironment_Create(env);
1308 }
1309
1310 static inline BOOL is_optional_argument(const VARIANT *arg)
1311 {
1312     return V_VT(arg) == VT_ERROR && V_ERROR(arg) == DISP_E_PARAMNOTFOUND;
1313 }
1314
1315 static WCHAR *split_command( BSTR cmd, WCHAR **params )
1316 {
1317     WCHAR *ret, *ptr;
1318     BOOL in_quotes = FALSE;
1319
1320     if (!(ret = wcsdup(cmd))) return NULL;
1321
1322     *params = NULL;
1323     for (ptr = ret; *ptr; ptr++)
1324     {
1325         if (*ptr == '"') in_quotes = !in_quotes;
1326         else if (*ptr == ' ' && !in_quotes)
1327         {
1328             *ptr = 0;
1329             *params = ptr + 1;
1330             break;
1331         }
1332     }
1333
1334     return ret;
1335 }
1336
1337 static HRESULT WINAPI WshShell3_Run(IWshShell3 *iface, BSTR cmd, VARIANT *style, VARIANT *wait, int *exit_code)
1338 {
1339     SHELLEXECUTEINFOW info;
1340     int waitforprocess, show;
1341     WCHAR *file, *params;
1342     VARIANT v;
1343     HRESULT hr;
1344     BOOL ret;
1345
1346     TRACE("(%s %s %s %p)\n", debugstr_w(cmd), debugstr_variant(style), debugstr_variant(wait), exit_code);
1347
1348     if (!style || !wait || !exit_code)
1349         return E_POINTER;
1350
1351     if (is_optional_argument(style))
1352         show = SW_SHOWNORMAL;
1353     else {
1354         VariantInit(&v);
1355         hr = VariantChangeType(&v, style, 0, VT_I4);
1356         if (FAILED(hr))
1357             return hr;
1358
1359         show = V_I4(&v);
1360     }
1361
1362     if (is_optional_argument(wait))
1363         waitforprocess = 0;
1364     else {
1365         VariantInit(&v);
1366         hr = VariantChangeType(&v, wait, 0, VT_I4);
1367         if (FAILED(hr))
1368             return hr;
1369
1370         waitforprocess = V_I4(&v);
1371     }
1372
1373     if (!(file = split_command(cmd, &params))) return E_OUTOFMEMORY;
1374
1375     memset(&info, 0, sizeof(info));
1376     info.cbSize = sizeof(info);
1377     info.fMask = SEE_MASK_FLAG_NO_UI;
1378     info.fMask |= waitforprocess ? SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS : SEE_MASK_DEFAULT;
1379     info.lpFile = file;
1380     info.lpParameters = params;
1381     info.nShow = show;
1382
1383     ret = ShellExecuteExW(&info);
1384     free(file);
1385     if (!ret)
1386     {
1387         TRACE("ShellExecute failed, %ld\n", GetLastError());
1388         *exit_code = GetLastError();
1389     }
1390     else
1391     {
1392         if (waitforprocess)
1393         {
1394             DWORD code;
1395             WaitForSingleObject(info.hProcess, INFINITE);
1396             GetExitCodeProcess(info.hProcess, &code);
1397             CloseHandle(info.hProcess);
1398             *exit_code = code;
1399         }
1400         else
1401             *exit_code = 0;
1402
1403     }
1404     return S_OK;
1405 }
1406
1407 struct popup_thread_param
1408 {
1409     WCHAR *text;
1410     VARIANT title;
1411     VARIANT type;
1412     INT button;
1413 };
1414
1415 static DWORD WINAPI popup_thread_proc(void *arg)
1416 {
1417     struct popup_thread_param *param = (struct popup_thread_param *)arg;
1418
1419     param->button = MessageBoxW(NULL, param->text, is_optional_argument(&param->title) ?
1420             L"Windows Script Host" : V_BSTR(&param->title), V_I4(&param->type));
1421     return 0;
1422 }
1423
1424 static HRESULT WINAPI WshShell3_Popup(IWshShell3 *iface, BSTR text, VARIANT *seconds_to_wait, VARIANT *title,
1425         VARIANT *type, int *button)
1426 {
1427     struct popup_thread_param param;
1428     DWORD tid, status;
1429     VARIANT timeout;
1430     HANDLE hthread;
1431     HRESULT hr;
1432
1433     TRACE("(%s %s %s %s %p)\n", debugstr_w(text), debugstr_variant(seconds_to_wait), debugstr_variant(title),
1434         debugstr_variant(type), button);
1435
1436     if (!seconds_to_wait || !title || !type || !button)
1437         return E_POINTER;
1438
1439     VariantInit(&timeout);
1440     if (!is_optional_argument(seconds_to_wait))
1441     {
1442         hr = VariantChangeType(&timeout, seconds_to_wait, 0, VT_I4);
1443         if (FAILED(hr))
1444             return hr;
1445     }
1446
1447     VariantInit(&param.type);
1448     if (!is_optional_argument(type))
1449     {
1450         hr = VariantChangeType(&param.type, type, 0, VT_I4);
1451         if (FAILED(hr))
1452             return hr;
1453     }
1454
1455     if (is_optional_argument(title))
1456         param.title = *title;
1457     else
1458     {
1459         VariantInit(&param.title);
1460         hr = VariantChangeType(&param.title, title, 0, VT_BSTR);
1461         if (FAILED(hr))
1462             return hr;
1463     }
1464
1465     param.text = text;
1466     param.button = -1;
1467     hthread = CreateThread(NULL, 0, popup_thread_proc, &param, 0, &tid);
1468     status = MsgWaitForMultipleObjects(1, &hthread, FALSE, V_I4(&timeout) ? V_I4(&timeout) * 1000: INFINITE, 0);
1469     if (status == WAIT_TIMEOUT)
1470     {
1471         PostThreadMessageW(tid, WM_QUIT, 0, 0);
1472         MsgWaitForMultipleObjects(1, &hthread, FALSE, INFINITE, 0);
1473         param.button = -1;
1474     }
1475     *button = param.button;
1476
1477     VariantClear(&param.title);
1478     CloseHandle(hthread);
1479
1480     return S_OK;
1481 }
1482
1483 static HRESULT WINAPI WshShell3_CreateShortcut(IWshShell3 *iface, BSTR PathLink, IDispatch** Shortcut)
1484 {
1485     TRACE("(%s %p)\n", debugstr_w(PathLink), Shortcut);
1486     return WshShortcut_Create(PathLink, Shortcut);
1487 }
1488
1489 static HRESULT WINAPI WshShell3_ExpandEnvironmentStrings(IWshShell3 *iface, BSTR Src, BSTR* Dst)
1490 {
1491     DWORD ret;
1492
1493     TRACE("(%s %p)\n", debugstr_w(Src), Dst);
1494
1495     if (!Src || !Dst) return E_POINTER;
1496
1497     ret = ExpandEnvironmentStringsW(Src, NULL, 0);
1498     *Dst = SysAllocStringLen(NULL, ret);
1499     if (!*Dst) return E_OUTOFMEMORY;
1500
1501     if (ExpandEnvironmentStringsW(Src, *Dst, ret))
1502         return S_OK;
1503     else
1504     {
1505         SysFreeString(*Dst);
1506         *Dst = NULL;
1507         return HRESULT_FROM_WIN32(GetLastError());
1508     }
1509 }
1510
1511 static HKEY get_root_key(const WCHAR *path)
1512 {
1513     static const struct {
1514         const WCHAR full[20];
1515         const WCHAR abbrev[5];
1516         HKEY hkey;
1517     } rootkeys[] = {
1518         { L"HKEY_CURRENT_USER",   L"HKCU", HKEY_CURRENT_USER },
1519         { L"HKEY_LOCAL_MACHINE",  L"HKLM", HKEY_LOCAL_MACHINE },
1520         { L"HKEY_CLASSES_ROOT",   L"HKCR", HKEY_CLASSES_ROOT },
1521         { L"HKEY_USERS",          {0},     HKEY_USERS },
1522         { L"HKEY_CURRENT_CONFIG", {0},     HKEY_CURRENT_CONFIG }
1523     };
1524     int i;
1525
1526     for (i = 0; i < ARRAY_SIZE(rootkeys); i++) {
1527         if (!wcsncmp(path, rootkeys[i].full, lstrlenW(rootkeys[i].full)))
1528             return rootkeys[i].hkey;
1529         if (rootkeys[i].abbrev[0] && !wcsncmp(path, rootkeys[i].abbrev, lstrlenW(rootkeys[i].abbrev)))
1530             return rootkeys[i].hkey;
1531     }
1532
1533     return NULL;
1534 }
1535
1536 /* Caller is responsible to free 'subkey' if 'value' is not NULL */
1537 static HRESULT split_reg_path(const WCHAR *path, WCHAR **subkey, WCHAR **value)
1538 {
1539     *value = NULL;
1540
1541     /* at least one separator should be present */
1542     *subkey = wcschr(path, '\\');
1543     if (!*subkey)
1544         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
1545
1546     /* default value or not */
1547     if ((*subkey)[lstrlenW(*subkey)-1] == '\\') {
1548         (*subkey)++;
1549         *value = NULL;
1550     }
1551     else {
1552         *value = wcsrchr(*subkey, '\\');
1553         if (*value - *subkey > 1) {
1554             unsigned int len = *value - *subkey - 1;
1555             WCHAR *ret;
1556
1557             ret = malloc((len + 1)*sizeof(WCHAR));
1558             if (!ret)
1559                 return E_OUTOFMEMORY;
1560
1561             memcpy(ret, *subkey + 1, len*sizeof(WCHAR));
1562             ret[len] = 0;
1563             *subkey = ret;
1564         }
1565         (*value)++;
1566     }
1567
1568     return S_OK;
1569 }
1570
1571 static HRESULT WINAPI WshShell3_RegRead(IWshShell3 *iface, BSTR name, VARIANT *value)
1572 {
1573     DWORD type, datalen, ret;
1574     WCHAR *subkey, *val;
1575     HRESULT hr;
1576     HKEY root;
1577
1578     TRACE("(%s %p)\n", debugstr_w(name), value);
1579
1580     if (!name || !value)
1581         return E_POINTER;
1582
1583     root = get_root_key(name);
1584     if (!root)
1585         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
1586
1587     hr = split_reg_path(name, &subkey, &val);
1588     if (FAILED(hr))
1589         return hr;
1590
1591     type = REG_NONE;
1592     datalen = 0;
1593     ret = RegGetValueW(root, subkey, val, RRF_RT_ANY, &type, NULL, &datalen);
1594     if (ret == ERROR_SUCCESS) {
1595         void *data;
1596
1597         data = malloc(datalen);
1598         if (!data) {
1599             hr = E_OUTOFMEMORY;
1600             goto fail;
1601         }
1602
1603         ret = RegGetValueW(root, subkey, val, RRF_RT_ANY, &type, data, &datalen);
1604         if (ret) {
1605             free(data);
1606             hr = HRESULT_FROM_WIN32(ret);
1607             goto fail;
1608         }
1609
1610         switch (type) {
1611         case REG_SZ:
1612         case REG_EXPAND_SZ:
1613             V_VT(value) = VT_BSTR;
1614             V_BSTR(value) = SysAllocString((WCHAR*)data);
1615             if (!V_BSTR(value))
1616                 hr = E_OUTOFMEMORY;
1617             break;
1618         case REG_DWORD:
1619             V_VT(value) = VT_I4;
1620             V_I4(value) = *(DWORD*)data;
1621             break;
1622         case REG_BINARY:
1623         {
1624             BYTE *ptr = (BYTE*)data;
1625             SAFEARRAYBOUND bound;
1626             unsigned int i;
1627             SAFEARRAY *sa;
1628             VARIANT *v;
1629
1630             bound.lLbound = 0;
1631             bound.cElements = datalen;
1632             sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
1633             if (!sa)
1634                 break;
1635
1636             hr = SafeArrayAccessData(sa, (void**)&v);
1637             if (FAILED(hr)) {
1638                 SafeArrayDestroy(sa);
1639                 break;
1640             }
1641
1642             for (i = 0; i < datalen; i++) {
1643                 V_VT(&v[i]) = VT_UI1;
1644                 V_UI1(&v[i]) = ptr[i];
1645             }
1646             SafeArrayUnaccessData(sa);
1647
1648             V_VT(value) = VT_ARRAY|VT_VARIANT;
1649             V_ARRAY(value) = sa;
1650             break;
1651         }
1652         case REG_MULTI_SZ:
1653         {
1654             WCHAR *ptr = (WCHAR*)data;
1655             SAFEARRAYBOUND bound;
1656             SAFEARRAY *sa;
1657             VARIANT *v;
1658
1659             /* get element count first */
1660             bound.lLbound = 0;
1661             bound.cElements = 0;
1662             while (*ptr) {
1663                 bound.cElements++;
1664                 ptr += lstrlenW(ptr)+1;
1665             }
1666
1667             sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
1668             if (!sa)
1669                 break;
1670
1671             hr = SafeArrayAccessData(sa, (void**)&v);
1672             if (FAILED(hr)) {
1673                 SafeArrayDestroy(sa);
1674                 break;
1675             }
1676
1677             ptr = (WCHAR*)data;
1678             while (*ptr) {
1679                 V_VT(v) = VT_BSTR;
1680                 V_BSTR(v) = SysAllocString(ptr);
1681                 ptr += lstrlenW(ptr)+1;
1682                 v++;
1683             }
1684
1685             SafeArrayUnaccessData(sa);
1686             V_VT(value) = VT_ARRAY|VT_VARIANT;
1687             V_ARRAY(value) = sa;
1688             break;
1689         }
1690         default:
1691             FIXME("value type %ld not supported\n", type);
1692             hr = E_FAIL;
1693         };
1694
1695         free(data);
1696         if (FAILED(hr))
1697             VariantInit(value);
1698     }
1699     else
1700         hr = HRESULT_FROM_WIN32(ret);
1701
1702 fail:
1703     if (val)
1704         free(subkey);
1705     return hr;
1706 }
1707
1708 static HRESULT WINAPI WshShell3_RegWrite(IWshShell3 *iface, BSTR name, VARIANT *value, VARIANT *type)
1709 {
1710     DWORD regtype, data_len;
1711     WCHAR *subkey, *val;
1712     const BYTE *data;
1713     HRESULT hr;
1714     HKEY root;
1715     VARIANT v;
1716     LONG ret;
1717
1718     TRACE("(%s %s %s)\n", debugstr_w(name), debugstr_variant(value), debugstr_variant(type));
1719
1720     if (!name || !value || !type)
1721         return E_POINTER;
1722
1723     root = get_root_key(name);
1724     if (!root)
1725         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
1726
1727     /* value type */
1728     if (is_optional_argument(type))
1729         regtype = REG_SZ;
1730     else {
1731         if (V_VT(type) != VT_BSTR)
1732             return E_INVALIDARG;
1733
1734         if (!wcscmp(V_BSTR(type), L"REG_SZ"))
1735             regtype = REG_SZ;
1736         else if (!wcscmp(V_BSTR(type), L"REG_DWORD"))
1737             regtype = REG_DWORD;
1738         else if (!wcscmp(V_BSTR(type), L"REG_EXPAND_SZ"))
1739             regtype = REG_EXPAND_SZ;
1740         else if (!wcscmp(V_BSTR(type), L"REG_BINARY"))
1741             regtype = REG_BINARY;
1742         else {
1743             FIXME("unrecognized value type %s\n", debugstr_w(V_BSTR(type)));
1744             return E_FAIL;
1745         }
1746     }
1747
1748     /* it's always a string or a DWORD */
1749     VariantInit(&v);
1750     switch (regtype)
1751     {
1752     case REG_SZ:
1753     case REG_EXPAND_SZ:
1754         hr = VariantChangeType(&v, value, 0, VT_BSTR);
1755         if (hr == S_OK) {
1756             data = (BYTE*)V_BSTR(&v);
1757             data_len = SysStringByteLen(V_BSTR(&v)) + sizeof(WCHAR);
1758         }
1759         break;
1760     case REG_DWORD:
1761     case REG_BINARY:
1762         hr = VariantChangeType(&v, value, 0, VT_I4);
1763         data = (BYTE*)&V_I4(&v);
1764         data_len = sizeof(DWORD);
1765         break;
1766     default:
1767         FIXME("unexpected regtype %ld\n", regtype);
1768         return E_FAIL;
1769     };
1770
1771     if (FAILED(hr)) {
1772         FIXME("failed to convert value, regtype %ld, %#lx.\n", regtype, hr);
1773         return hr;
1774     }
1775
1776     hr = split_reg_path(name, &subkey, &val);
1777     if (FAILED(hr))
1778         goto fail;
1779
1780     ret = RegSetKeyValueW(root, subkey, val, regtype, data, data_len);
1781     if (ret)
1782         hr = HRESULT_FROM_WIN32(ret);
1783
1784 fail:
1785     VariantClear(&v);
1786     if (val)
1787         free(subkey);
1788     return hr;
1789 }
1790
1791 static HRESULT WINAPI WshShell3_RegDelete(IWshShell3 *iface, BSTR Name)
1792 {
1793     FIXME("(%s): stub\n", debugstr_w(Name));
1794     return E_NOTIMPL;
1795 }
1796
1797 static HRESULT WINAPI WshShell3_LogEvent(IWshShell3 *iface, VARIANT *Type, BSTR Message, BSTR Target, VARIANT_BOOL *out_Success)
1798 {
1799     FIXME("(%s %s %s %p): stub\n", debugstr_variant(Type), debugstr_w(Message), debugstr_w(Target), out_Success);
1800     return E_NOTIMPL;
1801 }
1802
1803 static HRESULT WINAPI WshShell3_AppActivate(IWshShell3 *iface, VARIANT *App, VARIANT *Wait, VARIANT_BOOL *out_Success)
1804 {
1805     FIXME("(%s %s %p): stub\n", debugstr_variant(App), debugstr_variant(Wait), out_Success);
1806     return E_NOTIMPL;
1807 }
1808
1809 static HRESULT WINAPI WshShell3_SendKeys(IWshShell3 *iface, BSTR Keys, VARIANT *Wait)
1810 {
1811     FIXME("(%s %p): stub\n", debugstr_w(Keys), Wait);
1812     return E_NOTIMPL;
1813 }
1814
1815 static HRESULT WINAPI WshShell3_Exec(IWshShell3 *iface, BSTR command, IWshExec **ret)
1816 {
1817     BSTR expandedcmd;
1818     HRESULT hr;
1819
1820     TRACE("(%s %p)\n", debugstr_w(command), ret);
1821
1822     if (!ret)
1823         return E_POINTER;
1824
1825     if (!command)
1826         return DISP_E_EXCEPTION;
1827
1828     hr = WshShell3_ExpandEnvironmentStrings(iface, command, &expandedcmd);
1829     if (FAILED(hr))
1830         return hr;
1831
1832     hr = WshExec_create(expandedcmd, ret);
1833     SysFreeString(expandedcmd);
1834     return hr;
1835 }
1836
1837 static HRESULT WINAPI WshShell3_get_CurrentDirectory(IWshShell3 *iface, BSTR *dir)
1838 {
1839     DWORD ret;
1840
1841     TRACE("(%p)\n", dir);
1842
1843     ret = GetCurrentDirectoryW(0, NULL);
1844     if (!ret)
1845         return HRESULT_FROM_WIN32(GetLastError());
1846
1847     *dir = SysAllocStringLen(NULL, ret-1);
1848     if (!*dir)
1849         return E_OUTOFMEMORY;
1850
1851     ret = GetCurrentDirectoryW(ret, *dir);
1852     if (!ret) {
1853         SysFreeString(*dir);
1854         *dir = NULL;
1855         return HRESULT_FROM_WIN32(GetLastError());
1856     }
1857
1858     return S_OK;
1859 }
1860
1861 static HRESULT WINAPI WshShell3_put_CurrentDirectory(IWshShell3 *iface, BSTR dir)
1862 {
1863     TRACE("(%s)\n", debugstr_w(dir));
1864
1865     if (!dir)
1866         return E_INVALIDARG;
1867
1868     if (!SetCurrentDirectoryW(dir))
1869         return HRESULT_FROM_WIN32(GetLastError());
1870
1871     return S_OK;
1872 }
1873
1874 static const IWshShell3Vtbl WshShell3Vtbl = {
1875     WshShell3_QueryInterface,
1876     WshShell3_AddRef,
1877     WshShell3_Release,
1878     WshShell3_GetTypeInfoCount,
1879     WshShell3_GetTypeInfo,
1880     WshShell3_GetIDsOfNames,
1881     WshShell3_Invoke,
1882     WshShell3_get_SpecialFolders,
1883     WshShell3_get_Environment,
1884     WshShell3_Run,
1885     WshShell3_Popup,
1886     WshShell3_CreateShortcut,
1887     WshShell3_ExpandEnvironmentStrings,
1888     WshShell3_RegRead,
1889     WshShell3_RegWrite,
1890     WshShell3_RegDelete,
1891     WshShell3_LogEvent,
1892     WshShell3_AppActivate,
1893     WshShell3_SendKeys,
1894     WshShell3_Exec,
1895     WshShell3_get_CurrentDirectory,
1896     WshShell3_put_CurrentDirectory
1897 };
1898
1899 HRESULT WINAPI WshShellFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1900 {
1901     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
1902
1903     WshShell3.IWshShell3_iface.lpVtbl = &WshShell3Vtbl;
1904     init_classinfo(&IID_IWshShell3, (IUnknown *)&WshShell3.IWshShell3_iface, &WshShell3.classinfo);
1905     return IWshShell3_QueryInterface(&WshShell3.IWshShell3_iface, riid, ppv);
1906 }