registry/source/registry.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
  23 #include "keyimpl.hxx"
  24 #include "regimpl.hxx"
  25 #include "regkey.hxx"
  26
  27 #if defined(_WIN32)
  28 #include <io.h>
  29 #endif
  30
  31 extern "C" {
  32
  33
  34 //  acquire
  35
  36 static void REGISTRY_CALLTYPE acquire(RegHandle hReg)
  37 {
  38     ORegistry* pReg = static_cast<ORegistry*>(hReg);
  39
  40     if (pReg != nullptr)
  41         pReg->acquire();
  42 }
  43
  44
  45 //  release
  46
  47 static void REGISTRY_CALLTYPE release(RegHandle hReg)
  48 {
  49     ORegistry* pReg = static_cast<ORegistry*>(hReg);
  50
  51     if (pReg && pReg->release() == 0)
  52     {
  53         delete pReg;
  54         hReg = nullptr;
  55     }
  56 }
  57
  58
  59 //  getName
  60
  61 static RegError REGISTRY_CALLTYPE getName(RegHandle hReg, rtl_uString** pName)
  62 {
  63     if (hReg)
  64     {
  65         ORegistry*  pReg = static_cast<ORegistry*>(hReg);
  66         if ( pReg->isOpen() )
  67         {
  68             rtl_uString_assign(pName, pReg->getName().pData);
  69             return RegError::NO_ERROR;
  70         } else
  71         {
  72             rtl_uString_new(pName);
  73             return RegError::REGISTRY_NOT_OPEN;
  74         }
  75     }
  76
  77     rtl_uString_new(pName);
  78     return RegError::INVALID_REGISTRY;
  79 }
  80
  81
  82 //  isReadOnly
  83
  84 static sal_Bool REGISTRY_CALLTYPE isReadOnly(RegHandle hReg)
  85 {
  86     if (hReg)
  87         return static_cast<ORegistry*>(hReg)->isReadOnly();
  88     else
  89         return false;
  90 }
  91
  92
  93 //  createRegistry
  94
  95 static RegError REGISTRY_CALLTYPE createRegistry(rtl_uString* registryName,
  96                                                  RegHandle* phRegistry)
  97 {
  98     RegError ret;
  99
 100     ORegistry* pReg = new ORegistry();
 101     if ((ret = pReg->initRegistry(registryName, RegAccessMode::READWRITE, true/*bCreate*/)) != RegError::NO_ERROR)
 102     {
 103         delete pReg;
 104         *phRegistry = nullptr;
 105         return ret;
 106     }
 107
 108     *phRegistry = pReg;
 109
 110     return RegError::NO_ERROR;
 111 }
 112
 113
 114 //  openRootKey
 115
 116 static RegError REGISTRY_CALLTYPE openRootKey(RegHandle hReg,
 117                                               RegKeyHandle* phRootKey)
 118 {
 119     ORegistry* pReg;
 120
 121     if (hReg)
 122     {
 123         pReg = static_cast<ORegistry*>(hReg);
 124         if (!pReg->isOpen())
 125             return RegError::REGISTRY_NOT_OPEN;
 126     } else
 127     {
 128         phRootKey = nullptr;
 129         return RegError::INVALID_REGISTRY;
 130     }
 131
 132     *phRootKey = pReg->getRootKey();
 133
 134     return RegError::NO_ERROR;
 135 }
 136
 137
 138 //  openRegistry
 139
 140 static RegError REGISTRY_CALLTYPE openRegistry(rtl_uString* registryName,
 141                                                RegHandle* phRegistry,
 142                                                RegAccessMode accessMode)
 143 {
 144     RegError _ret;
 145
 146     ORegistry* pReg = new ORegistry();
 147     if ((_ret = pReg->initRegistry(registryName, accessMode)) != RegError::NO_ERROR)
 148     {
 149         *phRegistry = nullptr;
 150         delete pReg;
 151         return _ret;
 152     }
 153
 154
 155     *phRegistry = pReg;
 156
 157     return RegError::NO_ERROR;
 158 }
 159
 160
 161 //  closeRegistry
 162
 163 static RegError REGISTRY_CALLTYPE closeRegistry(RegHandle hReg)
 164 {
 165     if (hReg)
 166     {
 167         ORegistry *pReg = static_cast<ORegistry*>(hReg);
 168         if (!pReg->isOpen())
 169             return RegError::REGISTRY_NOT_OPEN;
 170
 171         RegError ret = RegError::NO_ERROR;
 172         if (pReg->release() == 0)
 173         {
 174             delete pReg;
 175             hReg = nullptr;
 176         }
 177         else
 178             ret = pReg->closeRegistry();
 179
 180         return ret;
 181     } else
 182     {
 183         return RegError::INVALID_REGISTRY;
 184     }
 185 }
 186
 187
 188 //  destroyRegistry
 189
 190 static RegError REGISTRY_CALLTYPE destroyRegistry(RegHandle hReg,
 191                                                   rtl_uString* registryName)
 192 {
 193     if (hReg)
 194     {
 195         ORegistry *pReg = static_cast<ORegistry*>(hReg);
 196         if (!pReg->isOpen())
 197             return RegError::INVALID_REGISTRY;
 198
 199         RegError ret = pReg->destroyRegistry(registryName);
 200         if (ret == RegError::NO_ERROR)
 201         {
 202             if (!registryName->length)
 203             {
 204                 delete pReg;
 205                 hReg = nullptr;
 206             }
 207         }
 208         return ret;
 209     } else
 210     {
 211         return RegError::INVALID_REGISTRY;
 212     }
 213 }
 214
 215
 216 //  mergeKey
 217
 218 static RegError REGISTRY_CALLTYPE mergeKey(RegHandle hReg,
 219                                               RegKeyHandle hKey,
 220                                            rtl_uString* keyName,
 221                                            rtl_uString* regFileName,
 222                                            sal_Bool bWarnings,
 223                                            sal_Bool bReport)
 224 {
 225     ORegistry* pReg = static_cast< ORegistry* >(hReg);
 226     if (!pReg)
 227         return RegError::INVALID_REGISTRY;
 228     if (!pReg->isOpen())
 229         return RegError::REGISTRY_NOT_OPEN;
 230
 231     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 232     if (!pKey)
 233         return RegError::INVALID_KEY;
 234     if (pKey->getRegistry() != pReg)
 235         return RegError::INVALID_KEY;
 236     if (pKey->isDeleted())
 237         return RegError::INVALID_KEY;
 238     if (pKey->isReadOnly())
 239         return RegError::REGISTRY_READONLY;
 240
 241     if (keyName->length)
 242     {
 243         ORegKey* pNewKey = nullptr;
 244         RegError _ret = pKey->createKey(keyName, reinterpret_cast<RegKeyHandle*>(&pNewKey));
 245         if (_ret != RegError::NO_ERROR)
 246             return _ret;
 247
 248         _ret = pReg->loadKey(pNewKey, regFileName, bWarnings, bReport);
 249         if (_ret != RegError::NO_ERROR && (_ret != RegError::MERGE_CONFLICT || bWarnings))
 250         {
 251             if (pNewKey != pKey)
 252                 (void) pKey->closeKey(pNewKey);
 253             else
 254                 (void) pKey->releaseKey(pNewKey);
 255             return _ret;
 256         }
 257
 258         return (pNewKey != pKey) ? pKey->closeKey(pNewKey) : pKey->releaseKey(pNewKey);
 259     }
 260
 261     return pReg->loadKey(pKey, regFileName, bWarnings, bReport);
 262 }
 263
 264
 265 //  dumpRegistry
 266
 267 static RegError REGISTRY_CALLTYPE dumpRegistry(RegHandle hReg,
 268                                                RegKeyHandle hKey)
 269 {
 270     ORegistry* pReg = static_cast< ORegistry* >(hReg);
 271     if (!pReg)
 272         return RegError::INVALID_REGISTRY;
 273     if (!pReg->isOpen())
 274         return RegError::REGISTRY_NOT_OPEN;
 275
 276     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 277     if (!pKey)
 278         return RegError::INVALID_KEY;
 279     if (pKey->getRegistry() != pReg)
 280         return RegError::INVALID_KEY;
 281     if (pKey->isDeleted())
 282         return RegError::INVALID_KEY;
 283
 284     return pReg->dumpRegistry(hKey);
 285 }
 286
 287
 288 //  initRegistry_Api
 289
 290 Registry_Api* REGISTRY_CALLTYPE initRegistry_Api()
 291 {
 292     static Registry_Api aApi= {&acquire,
 293                                &release,
 294                                &isReadOnly,
 295                                &openRootKey,
 296                                &getName,
 297                                &createRegistry,
 298                                &openRegistry,
 299                                &closeRegistry,
 300                                &destroyRegistry,
 301                                &mergeKey,
 302                                &acquireKey,
 303                                &releaseKey,
 304                                &isKeyReadOnly,
 305                                &getKeyName,
 306                                &createKey,
 307                                &openKey,
 308                                &openSubKeys,
 309                                &closeSubKeys,
 310                                &deleteKey,
 311                                &closeKey,
 312                                &setValue,
 313                                &setLongListValue,
 314                                &setStringListValue,
 315                                &setUnicodeListValue,
 316                                &getValueInfo,
 317                                &getValue,
 318                                &getLongListValue,
 319                                &getStringListValue,
 320                                &getUnicodeListValue,
 321                                &freeValueList,
 322                                &getResolvedKeyName,
 323                                &getKeyNames,
 324                                &freeKeyNames};
 325
 326     return (&aApi);
 327 }
 328
 329 }
 330
 331
 332 //  reg_openRootKey
 333
 334 RegError REGISTRY_CALLTYPE reg_openRootKey(RegHandle hRegistry,
 335                                           RegKeyHandle* phRootKey)
 336 {
 337     return openRootKey(hRegistry, phRootKey);
 338 }
 339
 340
 341 //  reg_openRegistry
 342
 343 RegError REGISTRY_CALLTYPE reg_openRegistry(rtl_uString* registryName,
 344                                             RegHandle* phRegistry)
 345 {
 346     RegError _ret;
 347
 348     ORegistry* pReg = new ORegistry();
 349     if ((_ret = pReg->initRegistry(registryName, RegAccessMode::READONLY)) != RegError::NO_ERROR)
 350     {
 351         delete pReg;
 352         *phRegistry = nullptr;
 353         return _ret;
 354     }
 355
 356     *phRegistry = pReg;
 357
 358     return RegError::NO_ERROR;
 359 }
 360
 361
 362 //  reg_closeRegistry
 363
 364 RegError REGISTRY_CALLTYPE reg_closeRegistry(RegHandle hRegistry)
 365 {
 366     if (hRegistry)
 367     {
 368         ORegistry* pReg = static_cast<ORegistry*>(hRegistry);
 369         delete pReg;
 370         return RegError::NO_ERROR;
 371     } else
 372     {
 373         return RegError::REGISTRY_NOT_OPEN;
 374     }
 375 }
 376
 377
 378 //  reg_dumpRegistry
 379
 380 RegError REGISTRY_CALLTYPE reg_dumpRegistry(RegKeyHandle hKey)
 381 {
 382     ORegKey *pKey;
 383
 384     if (hKey)
 385         pKey = static_cast<ORegKey*>(hKey);
 386     else
 387         return RegError::INVALID_KEY;
 388
 389     return dumpRegistry(pKey->getRegistry(), hKey);
 390 }
 391
 392
 393 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */