programs/wscript/main.c

   1 /*
   2  * Copyright 2010 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 <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include <windef.h>
  24 #include <winbase.h>
  25 #include <winreg.h>
  26 #include <ole2.h>
  27 #include <shellapi.h>
  28 #include <activscp.h>
  29 #include <initguid.h>
  30
  31 #include "wscript.h"
  32
  33 #include <wine/debug.h>
  34
  35 #ifdef _WIN64
  36
  37 #define IActiveScriptParse_Release IActiveScriptParse64_Release
  38 #define IActiveScriptParse_InitNew IActiveScriptParse64_InitNew
  39 #define IActiveScriptParse_ParseScriptText IActiveScriptParse64_ParseScriptText
  40
  41 #else
  42
  43 #define IActiveScriptParse_Release IActiveScriptParse32_Release
  44 #define IActiveScriptParse_InitNew IActiveScriptParse32_InitNew
  45 #define IActiveScriptParse_ParseScriptText IActiveScriptParse32_ParseScriptText
  46
  47 #endif
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(wscript);
  50
  51 static const WCHAR wscriptW[] = {'W','S','c','r','i','p','t',0};
  52 static const WCHAR wshW[] = {'W','S','H',0};
  53 WCHAR scriptFullName[MAX_PATH];
  54
  55 ITypeInfo *host_ti;
  56 ITypeInfo *arguments_ti;
  57
  58 static HRESULT query_interface(REFIID,void**);
  59
  60 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface,
  61                                                       REFIID riid, void **ppv)
  62 {
  63     return query_interface(riid, ppv);
  64 }
  65
  66 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
  67 {
  68     return 2;
  69 }
  70
  71 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
  72 {
  73     return 1;
  74 }
  75
  76 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
  77 {
  78     WINE_TRACE("()\n");
  79
  80     *plcid = GetUserDefaultLCID();
  81     return S_OK;
  82 }
  83
  84 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface,
  85         LPCOLESTR pstrName, DWORD dwReturnMask, IUnknown **ppunkItem, ITypeInfo **ppti)
  86 {
  87     WINE_TRACE("(%s %x %p %p)\n", wine_dbgstr_w(pstrName), dwReturnMask, ppunkItem, ppti);
  88
  89     if(lstrcmpW(pstrName, wshW) && lstrcmpW(pstrName, wscriptW))
  90         return E_FAIL;
  91
  92     if(dwReturnMask & SCRIPTINFO_ITYPEINFO) {
  93         ITypeInfo_AddRef(host_ti);
  94         *ppti = host_ti;
  95     }
  96
  97     if(dwReturnMask & SCRIPTINFO_IUNKNOWN) {
  98         IHost_AddRef(&host_obj);
  99         *ppunkItem = (IUnknown*)&host_obj;
 100     }
 101
 102     return S_OK;
 103 }
 104
 105 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface,
 106         BSTR *pbstrVersion)
 107 {
 108     WINE_FIXME("()\n");
 109     return E_NOTIMPL;
 110 }
 111
 112 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 113         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 114 {
 115     WINE_FIXME("()\n");
 116     return E_NOTIMPL;
 117 }
 118
 119 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface,
 120         SCRIPTSTATE ssScriptState)
 121 {
 122     WINE_TRACE("(%x)\n", ssScriptState);
 123     return S_OK;
 124 }
 125
 126 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface,
 127         IActiveScriptError *pscripterror)
 128 {
 129     WINE_FIXME("()\n");
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 134 {
 135     WINE_TRACE("()\n");
 136     return S_OK;
 137 }
 138
 139 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 140 {
 141     WINE_TRACE("()\n");
 142     return S_OK;
 143 }
 144
 145 static IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 146     ActiveScriptSite_QueryInterface,
 147     ActiveScriptSite_AddRef,
 148     ActiveScriptSite_Release,
 149     ActiveScriptSite_GetLCID,
 150     ActiveScriptSite_GetItemInfo,
 151     ActiveScriptSite_GetDocVersionString,
 152     ActiveScriptSite_OnScriptTerminate,
 153     ActiveScriptSite_OnStateChange,
 154     ActiveScriptSite_OnScriptError,
 155     ActiveScriptSite_OnEnterScript,
 156     ActiveScriptSite_OnLeaveScript
 157 };
 158
 159 static IActiveScriptSite script_site = { &ActiveScriptSiteVtbl };
 160
 161 static HRESULT WINAPI ActiveScriptSiteWindow_QueryInterface(IActiveScriptSiteWindow *iface, REFIID riid, void **ppv)
 162 {
 163     return query_interface(riid, ppv);
 164 }
 165
 166 static ULONG WINAPI ActiveScriptSiteWindow_AddRef(IActiveScriptSiteWindow *iface)
 167 {
 168     return 2;
 169 }
 170
 171 static ULONG WINAPI ActiveScriptSiteWindow_Release(IActiveScriptSiteWindow *iface)
 172 {
 173     return 1;
 174 }
 175
 176 static HRESULT WINAPI ActiveScriptSiteWindow_GetWindow(IActiveScriptSiteWindow *iface, HWND *phwnd)
 177 {
 178     TRACE("(%p)\n", phwnd);
 179
 180     *phwnd = NULL;
 181     return S_OK;
 182 }
 183
 184 static HRESULT WINAPI ActiveScriptSiteWindow_EnableModeless(IActiveScriptSiteWindow *iface, BOOL fEnable)
 185 {
 186     TRACE("(%x)\n", fEnable);
 187     return S_OK;
 188 }
 189
 190 static const IActiveScriptSiteWindowVtbl ActiveScriptSiteWindowVtbl = {
 191     ActiveScriptSiteWindow_QueryInterface,
 192     ActiveScriptSiteWindow_AddRef,
 193     ActiveScriptSiteWindow_Release,
 194     ActiveScriptSiteWindow_GetWindow,
 195     ActiveScriptSiteWindow_EnableModeless
 196 };
 197
 198 static IActiveScriptSiteWindow script_site_window = { &ActiveScriptSiteWindowVtbl };
 199
 200 static HRESULT query_interface(REFIID riid, void **ppv)
 201 {
 202     if(IsEqualGUID(riid, &IID_IUnknown)) {
 203         TRACE("(IID_IUnknown %p)\n", ppv);
 204         *ppv = &script_site;
 205     }else if(IsEqualGUID(riid, &IID_IActiveScriptSite)) {
 206         TRACE("(IID_IActiveScriptSite %p)\n", ppv);
 207         *ppv = &script_site;
 208     }else if(IsEqualGUID(riid, &IID_IActiveScriptSiteWindow)) {
 209         TRACE("(IID_IActiveScriptSiteWindow %p)\n", ppv);
 210         *ppv = &script_site_window;
 211     }else {
 212         *ppv = NULL;
 213         TRACE("(%s %p)\n", wine_dbgstr_guid(riid), ppv);
 214         return E_NOINTERFACE;
 215     }
 216
 217     IUnknown_AddRef((IUnknown*)*ppv);
 218     return S_OK;
 219 }
 220
 221 static BOOL load_typelib(void)
 222 {
 223     ITypeLib *typelib;
 224     HRESULT hres;
 225
 226     static const WCHAR wscript_exeW[] = {'w','s','c','r','i','p','t','.','e','x','e',0};
 227
 228     hres = LoadTypeLib(wscript_exeW, &typelib);
 229     if(FAILED(hres))
 230         return FALSE;
 231
 232     hres = ITypeLib_GetTypeInfoOfGuid(typelib, &IID_IHost, &host_ti);
 233     if(SUCCEEDED(hres))
 234         hres = ITypeLib_GetTypeInfoOfGuid(typelib, &IID_IArguments2, &arguments_ti);
 235
 236     ITypeLib_Release(typelib);
 237     return SUCCEEDED(hres);
 238 }
 239
 240 static BOOL get_engine_clsid(const WCHAR *ext, CLSID *clsid)
 241 {
 242     WCHAR fileid[64], progid[64];
 243     DWORD res;
 244     LONG size;
 245     HKEY hkey;
 246     HRESULT hres;
 247
 248     static const WCHAR script_engineW[] =
 249         {'\\','S','c','r','i','p','t','E','n','g','i','n','e',0};
 250
 251     res = RegOpenKeyW(HKEY_CLASSES_ROOT, ext, &hkey);
 252     if(res != ERROR_SUCCESS)
 253         return FALSE;
 254
 255     size = ARRAY_SIZE(fileid);
 256     res = RegQueryValueW(hkey, NULL, fileid, &size);
 257     RegCloseKey(hkey);
 258     if(res != ERROR_SUCCESS)
 259         return FALSE;
 260
 261     WINE_TRACE("fileid is %s\n", wine_dbgstr_w(fileid));
 262
 263     lstrcatW(fileid, script_engineW);
 264     res = RegOpenKeyW(HKEY_CLASSES_ROOT, fileid, &hkey);
 265     if(res != ERROR_SUCCESS)
 266         return FALSE;
 267
 268     size = ARRAY_SIZE(progid);
 269     res = RegQueryValueW(hkey, NULL, progid, &size);
 270     RegCloseKey(hkey);
 271     if(res != ERROR_SUCCESS)
 272         return FALSE;
 273
 274     WINE_TRACE("ProgID is %s\n", wine_dbgstr_w(progid));
 275
 276     hres = CLSIDFromProgID(progid, clsid);
 277     return SUCCEEDED(hres);
 278 }
 279
 280 static BOOL create_engine(CLSID *clsid, IActiveScript **script_ret,
 281         IActiveScriptParse **parser)
 282 {
 283     IActiveScript *script;
 284     IUnknown *unk;
 285     HRESULT hres;
 286
 287     hres = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 288             &IID_IUnknown, (void**)&unk);
 289     if(FAILED(hres))
 290         return FALSE;
 291
 292     hres = IUnknown_QueryInterface(unk, &IID_IActiveScript, (void**)&script);
 293     IUnknown_Release(unk);
 294     if(FAILED(hres))
 295         return FALSE;
 296
 297     hres = IActiveScript_QueryInterface(script, &IID_IActiveScriptParse, (void**)parser);
 298     if(FAILED(hres)) {
 299         IActiveScript_Release(script);
 300         return FALSE;
 301     }
 302
 303     *script_ret = script;
 304     return TRUE;
 305 }
 306
 307 static BOOL init_engine(IActiveScript *script, IActiveScriptParse *parser)
 308 {
 309     HRESULT hres;
 310
 311     if(!load_typelib())
 312         return FALSE;
 313
 314     hres = IActiveScript_SetScriptSite(script, &script_site);
 315     if(FAILED(hres))
 316         return FALSE;
 317
 318     hres = IActiveScriptParse_InitNew(parser);
 319     if(FAILED(hres))
 320         return FALSE;
 321
 322     hres = IActiveScript_AddNamedItem(script, wscriptW, SCRIPTITEM_ISVISIBLE);
 323     if(FAILED(hres))
 324         return FALSE;
 325
 326     hres = IActiveScript_AddNamedItem(script, wshW, SCRIPTITEM_ISVISIBLE);
 327     if(FAILED(hres))
 328         return FALSE;
 329
 330     hres = IActiveScript_SetScriptState(script, SCRIPTSTATE_INITIALIZED);
 331     return SUCCEEDED(hres);
 332 }
 333
 334 static BSTR get_script_str(const WCHAR *filename)
 335 {
 336     const char *file_map;
 337     HANDLE file, map;
 338     DWORD size, len;
 339     BSTR ret;
 340
 341     file = CreateFileW(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
 342     if(file == INVALID_HANDLE_VALUE)
 343         return NULL;
 344
 345     size = GetFileSize(file, NULL);
 346     map = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, NULL);
 347     CloseHandle(file);
 348     if(map == INVALID_HANDLE_VALUE)
 349         return NULL;
 350
 351     file_map = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
 352     CloseHandle(map);
 353     if(!file_map)
 354         return NULL;
 355
 356     len = MultiByteToWideChar(CP_ACP, 0, file_map, size, NULL, 0);
 357     ret = SysAllocStringLen(NULL, len);
 358     MultiByteToWideChar(CP_ACP, 0, file_map, size, ret, len);
 359
 360     UnmapViewOfFile(file_map);
 361     return ret;
 362 }
 363
 364 static void run_script(const WCHAR *filename, IActiveScript *script, IActiveScriptParse *parser)
 365 {
 366     BSTR text;
 367     HRESULT hres;
 368
 369     text = get_script_str(filename);
 370     if(!text) {
 371         WINE_FIXME("Could not get script text\n");
 372         return;
 373     }
 374
 375     hres = IActiveScriptParse_ParseScriptText(parser, text, NULL, NULL, NULL, 1, 1,
 376             SCRIPTTEXT_HOSTMANAGESSOURCE|SCRIPTITEM_ISVISIBLE, NULL, NULL);
 377     SysFreeString(text);
 378     if(FAILED(hres)) {
 379         WINE_FIXME("ParseScriptText failed: %08x\n", hres);
 380         return;
 381     }
 382
 383     hres = IActiveScript_SetScriptState(script, SCRIPTSTATE_STARTED);
 384     if(FAILED(hres))
 385         WINE_FIXME("SetScriptState failed: %08x\n", hres);
 386 }
 387
 388 static BOOL set_host_properties(const WCHAR *prop)
 389 {
 390     static const WCHAR nologoW[] = {'n','o','l','o','g','o',0};
 391     static const WCHAR iactive[] = {'i',0};
 392     static const WCHAR batch[] = {'b',0};
 393
 394     if(*prop == '/') {
 395         ++prop;
 396         if(*prop == '/')
 397             ++prop;
 398     }
 399     else
 400         ++prop;
 401
 402     if(wcsicmp(prop, iactive) == 0)
 403         wshInteractive = VARIANT_TRUE;
 404     else if(wcsicmp(prop, batch) == 0)
 405         wshInteractive = VARIANT_FALSE;
 406     else if(wcsicmp(prop, nologoW) == 0)
 407         WINE_FIXME("ignored %s switch\n", debugstr_w(nologoW));
 408     else
 409     {
 410         WINE_FIXME("unsupported switch %s\n", debugstr_w(prop));
 411         return FALSE;
 412     }
 413     return TRUE;
 414 }
 415
 416 int WINAPI wWinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPWSTR cmdline, int cmdshow)
 417 {
 418     WCHAR *ext, *filepart, *filename = NULL;
 419     IActiveScriptParse *parser;
 420     IActiveScript *script;
 421     WCHAR **argv;
 422     CLSID clsid;
 423     int argc, i;
 424     DWORD res;
 425
 426     WINE_TRACE("(%p %p %s %x)\n", hInst, hPrevInst, wine_dbgstr_w(cmdline), cmdshow);
 427
 428     argv = CommandLineToArgvW(GetCommandLineW(), &argc);
 429     if(!argv)
 430         return 1;
 431
 432     for(i=1; i<argc; i++) {
 433         if(*argv[i] == '/' || *argv[i] == '-') {
 434             if(!set_host_properties(argv[i]))
 435                 return 1;
 436         }else {
 437             filename = argv[i];
 438             argums = argv+i+1;
 439             numOfArgs = argc-i-1;
 440             break;
 441         }
 442     }
 443
 444     if(!filename) {
 445         WINE_FIXME("No file name specified\n");
 446         return 1;
 447     }
 448     res = GetFullPathNameW(filename, ARRAY_SIZE(scriptFullName), scriptFullName, &filepart);
 449     if(!res || res > ARRAY_SIZE(scriptFullName))
 450         return 1;
 451
 452     ext = wcsrchr(filepart, '.');
 453     if(!ext || !get_engine_clsid(ext, &clsid)) {
 454         WINE_FIXME("Could not find engine for %s\n", wine_dbgstr_w(ext));
 455         return 1;
 456     }
 457
 458     CoInitialize(NULL);
 459
 460     if(!create_engine(&clsid, &script, &parser)) {
 461         WINE_FIXME("Could not create script engine\n");
 462         CoUninitialize();
 463         return 1;
 464     }
 465
 466     if(init_engine(script, parser)) {
 467         run_script(filename, script, parser);
 468         IActiveScript_Close(script);
 469         ITypeInfo_Release(host_ti);
 470     }else {
 471         WINE_FIXME("Script initialization failed\n");
 472     }
 473
 474     IActiveScript_Release(script);
 475     IActiveScriptParse_Release(parser);
 476
 477     CoUninitialize();
 478
 479     return 0;
 480 }