xpcom/tools/registry/regxpcom.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Pierre Phaneuf <pp@ludusdesign.com>
  24  *   Mike Shaver <shaver@mozilla.org>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #include "stdlib.h"
  41 #include "prenv.h"
  42 #include "nspr.h"
  43
  44 #include "nsXPCOMPrivate.h" // for XPCOM_DLL defines.
  45
  46 #include "nsXPCOMGlue.h"
  47 #include "nsIComponentManager.h"
  48 #include "nsIComponentRegistrar.h"
  49 #include "nsIServiceManager.h"
  50 #include "nsCOMPtr.h"
  51 #include "nsILocalFile.h"
  52 #include "nsEmbedString.h"
  53 #include "nsIDirectoryService.h"
  54 #include "nsDirectoryServiceDefs.h"
  55
  56
  57 static PRBool gUnreg = PR_FALSE, gQuiet = PR_FALSE;
  58
  59 static const char* gXPCOMLocation = nsnull;
  60 static const char* gCompRegLocation = nsnull;
  61 static const char* gXPTIDatLocation = nsnull;
  62
  63 class DirectoryServiceProvider : public nsIDirectoryServiceProvider
  64 {
  65   public:
  66   DirectoryServiceProvider() {}
  67
  68   NS_DECL_ISUPPORTS
  69   NS_DECL_NSIDIRECTORYSERVICEPROVIDER
  70
  71   private:
  72   ~DirectoryServiceProvider() {}
  73 };
  74
  75 NS_IMPL_ISUPPORTS1(DirectoryServiceProvider, nsIDirectoryServiceProvider)
  76
  77 NS_IMETHODIMP
  78 DirectoryServiceProvider::GetFile(const char *prop, PRBool *persistent, nsIFile **_retval)
  79 {
  80   nsCOMPtr<nsILocalFile> localFile;
  81   nsresult rv = NS_ERROR_FAILURE;
  82
  83   *_retval = nsnull;
  84   *persistent = PR_TRUE;
  85
  86   const char* fileLocation = nsnull;
  87
  88   if(strcmp(prop, NS_XPCOM_CURRENT_PROCESS_DIR) == 0 && gXPCOMLocation)
  89   {
  90     fileLocation = gXPCOMLocation;
  91   }
  92   else if(strcmp(prop, NS_XPCOM_COMPONENT_REGISTRY_FILE) == 0 && gCompRegLocation)
  93   {
  94     fileLocation = gCompRegLocation;
  95   }
  96   else if(strcmp(prop, NS_XPCOM_XPTI_REGISTRY_FILE) == 0 && gXPTIDatLocation)
  97   {
  98     fileLocation = gXPTIDatLocation;
  99   }
 100   else
 101     return NS_ERROR_FAILURE;
 102
 103   rv = NS_NewNativeLocalFile(nsEmbedCString(fileLocation), PR_TRUE, getter_AddRefs(localFile));
 104   if (NS_FAILED(rv)) return rv;
 105
 106   return localFile->QueryInterface(NS_GET_IID(nsIFile), (void**)_retval);
 107 }
 108
 109 int startup_xpcom()
 110 {
 111   nsresult rv;
 112
 113   if (gXPCOMLocation) {
 114     int len = strlen(gXPCOMLocation);
 115     char* xpcomPath = (char*) malloc(len + sizeof(XPCOM_DLL) + sizeof(XPCOM_FILE_PATH_SEPARATOR) + 1);
 116     sprintf(xpcomPath, "%s" XPCOM_FILE_PATH_SEPARATOR XPCOM_DLL, gXPCOMLocation);
 117
 118     rv = XPCOMGlueStartup(xpcomPath);
 119
 120     free(xpcomPath);
 121
 122     const char* path = getenv(XPCOM_SEARCH_KEY);
 123     if (!path) {
 124       path = "";
 125     }
 126   }
 127   else
 128   {
 129     rv = XPCOMGlueStartup(nsnull);
 130   }
 131
 132   if (NS_FAILED(rv))
 133   {
 134     printf("Can not initialize XPCOM Glue\n");
 135     return -1;
 136   }
 137
 138   DirectoryServiceProvider *provider = new DirectoryServiceProvider();
 139   if ( !provider )
 140   {
 141     NS_WARNING("GRE_Startup failed");
 142     XPCOMGlueShutdown();
 143     return -1;
 144   }
 145
 146   nsCOMPtr<nsILocalFile> file;
 147   if (gXPCOMLocation)
 148   {
 149     rv = NS_NewNativeLocalFile(nsEmbedCString(gXPCOMLocation),
 150                                PR_TRUE,
 151                                getter_AddRefs(file));
 152   }
 153
 154   NS_ADDREF(provider);
 155   rv = NS_InitXPCOM2(nsnull, file, provider);
 156   NS_RELEASE(provider);
 157
 158   if (NS_FAILED(rv)) {
 159     printf("Can not initialize XPCOM\n");
 160     XPCOMGlueShutdown();
 161     return -1;
 162   }
 163
 164   return 0;
 165 }
 166
 167 void shutdown_xpcom()
 168 {
 169   nsresult rv;
 170
 171   rv = NS_ShutdownXPCOM(nsnull);
 172
 173   if (NS_FAILED(rv)) {
 174     printf("Can not shutdown XPCOM cleanly\n");
 175   }
 176
 177   rv = XPCOMGlueShutdown();
 178
 179   if (NS_FAILED(rv)) {
 180     printf("Can not shutdown XPCOM Glue cleanly\n");
 181   }
 182 }
 183
 184
 185 nsresult Register(const char *path)
 186 {
 187   startup_xpcom();
 188
 189   nsresult rv;
 190   nsCOMPtr<nsILocalFile> spec;
 191
 192   if (path) {
 193     rv = NS_NewNativeLocalFile(nsEmbedCString(path),
 194                                PR_TRUE,
 195                                getter_AddRefs(spec));
 196   }
 197
 198   nsCOMPtr<nsIComponentRegistrar> registrar;
 199   rv = NS_GetComponentRegistrar(getter_AddRefs(registrar));
 200   if (NS_FAILED(rv)) {
 201     printf("Can not aquire component registrar\n");
 202     return rv;
 203   }
 204
 205   if (gUnreg)
 206     rv = registrar->AutoUnregister(spec);
 207   else
 208     rv = registrar->AutoRegister(spec);
 209
 210   spec = 0;
 211   registrar = 0;
 212
 213   shutdown_xpcom();
 214   return rv;
 215 }
 216
 217
 218 void ReportSuccess(const char *file)
 219 {
 220   if (gQuiet)
 221     return;
 222
 223   if (gUnreg)
 224     printf("Unregistration successful for %s\n", file);
 225   else
 226     printf("Registration successful for %s\n", file);
 227 }
 228
 229 void ReportError(nsresult err, const char *file)
 230 {
 231   if (gUnreg)
 232     printf("Unregistration failed: (");
 233   else
 234     printf("Registration failed: (");
 235
 236   switch (err)
 237   {
 238     case NS_ERROR_FACTORY_NOT_LOADED:
 239       printf("Factory not loaded");
 240       break;
 241     case NS_NOINTERFACE:
 242       printf("No Interface");
 243       break;
 244     case NS_ERROR_NULL_POINTER:
 245       printf("Null pointer");
 246       break;
 247     case NS_ERROR_OUT_OF_MEMORY:
 248       printf("Out of memory");
 249       break;
 250     default:
 251       printf("%x", (unsigned)err);
 252   }
 253
 254   printf(") %s\n", file);
 255 }
 256
 257 void printHelp()
 258 {
 259   printf(
 260 "Mozilla regxpcom - a registration tool for xpcom components                    \n"
 261 "                                                                               \n"
 262 "Usage: regxpcom [options] [file-or-directory]                                  \n"
 263 "                                                                               \n"
 264 "Options:                                                                       \n"
 265 "         -x path        Specifies the location of a directory containing the   \n"
 266 "                        xpcom library which will be used when registering new  \n"
 267 "                        component libraries.  This path will also be added to  \n"
 268 "                        the \"load library\" path.  If not specified, the      \n"
 269 "                        current working directory will be used.                \n"
 270 "         -c path        Specifies the location of the compreg.dat file.  If    \n"
 271 "                        not specified, the compreg.dat file will be in its     \n"
 272 "                        default location.                                      \n"
 273 "         -d path        Specifies the location of the xpti.dat file.  If not   \n"
 274 "                        specified, the xpti.dat file will be in its default    \n"
 275 "                        location.                                              \n"
 276 "         -a             Option to register all files in the default component  \n"
 277 "                        directories.  This is the default behavior if regxpcom \n"
 278 "                        is called without any arguments.                       \n"
 279 "         -h             Displays this help screen.  Must be the only option    \n"
 280 "                        specified.                                             \n"
 281 "         -u             Option to uninstall the files-or-directory instead of  \n"
 282 "                        registering them.                                      \n"
 283 "         -q             Quiets some of the output of regxpcom.                 \n\n");
 284 }
 285
 286 int ProcessArgs(int argc, char *argv[])
 287 {
 288   int i = 1, result = 0;
 289   nsresult res;
 290
 291   while (i < argc)
 292   {
 293     if (argv[i][0] == '-')
 294     {
 295       int j;
 296       for (j = 1; argv[i][j] != '\0'; j++)
 297       {
 298         switch (argv[i][j])
 299         {
 300           case 'h':
 301             printHelp();
 302             return 0;  // we are all done!
 303
 304           case 'u':
 305             gUnreg = PR_TRUE;
 306             break;
 307
 308           case 'q':
 309             gQuiet = PR_TRUE;
 310             break;
 311
 312           case 'a':
 313           {
 314             res = Register(nsnull);
 315             if (NS_FAILED(res))
 316             {
 317               ReportError(res, "component directory");
 318               result = -1;
 319             }
 320             else
 321             {
 322               ReportSuccess("component directory");
 323             }
 324           }
 325           break;
 326
 327           case 'x':
 328             gXPCOMLocation = argv[++i];
 329             j = strlen(gXPCOMLocation) - 1;
 330             break;
 331
 332           case 'c':
 333             gCompRegLocation = argv[++i];
 334             j = strlen(gCompRegLocation) - 1;
 335             break;
 336
 337           case 'd':
 338             gXPTIDatLocation = argv[++i];
 339             j = strlen(gXPTIDatLocation) - 1;
 340             break;
 341
 342           default:
 343             printf("Unknown option '%c'\n", argv[i][j]);
 344         }
 345       }
 346     }
 347     else
 348     {
 349       res = Register(argv[i]);
 350
 351       if (NS_FAILED(res))
 352       {
 353         ReportError(res, argv[i]);
 354         result = -1;
 355       }
 356       else
 357       {
 358         ReportSuccess(argv[i]);
 359       }
 360     }
 361     i++;
 362   }
 363   return result;
 364 }
 365
 366
 367 int main(int argc, char *argv[])
 368 {
 369   int ret;
 370   nsresult rv;
 371
 372   /* With no arguments, regxpcom will autoregister */
 373   if (argc <= 1)
 374   {
 375     startup_xpcom();
 376     nsCOMPtr<nsIComponentRegistrar> registrar;
 377     rv = NS_GetComponentRegistrar(getter_AddRefs(registrar));
 378     if (NS_FAILED(rv)) {
 379       printf("Can not aquire component registrar\n");
 380       return -1;
 381     }
 382     rv = registrar->AutoRegister(nsnull);
 383     ret = (NS_FAILED(rv)) ? -1 : 0;
 384     registrar = 0;
 385     shutdown_xpcom();
 386   } else
 387     ret = ProcessArgs(argc, argv);
 388
 389   return ret;
 390 }