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