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  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  *
  22  * This version deliberately differs in error handling compared to the
  23  * windows version.
  24  */
  25
  26 /*
  27  *
  28  *  regsvr32 [/u] [/s] [/n] [/i[:cmdline]] dllname ...
  29  *  [/u]    unregister server
  30  *  [/s]    silent (no message boxes)
  31  *  [/i]    Call DllInstall passing it an optional [cmdline];
  32  *          when used with /u calls dll uninstall.
  33  *  [/n]    Do not call DllRegisterServer; this option must be used with [/i]
  34  *  [/c]    Console output (seems to be deprecated and ignored)
  35  *
  36  *  Note the complication that this version may be passed unix format file names
  37  *  which might be mistaken for flags.  Conveniently the Windows version
  38  *  requires each flag to be separate (e.g. no /su ) and so we will simply
  39  *  assume that anything longer than /. is a filename.
  40  */
  41
  42 /**
  43  * FIXME - currently receives command-line parameters in ASCII only and later
  44  * converts to Unicode. Ideally the function should have wWinMain entry point
  45  * and then work in Unicode only, but it seems Wine does not have necessary
  46  * support.
  47  */
  48
  49 #define WIN32_LEAN_AND_MEAN
  50
  51 #include "config.h"
  52 #include "wine/port.h"
  53
  54 #include <string.h>
  55 #include <windows.h>
  56 #include <ole2.h>
  57 #include "regsvr32.h"
  58 #include "wine/debug.h"
  59
  60 WINE_DEFAULT_DEBUG_CHANNEL(regsvr32);
  61
  62 typedef HRESULT (*DLLREGISTER)          (void);
  63 typedef HRESULT (*DLLUNREGISTER)        (void);
  64 typedef HRESULT (*DLLINSTALL)           (BOOL,LPCWSTR);
  65
  66 static BOOL Silent = FALSE;
  67
  68 static void __cdecl output_write(UINT id, ...)
  69 {
  70     char fmt[1024];
  71     __ms_va_list va_args;
  72     char *str;
  73     DWORD len, nOut, ret;
  74
  75     if (!LoadStringA(GetModuleHandleA(NULL), id, fmt, sizeof(fmt)/sizeof(fmt[0])))
  76     {
  77         WINE_FIXME("LoadString failed with %d\n", GetLastError());
  78         return;
  79     }
  80
  81     __ms_va_start(va_args, id);
  82     SetLastError(NO_ERROR);
  83     len = FormatMessageA(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
  84                          fmt, 0, 0, (LPSTR)&str, 0, &va_args);
  85     __ms_va_end(va_args);
  86     if (len == 0 && GetLastError() != NO_ERROR)
  87     {
  88         WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_a(fmt));
  89         return;
  90     }
  91
  92     ret = WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), str, len, &nOut, NULL);
  93
  94     if (!ret)
  95         WINE_WARN("regsvr32: WriteConsoleA() failed.\n");
  96
  97     LocalFree(str);
  98 }
  99
 100 /**
 101  * Loads procedure.
 102  *
 103  * Parameters:
 104  * strDll - name of the dll.
 105  * procName - name of the procedure to load from dll
 106  * pDllHanlde - output variable receives handle of the loaded dll.
 107  */
 108 static VOID *LoadProc(const char* strDll, const char* procName, HMODULE* DllHandle)
 109 {
 110     VOID* (*proc)(void);
 111
 112     *DllHandle = LoadLibraryExA(strDll, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
 113     if(!*DllHandle)
 114     {
 115         if(!Silent)
 116             output_write(STRING_DLL_LOAD_FAILED, strDll);
 117
 118         ExitProcess(1);
 119     }
 120     proc = (VOID *) GetProcAddress(*DllHandle, procName);
 121     if(!proc)
 122     {
 123         if(!Silent)
 124             output_write(STRING_PROC_NOT_IMPLEMENTED, procName, strDll);
 125         FreeLibrary(*DllHandle);
 126         return NULL;
 127     }
 128     return proc;
 129 }
 130
 131 static int RegisterDll(const char* strDll)
 132 {
 133     HRESULT hr;
 134     DLLREGISTER pfRegister;
 135     HMODULE DllHandle = NULL;
 136
 137     pfRegister = LoadProc(strDll, "DllRegisterServer", &DllHandle);
 138     if (!pfRegister)
 139         return 0;
 140
 141     hr = pfRegister();
 142     if(FAILED(hr))
 143     {
 144         if(!Silent)
 145             output_write(STRING_REGISTER_FAILED, strDll);
 146
 147         return -1;
 148     }
 149     if(!Silent)
 150         output_write(STRING_REGISTER_SUCCESSFUL, strDll);
 151
 152     if(DllHandle)
 153         FreeLibrary(DllHandle);
 154     return 0;
 155 }
 156
 157 static int UnregisterDll(char* strDll)
 158 {
 159     HRESULT hr;
 160     DLLUNREGISTER pfUnregister;
 161     HMODULE DllHandle = NULL;
 162
 163     pfUnregister = LoadProc(strDll, "DllUnregisterServer", &DllHandle);
 164     if (!pfUnregister)
 165         return 0;
 166
 167     hr = pfUnregister();
 168     if(FAILED(hr))
 169     {
 170         if(!Silent)
 171             output_write(STRING_UNREGISTER_FAILED, strDll);
 172
 173         return -1;
 174     }
 175     if(!Silent)
 176         output_write(STRING_UNREGISTER_SUCCESSFUL, strDll);
 177
 178     if(DllHandle)
 179         FreeLibrary(DllHandle);
 180     return 0;
 181 }
 182
 183 static int InstallDll(BOOL install, char *strDll, WCHAR *command_line)
 184 {
 185     HRESULT hr;
 186     DLLINSTALL pfInstall;
 187     HMODULE DllHandle = NULL;
 188
 189     pfInstall = LoadProc(strDll, "DllInstall", &DllHandle);
 190     if (!pfInstall)
 191         return 0;
 192
 193     hr = pfInstall(install, command_line);
 194     if(FAILED(hr))
 195     {
 196         if(!Silent)
 197         {
 198             if (install)
 199                 output_write(STRING_INSTALL_FAILED, strDll);
 200             else
 201                 output_write(STRING_UNINSTALL_FAILED, strDll);
 202         }
 203         return -1;
 204     }
 205     if(!Silent)
 206     {
 207         if (install)
 208             output_write(STRING_INSTALL_SUCCESSFUL, strDll);
 209         else
 210             output_write(STRING_UNINSTALL_SUCCESSFUL, strDll);
 211     }
 212
 213     if(DllHandle)
 214         FreeLibrary(DllHandle);
 215     return 0;
 216 }
 217
 218 int main(int argc, char* argv[])
 219 {
 220     int             i;
 221     BOOL            CallRegister = TRUE;
 222     BOOL            CallInstall = FALSE;
 223     BOOL            Unregister = FALSE;
 224     BOOL            DllFound = FALSE;
 225     WCHAR*          wsCommandLine = NULL;
 226     WCHAR           EmptyLine[1] = {0};
 227
 228     OleInitialize(NULL);
 229
 230     /* Strictly, the Microsoft version processes all the flags before
 231      * the files (e.g. regsvr32 file1 /s file2 is silent even for file1).
 232      * For ease, we will not replicate that and will process the arguments
 233      * in order.
 234      */
 235     for(i = 1; i < argc; i++)
 236     {
 237         if ((!strcasecmp(argv[i], "/u")) ||(!strcasecmp(argv[i], "-u")))
 238                 Unregister = TRUE;
 239         else if ((!strcasecmp(argv[i], "/s"))||(!strcasecmp(argv[i], "-s")))
 240                 Silent = TRUE;
 241         else if ((!strncasecmp(argv[i], "/i", strlen("/i")))||(!strncasecmp(argv[i], "-i", strlen("-i"))))
 242         {
 243             CHAR* command_line = argv[i] + strlen("/i");
 244
 245             CallInstall = TRUE;
 246             if (command_line[0] == ':' && command_line[1])
 247             {
 248                 int len = strlen(command_line);
 249
 250                 command_line++;
 251                 len--;
 252                 /* remove double quotes */
 253                 if (command_line[0] == '"')
 254                 {
 255                     command_line++;
 256                     len--;
 257                     if (command_line[0])
 258                     {
 259                         len--;
 260                         command_line[len] = 0;
 261                     }
 262                 }
 263                 if (command_line[0])
 264                 {
 265                     len = MultiByteToWideChar(CP_ACP, 0, command_line, -1,
 266                                               NULL, 0);
 267                     wsCommandLine = HeapAlloc(GetProcessHeap(), 0,
 268                                               len * sizeof(WCHAR));
 269                     if (wsCommandLine)
 270                         MultiByteToWideChar(CP_ACP, 0, command_line, -1,
 271                                             wsCommandLine, len);
 272                 }
 273                 else
 274                 {
 275                     wsCommandLine = EmptyLine;
 276                 }
 277             }
 278             else
 279             {
 280                 wsCommandLine = EmptyLine;
 281             }
 282         }
 283         else if((!strcasecmp(argv[i], "/n"))||(!strcasecmp(argv[i], "-n")))
 284             CallRegister = FALSE;
 285         else if((!strcasecmp(argv[i], "/c"))||(!strcasecmp(argv[i], "-c")))
 286             /* console output */;
 287         else if (argv[i][0] == '/' && (!argv[i][2] || argv[i][2] == ':'))
 288         {
 289             output_write(STRING_UNRECOGNIZED_SWITCH, argv[i]);
 290             output_write(STRING_USAGE);
 291             return 1;
 292         }
 293         else
 294         {
 295             char *DllName = argv[i];
 296             int res = 0;
 297
 298             DllFound = TRUE;
 299             if (!CallInstall || (CallInstall && CallRegister))
 300             {
 301                 if(Unregister)
 302                     res = UnregisterDll(DllName);
 303                 else
 304                     res = RegisterDll(DllName);
 305             }
 306
 307             if (res)
 308                 return res;
 309             /* Confirmed.  The windows version does stop on the first error.*/
 310
 311             if (CallInstall)
 312             {
 313                 res = InstallDll(!Unregister, DllName, wsCommandLine);
 314             }
 315
 316             if (res)
 317                 return res;
 318         }
 319     }
 320
 321     if (!DllFound)
 322     {
 323         if(!Silent)
 324         {
 325             output_write(STRING_HEADER);
 326             output_write(STRING_USAGE);
 327         }
 328         return 1;
 329     }
 330
 331     OleUninitialize();
 332
 333     return 0;
 334 }