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 static void REGISTRY_CALLTYPE acquire(RegHandle hReg)
  34 {
  35     ORegistry* pReg = static_cast<ORegistry*>(hReg);
  36
  37     if (pReg != nullptr)
  38         pReg->acquire();
  39 }
  40
  41 static void REGISTRY_CALLTYPE release(RegHandle hReg)
  42 {
  43     ORegistry* pReg = static_cast<ORegistry*>(hReg);
  44
  45     if (pReg && pReg->release() == 0)
  46     {
  47         delete pReg;
  48         hReg = nullptr;
  49     }
  50 }
  51
  52 static RegError REGISTRY_CALLTYPE getName(RegHandle hReg, rtl_uString** pName)
  53 {
  54     if (hReg)
  55     {
  56         ORegistry*  pReg = static_cast<ORegistry*>(hReg);
  57         if ( pReg->isOpen() )
  58         {
  59             rtl_uString_assign(pName, pReg->getName().pData);
  60             return RegError::NO_ERROR;
  61         } else
  62         {
  63             rtl_uString_new(pName);
  64             return RegError::REGISTRY_NOT_OPEN;
  65         }
  66     }
  67
  68     rtl_uString_new(pName);
  69     return RegError::INVALID_REGISTRY;
  70 }
  71
  72 static sal_Bool REGISTRY_CALLTYPE isReadOnly(RegHandle hReg)
  73 {
  74     if (hReg)
  75         return static_cast<ORegistry*>(hReg)->isReadOnly();
  76     else
  77         return false;
  78 }
  79
  80 static RegError REGISTRY_CALLTYPE createRegistry(rtl_uString* registryName,
  81                                                  RegHandle* phRegistry)
  82 {
  83     RegError ret;
  84
  85     ORegistry* pReg = new ORegistry();
  86     if ((ret = pReg->initRegistry(registryName, RegAccessMode::READWRITE, true/*bCreate*/)) != RegError::NO_ERROR)
  87     {
  88         delete pReg;
  89         *phRegistry = nullptr;
  90         return ret;
  91     }
  92
  93     *phRegistry = pReg;
  94
  95     return RegError::NO_ERROR;
  96 }
  97
  98 static RegError REGISTRY_CALLTYPE openRootKey(RegHandle hReg,
  99                                               RegKeyHandle* phRootKey)
 100 {
 101     ORegistry* pReg;
 102
 103     if (hReg)
 104     {
 105         pReg = static_cast<ORegistry*>(hReg);
 106         if (!pReg->isOpen())
 107             return RegError::REGISTRY_NOT_OPEN;
 108     } else
 109     {
 110         phRootKey = nullptr;
 111         return RegError::INVALID_REGISTRY;
 112     }
 113
 114     *phRootKey = pReg->getRootKey();
 115
 116     return RegError::NO_ERROR;
 117 }
 118
 119 static RegError REGISTRY_CALLTYPE openRegistry(rtl_uString* registryName,
 120                                                RegHandle* phRegistry,
 121                                                RegAccessMode accessMode)
 122 {
 123     RegError _ret;
 124
 125     ORegistry* pReg = new ORegistry();
 126     if ((_ret = pReg->initRegistry(registryName, accessMode)) != RegError::NO_ERROR)
 127     {
 128         *phRegistry = nullptr;
 129         delete pReg;
 130         return _ret;
 131     }
 132
 133
 134     *phRegistry = pReg;
 135
 136     return RegError::NO_ERROR;
 137 }
 138
 139 static RegError REGISTRY_CALLTYPE closeRegistry(RegHandle hReg)
 140 {
 141     if (hReg)
 142     {
 143         ORegistry *pReg = static_cast<ORegistry*>(hReg);
 144         if (!pReg->isOpen())
 145             return RegError::REGISTRY_NOT_OPEN;
 146
 147         RegError ret = RegError::NO_ERROR;
 148         if (pReg->release() == 0)
 149         {
 150             delete pReg;
 151             hReg = nullptr;
 152         }
 153         else
 154             ret = pReg->closeRegistry();
 155
 156         return ret;
 157     } else
 158     {
 159         return RegError::INVALID_REGISTRY;
 160     }
 161 }
 162
 163 static RegError REGISTRY_CALLTYPE destroyRegistry(RegHandle hReg,
 164                                                   rtl_uString* registryName)
 165 {
 166     if (hReg)
 167     {
 168         ORegistry *pReg = static_cast<ORegistry*>(hReg);
 169         if (!pReg->isOpen())
 170             return RegError::INVALID_REGISTRY;
 171
 172         RegError ret = pReg->destroyRegistry(registryName);
 173         if (ret == RegError::NO_ERROR)
 174         {
 175             if (!registryName->length)
 176             {
 177                 delete pReg;
 178                 hReg = nullptr;
 179             }
 180         }
 181         return ret;
 182     } else
 183     {
 184         return RegError::INVALID_REGISTRY;
 185     }
 186 }
 187
 188
 189 //  dumpRegistry
 190
 191 static RegError REGISTRY_CALLTYPE dumpRegistry(RegHandle hReg,
 192                                                RegKeyHandle hKey)
 193 {
 194     ORegistry* pReg = static_cast< ORegistry* >(hReg);
 195     if (!pReg)
 196         return RegError::INVALID_REGISTRY;
 197     if (!pReg->isOpen())
 198         return RegError::REGISTRY_NOT_OPEN;
 199
 200     ORegKey* pKey = static_cast< ORegKey* >(hKey);
 201     if (!pKey)
 202         return RegError::INVALID_KEY;
 203     if (pKey->getRegistry() != pReg)
 204         return RegError::INVALID_KEY;
 205     if (pKey->isDeleted())
 206         return RegError::INVALID_KEY;
 207
 208     return pReg->dumpRegistry(hKey);
 209 }
 210
 211 Registry_Api* REGISTRY_CALLTYPE initRegistry_Api()
 212 {
 213     static Registry_Api aApi= {&acquire,
 214                                &release,
 215                                &isReadOnly,
 216                                &openRootKey,
 217                                &getName,
 218                                &createRegistry,
 219                                &openRegistry,
 220                                &closeRegistry,
 221                                &destroyRegistry,
 222                                &acquireKey,
 223                                &releaseKey,
 224                                &isKeyReadOnly,
 225                                &getKeyName,
 226                                &createKey,
 227                                &openKey,
 228                                &openSubKeys,
 229                                &closeSubKeys,
 230                                &deleteKey,
 231                                &closeKey,
 232                                &setValue,
 233                                &setLongListValue,
 234                                &setStringListValue,
 235                                &setUnicodeListValue,
 236                                &getValueInfo,
 237                                &getValue,
 238                                &getLongListValue,
 239                                &getStringListValue,
 240                                &getUnicodeListValue,
 241                                &freeValueList,
 242                                &getResolvedKeyName,
 243                                &getKeyNames,
 244                                &freeKeyNames};
 245
 246     return (&aApi);
 247 }
 248
 249 }
 250
 251 RegError REGISTRY_CALLTYPE reg_openRootKey(RegHandle hRegistry,
 252                                           RegKeyHandle* phRootKey)
 253 {
 254     return openRootKey(hRegistry, phRootKey);
 255 }
 256
 257 RegError REGISTRY_CALLTYPE reg_openRegistry(rtl_uString* registryName,
 258                                             RegHandle* phRegistry)
 259 {
 260     RegError _ret;
 261
 262     ORegistry* pReg = new ORegistry();
 263     if ((_ret = pReg->initRegistry(registryName, RegAccessMode::READONLY)) != RegError::NO_ERROR)
 264     {
 265         delete pReg;
 266         *phRegistry = nullptr;
 267         return _ret;
 268     }
 269
 270     *phRegistry = pReg;
 271
 272     return RegError::NO_ERROR;
 273 }
 274
 275 RegError REGISTRY_CALLTYPE reg_closeRegistry(RegHandle hRegistry)
 276 {
 277     if (hRegistry)
 278     {
 279         ORegistry* pReg = static_cast<ORegistry*>(hRegistry);
 280         delete pReg;
 281         return RegError::NO_ERROR;
 282     } else
 283     {
 284         return RegError::REGISTRY_NOT_OPEN;
 285     }
 286 }
 287
 288 RegError REGISTRY_CALLTYPE reg_dumpRegistry(RegKeyHandle hKey)
 289 {
 290     ORegKey *pKey;
 291
 292     if (hKey)
 293         pKey = static_cast<ORegKey*>(hKey);
 294     else
 295         return RegError::INVALID_KEY;
 296
 297     return dumpRegistry(pKey->getRegistry(), hKey);
 298 }
 299
 300
 301 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */