programs/regsvr32/regsvr32.c

   1 /*
   2  * PURPOSE: Register OLE components in the registry
   3  *
   4  * Copyright 2001 ReactOS project
   5  * Copyright 2001 Jurgen Van Gael [jurgen.vangael@student.kuleuven.ac.be]
   6  * Copyright 2002 Andriy Palamarchuk
   7  * Copyright 2014, 2015 Hugh McMaster
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #define WIN32_LEAN_AND_MEAN
  25 #include <windows.h>
  26 #include <winternl.h>
  27 #include <ole2.h>
  28 #include "regsvr32.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(regsvr32);
  32
  33 typedef HRESULT (WINAPI *DLLREGISTER)   (void);
  34 typedef HRESULT (WINAPI *DLLUNREGISTER) (void);
  35 typedef HRESULT (WINAPI *DLLINSTALL)    (BOOL,LPCWSTR);
  36
  37 static BOOL Silent = FALSE;
  38
  39 static void WINAPIV output_write(UINT id, ...)
  40 {
  41     WCHAR fmt[1024];
  42     va_list va_args;
  43     WCHAR *str;
  44     DWORD len, nOut, ret;
  45
  46     if (Silent) return;
  47
  48     if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, ARRAY_SIZE(fmt)))
  49     {
  50         WINE_FIXME("LoadString failed with %d\n", GetLastError());
  51         return;
  52     }
  53
  54     va_start(va_args, id);
  55     len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
  56                          fmt, 0, 0, (LPWSTR)&str, 0, &va_args);
  57     va_end(va_args);
  58     if (len == 0 && GetLastError() != ERROR_NO_WORK_DONE)
  59     {
  60         WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(fmt));
  61         return;
  62     }
  63
  64     ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), str, len, &nOut, NULL);
  65
  66     /* WriteConsole fails if its output is redirected to a file.
  67      * If this occurs, we should use an OEM codepage and call WriteFile.
  68      */
  69     if (!ret)
  70     {
  71         DWORD lenA;
  72         char *strA;
  73
  74         lenA = WideCharToMultiByte(GetConsoleOutputCP(), 0, str, len, NULL, 0, NULL, NULL);
  75         strA = HeapAlloc(GetProcessHeap(), 0, lenA);
  76         if (strA)
  77         {
  78             WideCharToMultiByte(GetConsoleOutputCP(), 0, str, len, strA, lenA, NULL, NULL);
  79             WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), strA, lenA, &nOut, FALSE);
  80             HeapFree(GetProcessHeap(), 0, strA);
  81         }
  82     }
  83     LocalFree(str);
  84 }
  85
  86 static LPCWSTR find_arg_start(LPCWSTR cmdline)
  87 {
  88     LPCWSTR s;
  89     BOOL in_quotes;
  90     int bcount;
  91
  92     bcount=0;
  93     in_quotes=FALSE;
  94     s=cmdline;
  95     while (1) {
  96         if (*s==0 || ((*s=='\t' || *s==' ') && !in_quotes)) {
  97             /* end of this command line argument */
  98             break;
  99         } else if (*s=='\\') {
 100             /* '\', count them */
 101             bcount++;
 102         } else if ((*s=='"') && ((bcount & 1)==0)) {
 103             /* unescaped '"' */
 104             in_quotes=!in_quotes;
 105             bcount=0;
 106         } else {
 107             /* a regular character */
 108             bcount=0;
 109         }
 110         s++;
 111     }
 112     return s;
 113 }
 114
 115 static void reexec_self( WORD machine )
 116 {
 117     WCHAR app[MAX_PATH];
 118     LPCWSTR args;
 119     WCHAR *cmdline;
 120     ULONG i, machines[8];
 121     HANDLE process = 0;
 122     STARTUPINFOW si = {0};
 123     PROCESS_INFORMATION pi;
 124     void *cookie;
 125
 126     NtQuerySystemInformationEx( SystemSupportedProcessorArchitectures, &process, sizeof(process),
 127                                 machines, sizeof(machines), NULL );
 128     for (i = 0; machines[i]; i++) if (LOWORD(machines[i]) == machine) break;
 129     if (!machines[i]) return;
 130     if (HIWORD(machines[i]) & 4 /* native machine */) machine = IMAGE_FILE_MACHINE_TARGET_HOST;
 131     if (!GetSystemWow64Directory2W( app, MAX_PATH, machine )) return;
 132     wcscat( app, L"\\regsvr32.exe" );
 133
 134     TRACE( "restarting as %s\n", debugstr_w(app) );
 135
 136     args = find_arg_start(GetCommandLineW());
 137
 138     cmdline = HeapAlloc(GetProcessHeap(), 0,
 139                         (wcslen(app)+wcslen(args)+1)*sizeof(WCHAR));
 140
 141     wcscpy(cmdline, app);
 142     wcscat(cmdline, args);
 143
 144     si.cb = sizeof(si);
 145
 146     Wow64DisableWow64FsRedirection(&cookie);
 147     if (CreateProcessW(app, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
 148     {
 149         DWORD exit_code;
 150         WaitForSingleObject(pi.hProcess, INFINITE);
 151         GetExitCodeProcess(pi.hProcess, &exit_code);
 152         ExitProcess(exit_code);
 153     }
 154     else
 155     {
 156         WINE_TRACE("failed to restart, err=%d\n", GetLastError());
 157     }
 158     Wow64RevertWow64FsRedirection(cookie);
 159     HeapFree(GetProcessHeap(), 0, cmdline);
 160 }
 161
 162 /**
 163  * Loads procedure.
 164  *
 165  * Parameters:
 166  * strDll - name of the dll.
 167  * procName - name of the procedure to load from the dll.
 168  * DllHandle - a variable that receives the handle of the loaded dll.
 169  * firstDll - true if this is the first dll in the command line.
 170  */
 171 static VOID *LoadProc(const WCHAR* strDll, const char* procName, HMODULE* DllHandle, BOOL firstDll)
 172 {
 173     VOID* (*proc)(void);
 174
 175     *DllHandle = LoadLibraryExW(strDll, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
 176     if(!*DllHandle)
 177     {
 178         HMODULE module;
 179         if (firstDll && GetLastError() == ERROR_BAD_EXE_FORMAT &&
 180             (module = LoadLibraryExW(strDll, 0, LOAD_LIBRARY_AS_IMAGE_RESOURCE)))
 181         {
 182             IMAGE_NT_HEADERS *nt = RtlImageNtHeader( (HMODULE)((ULONG_PTR)module & ~3) );
 183             reexec_self( nt->FileHeader.Machine );
 184         }
 185         output_write(STRING_DLL_LOAD_FAILED, strDll);
 186         ExitProcess(LOADLIBRARY_FAILED);
 187     }
 188     proc = (VOID *) GetProcAddress(*DllHandle, procName);
 189     if(!proc)
 190     {
 191         output_write(STRING_PROC_NOT_IMPLEMENTED, procName, strDll);
 192         FreeLibrary(*DllHandle);
 193         return NULL;
 194     }
 195     return proc;
 196 }
 197
 198 static int RegisterDll(const WCHAR* strDll, BOOL firstDll)
 199 {
 200     HRESULT hr;
 201     DLLREGISTER pfRegister;
 202     HMODULE DllHandle = NULL;
 203
 204     pfRegister = LoadProc(strDll, "DllRegisterServer", &DllHandle, firstDll);
 205     if (!pfRegister)
 206         return GETPROCADDRESS_FAILED;
 207
 208     hr = pfRegister();
 209     if(FAILED(hr))
 210     {
 211         output_write(STRING_REGISTER_FAILED, strDll);
 212         return DLLSERVER_FAILED;
 213     }
 214     output_write(STRING_REGISTER_SUCCESSFUL, strDll);
 215
 216     if(DllHandle)
 217         FreeLibrary(DllHandle);
 218     return 0;
 219 }
 220
 221 static int UnregisterDll(const WCHAR* strDll, BOOL firstDll)
 222 {
 223     HRESULT hr;
 224     DLLUNREGISTER pfUnregister;
 225     HMODULE DllHandle = NULL;
 226
 227     pfUnregister = LoadProc(strDll, "DllUnregisterServer", &DllHandle, firstDll);
 228     if (!pfUnregister)
 229         return GETPROCADDRESS_FAILED;
 230
 231     hr = pfUnregister();
 232     if(FAILED(hr))
 233     {
 234         output_write(STRING_UNREGISTER_FAILED, strDll);
 235         return DLLSERVER_FAILED;
 236     }
 237     output_write(STRING_UNREGISTER_SUCCESSFUL, strDll);
 238
 239     if(DllHandle)
 240         FreeLibrary(DllHandle);
 241     return 0;
 242 }
 243
 244 static int InstallDll(BOOL install, const WCHAR *strDll, const WCHAR *command_line, BOOL firstDll)
 245 {
 246     HRESULT hr;
 247     DLLINSTALL pfInstall;
 248     HMODULE DllHandle = NULL;
 249
 250     pfInstall = LoadProc(strDll, "DllInstall", &DllHandle, firstDll);
 251     if (!pfInstall)
 252         return GETPROCADDRESS_FAILED;
 253
 254     hr = pfInstall(install, command_line);
 255     if(FAILED(hr))
 256     {
 257         if (install)
 258             output_write(STRING_INSTALL_FAILED, strDll);
 259         else
 260             output_write(STRING_UNINSTALL_FAILED, strDll);
 261         return DLLSERVER_FAILED;
 262     }
 263     if (install)
 264         output_write(STRING_INSTALL_SUCCESSFUL, strDll);
 265     else
 266         output_write(STRING_UNINSTALL_SUCCESSFUL, strDll);
 267
 268     if(DllHandle)
 269         FreeLibrary(DllHandle);
 270     return 0;
 271 }
 272
 273 static WCHAR *parse_command_line(WCHAR *command_line)
 274 {
 275     if (command_line[0] == ':' && command_line[1])
 276     {
 277         int len = lstrlenW(command_line);
 278
 279         command_line++;
 280         len--;
 281         /* remove double quotes */
 282         if (command_line[0] == '"')
 283         {
 284             command_line++;
 285             len--;
 286             if (command_line[0])
 287             {
 288                 len--;
 289                 command_line[len] = 0;
 290             }
 291         }
 292         if (command_line[0])
 293             return command_line;
 294     }
 295     return NULL;
 296 }
 297
 298 int __cdecl wmain(int argc, WCHAR* argv[])
 299 {
 300     int             i, res, ret = 0;
 301     BOOL            CallRegister = TRUE;
 302     BOOL            CallInstall = FALSE;
 303     BOOL            Unregister = FALSE;
 304     BOOL            DllFound = FALSE;
 305     WCHAR*          wsCommandLine = NULL;
 306     WCHAR           EmptyLine[] = L"";
 307
 308     OleInitialize(NULL);
 309
 310     /* We mirror the Microsoft version by processing all of the flags before
 311      * the files (e.g. regsvr32 file1 /s file2 is silent even for file1).
 312      *
 313      * Note the complication that this version may be passed Unix format filenames
 314      * which could be mistaken for flags. The Windows version conveniently
 315      * requires each flag to be separate (e.g. no /su), so we will simply
 316      * assume that anything longer than /. is a filename.
 317      */
 318     for(i = 1; i < argc; i++)
 319     {
 320         if (argv[i][0] == '/' || argv[i][0] == '-')
 321         {
 322             if (!argv[i][1])
 323                 return INVALID_ARG;
 324
 325             if (argv[i][2] && argv[i][2] != ':')
 326                 continue;
 327
 328             switch (towlower(argv[i][1]))
 329             {
 330             case 'u':
 331                 Unregister = TRUE;
 332                 break;
 333             case 's':
 334                 Silent = TRUE;
 335                 break;
 336             case 'i':
 337                 CallInstall = TRUE;
 338                 wsCommandLine = parse_command_line(argv[i] + 2); /* argv[i] + strlen("/i") */
 339                 if (!wsCommandLine)
 340                     wsCommandLine = EmptyLine;
 341                 break;
 342             case 'n':
 343                 CallRegister = FALSE;
 344                 break;
 345             case 'c':
 346                 /* console output */;
 347                 break;
 348             default:
 349                 output_write(STRING_UNRECOGNIZED_SWITCH, argv[i]);
 350                 output_write(STRING_USAGE);
 351                 return INVALID_ARG;
 352             }
 353             argv[i] = NULL;
 354         }
 355     }
 356
 357     if (!CallInstall && !CallRegister) /* flags: /n or /u /n */
 358         return INVALID_ARG;
 359
 360     for (i = 1; i < argc; i++)
 361     {
 362         if (argv[i])
 363         {
 364             WCHAR *DllName = argv[i];
 365             BOOL firstDll = !DllFound;
 366             res = 0;
 367
 368             DllFound = TRUE;
 369             if (CallInstall && Unregister)
 370                 res = InstallDll(!Unregister, DllName, wsCommandLine, firstDll);
 371
 372             /* The Windows version stops processing the current file on the first error. */
 373             if (res)
 374             {
 375                 ret = res;
 376                 continue;
 377             }
 378
 379             if (!CallInstall || CallRegister)
 380             {
 381                 if(Unregister)
 382                     res = UnregisterDll(DllName, firstDll);
 383                 else
 384                     res = RegisterDll(DllName, firstDll);
 385             }
 386
 387             if (res)
 388             {
 389                 ret = res;
 390                 continue;
 391             }
 392
 393             if (CallInstall && !Unregister)
 394                 res = InstallDll(!Unregister, DllName, wsCommandLine, firstDll);
 395
 396             if (res)
 397             {
 398                 ret = res;
 399                 continue;
 400             }
 401         }
 402     }
 403
 404     if (!DllFound)
 405     {
 406         output_write(STRING_HEADER);
 407         output_write(STRING_USAGE);
 408         return INVALID_ARG;
 409     }
 410
 411     OleUninitialize();
 412
 413     /* return the most recent error code, even if later DLLs succeed */
 414     return ret;
 415 }