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 (Silent) return;
  76
  77     if (!LoadStringA(GetModuleHandleA(NULL), id, fmt, sizeof(fmt)/sizeof(fmt[0])))
  78     {
  79         WINE_FIXME("LoadString failed with %d\n", GetLastError());
  80         return;
  81     }
  82
  83     __ms_va_start(va_args, id);
  84     SetLastError(NO_ERROR);
  85     len = FormatMessageA(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
  86                          fmt, 0, 0, (LPSTR)&str, 0, &va_args);
  87     __ms_va_end(va_args);
  88     if (len == 0 && GetLastError() != NO_ERROR)
  89     {
  90         WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_a(fmt));
  91         return;
  92     }
  93
  94     ret = WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), str, len, &nOut, NULL);
  95
  96     if (!ret)
  97         WINE_WARN("regsvr32: WriteConsoleA() failed.\n");
  98
  99     LocalFree(str);
 100 }
 101
 102 /**
 103  * Loads procedure.
 104  *
 105  * Parameters:
 106  * strDll - name of the dll.
 107  * procName - name of the procedure to load from dll
 108  * pDllHanlde - output variable receives handle of the loaded dll.
 109  */
 110 static VOID *LoadProc(const char* strDll, const char* procName, HMODULE* DllHandle)
 111 {
 112     VOID* (*proc)(void);
 113
 114     *DllHandle = LoadLibraryExA(strDll, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
 115     if(!*DllHandle)
 116     {
 117         output_write(STRING_DLL_LOAD_FAILED, strDll);
 118         ExitProcess(1);
 119     }
 120     proc = (VOID *) GetProcAddress(*DllHandle, procName);
 121     if(!proc)
 122     {
 123         output_write(STRING_PROC_NOT_IMPLEMENTED, procName, strDll);
 124         FreeLibrary(*DllHandle);
 125         return NULL;
 126     }
 127     return proc;
 128 }
 129
 130 static int RegisterDll(const char* strDll)
 131 {
 132     HRESULT hr;
 133     DLLREGISTER pfRegister;
 134     HMODULE DllHandle = NULL;
 135
 136     pfRegister = LoadProc(strDll, "DllRegisterServer", &DllHandle);
 137     if (!pfRegister)
 138         return 0;
 139
 140     hr = pfRegister();
 141     if(FAILED(hr))
 142     {
 143         output_write(STRING_REGISTER_FAILED, strDll);
 144         return -1;
 145     }
 146     output_write(STRING_REGISTER_SUCCESSFUL, strDll);
 147
 148     if(DllHandle)
 149         FreeLibrary(DllHandle);
 150     return 0;
 151 }
 152
 153 static int UnregisterDll(char* strDll)
 154 {
 155     HRESULT hr;
 156     DLLUNREGISTER pfUnregister;
 157     HMODULE DllHandle = NULL;
 158
 159     pfUnregister = LoadProc(strDll, "DllUnregisterServer", &DllHandle);
 160     if (!pfUnregister)
 161         return 0;
 162
 163     hr = pfUnregister();
 164     if(FAILED(hr))
 165     {
 166         output_write(STRING_UNREGISTER_FAILED, strDll);
 167         return -1;
 168     }
 169     output_write(STRING_UNREGISTER_SUCCESSFUL, strDll);
 170
 171     if(DllHandle)
 172         FreeLibrary(DllHandle);
 173     return 0;
 174 }
 175
 176 static int InstallDll(BOOL install, char *strDll, WCHAR *command_line)
 177 {
 178     HRESULT hr;
 179     DLLINSTALL pfInstall;
 180     HMODULE DllHandle = NULL;
 181
 182     pfInstall = LoadProc(strDll, "DllInstall", &DllHandle);
 183     if (!pfInstall)
 184         return 0;
 185
 186     hr = pfInstall(install, command_line);
 187     if(FAILED(hr))
 188     {
 189         if (install)
 190             output_write(STRING_INSTALL_FAILED, strDll);
 191         else
 192             output_write(STRING_UNINSTALL_FAILED, strDll);
 193         return -1;
 194     }
 195     if (install)
 196         output_write(STRING_INSTALL_SUCCESSFUL, strDll);
 197     else
 198         output_write(STRING_UNINSTALL_SUCCESSFUL, strDll);
 199
 200     if(DllHandle)
 201         FreeLibrary(DllHandle);
 202     return 0;
 203 }
 204
 205 int main(int argc, char* argv[])
 206 {
 207     int             i;
 208     BOOL            CallRegister = TRUE;
 209     BOOL            CallInstall = FALSE;
 210     BOOL            Unregister = FALSE;
 211     BOOL            DllFound = FALSE;
 212     WCHAR*          wsCommandLine = NULL;
 213     WCHAR           EmptyLine[1] = {0};
 214
 215     OleInitialize(NULL);
 216
 217     /* Strictly, the Microsoft version processes all the flags before
 218      * the files (e.g. regsvr32 file1 /s file2 is silent even for file1).
 219      * For ease, we will not replicate that and will process the arguments
 220      * in order.
 221      */
 222     for(i = 1; i < argc; i++)
 223     {
 224         if ((!strcasecmp(argv[i], "/u")) ||(!strcasecmp(argv[i], "-u")))
 225                 Unregister = TRUE;
 226         else if ((!strcasecmp(argv[i], "/s"))||(!strcasecmp(argv[i], "-s")))
 227                 Silent = TRUE;
 228         else if ((!strncasecmp(argv[i], "/i", strlen("/i")))||(!strncasecmp(argv[i], "-i", strlen("-i"))))
 229         {
 230             CHAR* command_line = argv[i] + strlen("/i");
 231
 232             CallInstall = TRUE;
 233             if (command_line[0] == ':' && command_line[1])
 234             {
 235                 int len = strlen(command_line);
 236
 237                 command_line++;
 238                 len--;
 239                 /* remove double quotes */
 240                 if (command_line[0] == '"')
 241                 {
 242                     command_line++;
 243                     len--;
 244                     if (command_line[0])
 245                     {
 246                         len--;
 247                         command_line[len] = 0;
 248                     }
 249                 }
 250                 if (command_line[0])
 251                 {
 252                     len = MultiByteToWideChar(CP_ACP, 0, command_line, -1,
 253                                               NULL, 0);
 254                     wsCommandLine = HeapAlloc(GetProcessHeap(), 0,
 255                                               len * sizeof(WCHAR));
 256                     if (wsCommandLine)
 257                         MultiByteToWideChar(CP_ACP, 0, command_line, -1,
 258                                             wsCommandLine, len);
 259                 }
 260                 else
 261                 {
 262                     wsCommandLine = EmptyLine;
 263                 }
 264             }
 265             else
 266             {
 267                 wsCommandLine = EmptyLine;
 268             }
 269         }
 270         else if((!strcasecmp(argv[i], "/n"))||(!strcasecmp(argv[i], "-n")))
 271             CallRegister = FALSE;
 272         else if((!strcasecmp(argv[i], "/c"))||(!strcasecmp(argv[i], "-c")))
 273             /* console output */;
 274         else if (argv[i][0] == '/' && (!argv[i][2] || argv[i][2] == ':'))
 275         {
 276             output_write(STRING_UNRECOGNIZED_SWITCH, argv[i]);
 277             output_write(STRING_USAGE);
 278             return 1;
 279         }
 280         else
 281         {
 282             char *DllName = argv[i];
 283             int res = 0;
 284
 285             DllFound = TRUE;
 286             if (!CallInstall || (CallInstall && CallRegister))
 287             {
 288                 if(Unregister)
 289                     res = UnregisterDll(DllName);
 290                 else
 291                     res = RegisterDll(DllName);
 292             }
 293
 294             if (res)
 295                 return res;
 296             /* Confirmed.  The windows version does stop on the first error.*/
 297
 298             if (CallInstall)
 299             {
 300                 res = InstallDll(!Unregister, DllName, wsCommandLine);
 301             }
 302
 303             if (res)
 304                 return res;
 305         }
 306     }
 307
 308     if (!DllFound)
 309     {
 310         output_write(STRING_HEADER);
 311         output_write(STRING_USAGE);
 312         return 1;
 313     }
 314
 315     OleUninitialize();
 316
 317     return 0;
 318 }