registry/tools/regmerge.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <registry/registry.hxx>
  22 #include "fileurl.hxx"
  23 #include "options.hxx"
  24
  25 #include <rtl/ustring.hxx>
  26 #include <sal/log.hxx>
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 using namespace registry::tools;
  32
  33 namespace {
  34
  35 class Options_Impl : public Options
  36 {
  37     bool m_bVerbose;
  38
  39 public:
  40     explicit Options_Impl (char const * program)
  41         : Options(program), m_bVerbose(false)
  42     {}
  43     bool isVerbose() const { return m_bVerbose; }
  44
  45 protected:
  46     virtual void printUsage_Impl() const override;
  47     virtual bool initOptions_Impl(std::vector< std::string > & rArgs) override;
  48 };
  49
  50 }
  51
  52 void Options_Impl::printUsage_Impl() const
  53 {
  54     fprintf(stderr, "using: regmerge [-v|--verbose] mergefile mergeKeyName regfile_1 ... regfile_n\n");
  55     fprintf(stderr, "       regmerge @regcmds\nOptions:\n");
  56     fprintf(stderr, "  -v, --verbose : verbose output on stdout.\n");
  57     fprintf(stderr, "  mergefile     : specifies the merged registry file. If this file doesn't exists,\n");
  58     fprintf(stderr, "                  it is created.\n");
  59     fprintf(stderr, "  mergeKeyName  : specifies the merge key, everything is merged under this key.\n");
  60     fprintf(stderr, "                  If this key doesn't exists, it is created.\n");
  61     fprintf(stderr, "  regfile_1..n  : specifies one or more registry files which are merged.\n");
  62 }
  63
  64 bool Options_Impl::initOptions_Impl (std::vector< std::string > & rArgs)
  65 {
  66     std::vector< std::string >::iterator first = rArgs.begin(), last = rArgs.end();
  67     if ((first != last) && ((*first)[0] == '-'))
  68     {
  69         std::string option(*first);
  70         if ((option.compare("-v") == 0) || (option.compare("--verbose") == 0))
  71         {
  72             m_bVerbose = true;
  73         }
  74         else if ((option.compare("-h") == 0) || (option.compare("-?") == 0))
  75         {
  76             return printUsage();
  77         }
  78         else
  79         {
  80             return badOption("unknown", option.c_str());
  81         }
  82         (void) rArgs.erase(first);
  83     }
  84     return true;
  85 }
  86
  87 #if (defined UNX)
  88 int main( int argc, char * argv[] )
  89 #else
  90 int __cdecl main( int argc, char * argv[] )
  91 #endif
  92 {
  93     try
  94     {
  95         Options_Impl options(argv[0]);
  96
  97         std::vector< std::string > args;
  98         for (int i = 1; i < argc; i++)
  99         {
 100             if (!Options::checkArgument(args, argv[i], strlen(argv[i])))
 101             {
 102                 options.printUsage();
 103                 return 1;
 104             }
 105         }
 106         if (!options.initOptions(args))
 107         {
 108             return 1;
 109         }
 110         if (args.size() < 3)
 111         {
 112             options.printUsage();
 113             return 1;
 114         }
 115
 116         Registry reg;
 117         OUString regName( convertToFileUrl(args[0].c_str(), args[0].size()) );
 118         if (reg.open(regName, RegAccessMode::READWRITE) != RegError::NO_ERROR)
 119         {
 120             if (reg.create(regName) != RegError::NO_ERROR)
 121             {
 122                 if (options.isVerbose())
 123                     fprintf(stderr, "open registry \"%s\" failed\n", args[0].c_str());
 124                 return -1;
 125             }
 126         }
 127
 128         RegistryKey rootKey;
 129         if (reg.openRootKey(rootKey) != RegError::NO_ERROR)
 130         {
 131             if (options.isVerbose())
 132                 fprintf(stderr, "open root key of registry \"%s\" failed\n", args[0].c_str());
 133             return -4;
 134         }
 135
 136         OUString mergeKeyName( OUString::createFromAscii(args[1].c_str()) );
 137         for (size_t i = 2; i < args.size(); i++)
 138         {
 139             OUString targetRegName( convertToFileUrl(args[i].c_str(), args[i].size()) );
 140             RegError _ret = reg.mergeKey(rootKey, mergeKeyName, targetRegName, options.isVerbose());
 141             if (_ret != RegError::NO_ERROR)
 142             {
 143                 if (_ret == RegError::MERGE_CONFLICT)
 144                 {
 145                     if (options.isVerbose())
 146                         fprintf(stderr, "merging registry \"%s\" under key \"%s\" in registry \"%s\".\n",
 147                                 args[i].c_str(), args[1].c_str(), args[0].c_str());
 148                 }
 149                 else
 150                 {
 151                     if (options.isVerbose())
 152                         fprintf(stderr, "ERROR: merging registry \"%s\" under key \"%s\" in registry \"%s\" failed.\n",
 153                                 args[i].c_str(), args[1].c_str(), args[0].c_str());
 154                     return -2;
 155                 }
 156             }
 157             else
 158             {
 159                 if (options.isVerbose())
 160                     fprintf(stderr, "merging registry \"%s\" under key \"%s\" in registry \"%s\".\n",
 161                             args[i].c_str(), args[1].c_str(), args[0].c_str());
 162             }
 163         }
 164
 165         rootKey.releaseKey();
 166         if (reg.close() != RegError::NO_ERROR)
 167         {
 168             if (options.isVerbose())
 169                 fprintf(stderr, "closing registry \"%s\" failed\n", args[0].c_str());
 170             return -5;
 171         }
 172     }
 173     catch (const std::exception &e)
 174     {
 175         SAL_WARN("registry", "Fatal exception: " << e.what());
 176         return -5;
 177     }
 178
 179
 180     return 0;
 181 }
 182
 183 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */