dep/ACE_wrappers/ace/Configuration.cpp

   1 // $Id: Configuration.cpp 80826 2008-03-04 14:51:23Z wotte $
   2 #include "ace/Configuration.h"
   3 #include "ace/Auto_Ptr.h"
   4 #include "ace/SString.h"
   5 #include "ace/OS_NS_string.h"
   6 #include "ace/OS_NS_strings.h"
   7
   8 // Can remove this when import_config and export_config are removed from
   9 // ACE_Configuration. They're deprecated at ACE 5.2.
  10 #include "ace/Configuration_Import_Export.h"
  11
  12 #if !defined (ACE_LACKS_ACCESS)
  13 #  include "ace/OS_NS_unistd.h"
  14 #endif /* ACE_LACKS_ACCESS */
  15
  16 #if !defined (__ACE_INLINE__)
  17 #include "ace/Configuration.inl"
  18 #endif /* __ACE_INLINE__ */
  19
  20 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  21
  22 ACE_Section_Key_Internal::ACE_Section_Key_Internal (void)
  23   : ref_count_ (0)
  24 {
  25 }
  26
  27 ACE_Section_Key_Internal::~ACE_Section_Key_Internal (void)
  28 {
  29 }
  30
  31 int
  32 ACE_Section_Key_Internal::add_ref (void)
  33 {
  34   ++ref_count_;
  35   return 0;
  36 }
  37
  38 int
  39 ACE_Section_Key_Internal::dec_ref (void)
  40 {
  41   if (!--ref_count_)
  42     delete this;
  43   return 0;
  44 }
  45
  46 ACE_Configuration_Section_Key::ACE_Configuration_Section_Key (void)
  47   : key_ (0)
  48 {
  49 }
  50
  51 ACE_Configuration_Section_Key::~ACE_Configuration_Section_Key (void)
  52 {
  53   if (key_)
  54     key_->dec_ref ();
  55 }
  56
  57 ACE_Configuration_Section_Key::ACE_Configuration_Section_Key (ACE_Section_Key_Internal* key)
  58   : key_ (key)
  59 {
  60   if (key_)
  61     key_->add_ref ();
  62 }
  63
  64 ACE_Configuration_Section_Key::ACE_Configuration_Section_Key (const ACE_Configuration_Section_Key& rhs)
  65   : key_ (rhs.key_)
  66 {
  67   if (key_)
  68     key_->add_ref ();
  69 }
  70
  71 ACE_Configuration_Section_Key&
  72 ACE_Configuration_Section_Key::operator= (const ACE_Configuration_Section_Key& rhs)
  73 {
  74   if (this != &rhs)
  75     {
  76       if (key_)
  77         key_->dec_ref ();
  78
  79       key_ = rhs.key_;
  80
  81       if (key_)
  82         key_->add_ref ();
  83     }
  84   return *this;
  85 }
  86
  87 //////////////////////////////////////////////////////////////////////////////
  88
  89 ACE_TCHAR ACE_Configuration::NULL_String_ = '\0';
  90
  91 ACE_Configuration::ACE_Configuration (void)
  92   : root_ ()
  93 {
  94 }
  95
  96 ACE_Configuration::~ACE_Configuration (void)
  97 {
  98 }
  99
 100 ACE_Section_Key_Internal*
 101 ACE_Configuration::get_internal_key (const ACE_Configuration_Section_Key& key)
 102 {
 103   return key.key_;
 104 }
 105
 106 int
 107 ACE_Configuration::expand_path (const ACE_Configuration_Section_Key& key,
 108                                 const ACE_TString& path_in,
 109                                 ACE_Configuration_Section_Key& key_out,
 110                                 int create)
 111 {
 112   // Make a copy of key
 113   ACE_Configuration_Section_Key current_section = key;
 114   ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> pData (path_in.rep ());
 115   ACE_Tokenizer parser (pData.get ());
 116   parser.delimiter_replace ('\\', '\0');
 117   parser.delimiter_replace ('/', '\0');
 118
 119   for (ACE_TCHAR *temp = parser.next ();
 120        temp != 0;
 121        temp = parser.next ())
 122     {
 123       // Open the section
 124       if (open_section (current_section,
 125                         temp,
 126                         create,
 127                         key_out))
 128         return -1;
 129
 130       current_section = key_out;
 131     }
 132
 133   return 0;
 134
 135 }
 136
 137 // import_config and export_config are here for backward compatibility,
 138 // and have been deprecated.
 139 int
 140 ACE_Configuration::export_config (const ACE_TCHAR* filename)
 141 {
 142   ACE_Registry_ImpExp exporter (*this);
 143   return exporter.export_config (filename);
 144 }
 145
 146 int
 147 ACE_Configuration::import_config (const ACE_TCHAR* filename)
 148 {
 149   ACE_Registry_ImpExp importer (*this);
 150   return importer.import_config (filename);
 151 }
 152
 153 int
 154 ACE_Configuration::validate_name (const ACE_TCHAR* name, int allow_path)
 155 {
 156   // Invalid character set
 157   const ACE_TCHAR* reject =
 158     allow_path ? ACE_TEXT ("][") : ACE_TEXT ("\\][");
 159
 160   // Position of the first invalid character or terminating null.
 161   size_t const pos = ACE_OS::strcspn (name, reject);
 162
 163   // Check if it is an invalid character.
 164   if (name[pos] != ACE_TEXT ('\0'))
 165     {
 166       errno = EINVAL;
 167       return -1;
 168     }
 169
 170   // The first character can never be a path separator.
 171   if (name[0] == ACE_TEXT ('\\'))
 172     {
 173       errno = EINVAL;
 174       return -1;
 175     }
 176
 177   // Validate length.
 178   if (pos == 0 || pos > 255)
 179     {
 180       errno = ENAMETOOLONG;
 181       return -1;
 182     }
 183
 184   return 0;
 185 }
 186
 187 int
 188 ACE_Configuration::validate_value_name (const ACE_TCHAR* name)
 189 {
 190   if (name == 0 || *name == this->NULL_String_)
 191     return 0;
 192
 193   return this->validate_name (name);
 194 }
 195
 196 const ACE_Configuration_Section_Key&
 197 ACE_Configuration::root_section (void) const
 198 {
 199   return root_;
 200 }
 201
 202 /**
 203  * Determine if the contents of this object is the same as the
 204  * contents of the object on the right hand side.
 205  * Returns 1 (True) if they are equal and 0 (False) if they are not equal
 206  */
 207 bool
 208 ACE_Configuration::operator== (const ACE_Configuration& rhs) const
 209 {
 210   bool rc = true;
 211   int sectionIndex = 0;
 212   ACE_TString sectionName;
 213   ACE_Configuration *nonconst_this = const_cast<ACE_Configuration*> (this);
 214   ACE_Configuration &nonconst_rhs  = const_cast<ACE_Configuration&> (rhs);
 215
 216   const ACE_Configuration_Section_Key& rhsRoot = rhs.root_section ();
 217   ACE_Configuration_Section_Key rhsSection;
 218   ACE_Configuration_Section_Key thisSection;
 219
 220   // loop through each section in this object
 221   while ((rc) && (nonconst_this->enumerate_sections (this->root_,
 222                                                      sectionIndex,
 223                                                      sectionName) == 0))
 224     {
 225       // find that section in the rhs object
 226       if (nonconst_rhs.open_section (rhsRoot,
 227                                      sectionName.c_str (),
 228                                      0,
 229                                      rhsSection) != 0)
 230         {
 231           // If the rhs object does not contain the section then we are
 232           // not equal.
 233           rc = false;
 234         }
 235       else if (nonconst_this->open_section (this->root_,
 236                                             sectionName.c_str (),
 237                                             0,
 238                                             thisSection) != 0)
 239         {
 240           // if there is some error opening the section in this object
 241           rc = false;
 242         }
 243       else
 244         {
 245           // Well the sections match
 246           int         valueIndex = 0;
 247           ACE_TString valueName;
 248           VALUETYPE   valueType;
 249           VALUETYPE   rhsType;
 250
 251           // Enumerate each value in this section
 252           while ((rc) && nonconst_this->enumerate_values (thisSection,
 253                                                           valueIndex,
 254                                                           valueName,
 255                                                           valueType) == 0)
 256             {
 257               // look for the same value in the rhs section
 258               if (nonconst_rhs.find_value (rhsSection,
 259                                            valueName.c_str (),
 260                                            rhsType) != 0)
 261                 {
 262                   // We're not equal if the same value cannot
 263                   // be found in the rhs object.
 264                   rc = false;
 265                 }
 266               else if (valueType != rhsType)
 267                 {
 268                   // we're not equal if the types do not match.
 269                   rc = false;
 270                 }
 271               else
 272                 {
 273                   // finally compare values.
 274                   if (valueType == STRING)
 275                     {
 276                       ACE_TString thisString, rhsString;
 277                       if (nonconst_this->get_string_value (thisSection,
 278                                                            valueName.c_str (),
 279                                                            thisString) != 0)
 280                         {
 281                           // we're not equal if we cannot get this string
 282                           rc = false;
 283                         }
 284                       else if (nonconst_rhs.get_string_value (
 285                                  rhsSection,
 286                                  valueName.c_str (),
 287                                  rhsString) != 0)
 288                         {
 289                           // we're not equal if we cannot get rhs string
 290                           rc = false;
 291                         }
 292                       rc = (thisString == rhsString);
 293                     }
 294                   else if (valueType == INTEGER)
 295                     {
 296                       u_int thisInt = 0;
 297                       u_int rhsInt = 0;
 298                       if (nonconst_this->get_integer_value (
 299                             thisSection,
 300                             valueName.c_str (),
 301                             thisInt) != 0)
 302                         {
 303                           // we're not equal if we cannot get this int
 304                           rc = false;
 305                         }
 306                       else if (nonconst_rhs.get_integer_value (
 307                                  rhsSection,
 308                                  valueName.c_str (),
 309                                  rhsInt) != 0)
 310                         {
 311                           // we're not equal if we cannot get rhs int
 312                           rc = false;
 313                         }
 314                       rc = (thisInt == rhsInt);
 315                     }
 316                   else if (valueType == BINARY)
 317                     {
 318                       void* thisData = 0;
 319                       void* rhsData = 0;
 320                       size_t thisLength = 0;
 321                       size_t rhsLength = 0;
 322                       if (nonconst_this->get_binary_value (thisSection,
 323                                                            valueName.c_str (),
 324                                                            thisData,
 325                                                            thisLength) != 0)
 326                         {
 327                           // we're not equal if we cannot get this data
 328                           rc = false;
 329                         }
 330                       else if (nonconst_rhs.get_binary_value (
 331                                  rhsSection,
 332                                  valueName.c_str (),
 333                                  rhsData,
 334                                  rhsLength) != 0)
 335                         {
 336                           // we're not equal if we cannot get this data
 337                           rc = false;
 338                         }
 339
 340                       rc = (thisLength == rhsLength);
 341                       // are the length's the same?
 342
 343                       if (rc)
 344                         {
 345                           unsigned char* thisCharData =
 346                             (unsigned char*)thisData;
 347                           unsigned char* rhsCharData = (unsigned char*)rhsData;
 348                           // yes, then check each element
 349                           for (size_t count = 0;
 350                                (rc) && (count < thisLength);
 351                                count++)
 352                             {
 353                               rc = (* (thisCharData + count) == * (rhsCharData + count));
 354                             }
 355
 356                           delete [] thisCharData;
 357                           delete [] rhsCharData;
 358                         }// end if the length's match
 359                     }
 360                   // We should never have valueTypes of INVALID, therefore
 361                   // we're not comparing them.  How would we since we have
 362                   // no get operation for invalid types.
 363                   // So, if we have them, we guess they are equal.
 364
 365                 }// end else if values match.
 366
 367               ++valueIndex;
 368
 369             }// end value while loop
 370
 371           // look in the rhs for values not in this
 372           valueIndex = 0;
 373           while ((rc) && (nonconst_rhs.enumerate_values (rhsSection,
 374                                                          valueIndex,
 375                                                          valueName,
 376                                                          rhsType) == 0))
 377             {
 378               // look for the same value in this section
 379               if (nonconst_this->find_value (thisSection,
 380                                              valueName.c_str (),
 381                                              valueType) != 0)
 382                 {
 383                   // We're not equal if the same value cannot
 384                   // be found in the rhs object.
 385                   rc = false;
 386                 }
 387               ++valueIndex;
 388             }// end while for rhs values not in this.
 389
 390         }// end else if sections match.
 391
 392       ++sectionIndex;
 393
 394     }// end section while loop
 395
 396   // Finally, make sure that there are no sections in rhs that do not
 397   // exist in this
 398   sectionIndex = 0;
 399   while ((rc)
 400          && (nonconst_rhs.enumerate_sections (rhsRoot,
 401                                               sectionIndex,
 402                                               sectionName) == 0))
 403     {
 404       // find the section in this
 405       if (nonconst_this->open_section (this->root_,
 406                                        sectionName.c_str (),
 407                                        0,
 408                                        thisSection) != 0)
 409         {
 410           // if there is some error opening the section in this object
 411           rc = false;
 412         }
 413       else if (nonconst_rhs.open_section (rhsRoot,
 414                                           sectionName.c_str (),
 415                                           0,
 416                                           rhsSection) != 0)
 417         {
 418           // If the rhs object does not contain the section then we
 419           // are not equal.
 420           rc = false;
 421         }
 422       ++sectionIndex;
 423     }
 424   return rc;
 425 }
 426
 427 bool
 428 ACE_Configuration::operator!= (const ACE_Configuration& rhs) const
 429 {
 430   return !(*this == rhs);
 431 }
 432
 433 //////////////////////////////////////////////////////////////////////////////
 434
 435 #if defined (ACE_WIN32) && !defined (ACE_LACKS_WIN32_REGISTRY)
 436
 437 static const int ACE_DEFAULT_BUFSIZE = 256;
 438
 439 static const ACE_TCHAR *temp_name (const ACE_TCHAR *name)
 440 {
 441   if (name && *name == ACE_Configuration::NULL_String_)
 442     return 0;
 443   return name;
 444 }
 445
 446 ACE_Section_Key_Win32::ACE_Section_Key_Win32 (HKEY hKey)
 447   : hKey_ (hKey)
 448 {
 449 }
 450
 451 ACE_Section_Key_Win32::~ACE_Section_Key_Win32 (void)
 452 {
 453   ::RegCloseKey (hKey_);
 454 }
 455
 456 //////////////////////////////////////////////////////////////////////////////
 457
 458 bool
 459 ACE_Configuration_Win32Registry::operator== (const ACE_Configuration_Win32Registry &rhs) const
 460 {
 461   ACE_UNUSED_ARG (rhs);
 462   return true;
 463 }
 464
 465 bool
 466 ACE_Configuration_Win32Registry::operator!= (const ACE_Configuration_Win32Registry &rhs) const
 467 {
 468   ACE_UNUSED_ARG (rhs);
 469   return true;
 470 }
 471
 472 ACE_Configuration_Win32Registry::ACE_Configuration_Win32Registry (HKEY hKey)
 473 {
 474   ACE_Section_Key_Win32 *temp = 0;
 475
 476   ACE_NEW (temp, ACE_Section_Key_Win32 (hKey));
 477
 478   root_ = ACE_Configuration_Section_Key (temp);
 479 }
 480
 481
 482 ACE_Configuration_Win32Registry::~ACE_Configuration_Win32Registry (void)
 483 {
 484 }
 485
 486 int
 487 ACE_Configuration_Win32Registry::open_section (const ACE_Configuration_Section_Key& base,
 488                                                const ACE_TCHAR* sub_section,
 489                                                int create,
 490                                                ACE_Configuration_Section_Key& result)
 491 {
 492   if (validate_name (sub_section, 1))
 493     return -1;
 494
 495   HKEY base_key;
 496   if (load_key (base, base_key))
 497     return -1;
 498
 499   int errnum;
 500   HKEY result_key;
 501   if ((errnum = ACE_TEXT_RegOpenKeyEx (base_key,
 502                                        sub_section,
 503                                        0,
 504                                        KEY_ALL_ACCESS,
 505                                        &result_key)) != ERROR_SUCCESS)
 506     {
 507       if (!create)
 508         {
 509           errno = errnum;
 510           return -1;
 511         }
 512
 513       if ((errnum = ACE_TEXT_RegCreateKeyEx (base_key,
 514                                              sub_section,
 515                                              0,
 516                                              0,
 517                                              REG_OPTION_NON_VOLATILE,
 518                                              KEY_ALL_ACCESS,
 519                                              0,
 520                                              &result_key,
 521 #if defined (__MINGW32__)
 522                                              (PDWORD) 0
 523 #else
 524                                              0
 525 #endif /* __MINGW32__ */
 526                                              )) != ERROR_SUCCESS)
 527         {
 528           errno = errnum;
 529           return -1;
 530         }
 531     }
 532
 533   ACE_Section_Key_Win32 *temp;
 534
 535   ACE_NEW_RETURN (temp, ACE_Section_Key_Win32 (result_key), -1);
 536   result = ACE_Configuration_Section_Key (temp);
 537   return 0;
 538 }
 539
 540 int
 541 ACE_Configuration_Win32Registry::remove_section (const ACE_Configuration_Section_Key& key,
 542                                                  const ACE_TCHAR* sub_section,
 543                                                  int recursive)
 544 {
 545   if (validate_name (sub_section))
 546     return -1;
 547
 548   HKEY base_key;
 549   if (load_key (key, base_key))
 550     return -1;
 551
 552   if (recursive)
 553     {
 554       ACE_Configuration_Section_Key section;
 555       if (open_section (key, sub_section, 0, section))
 556         return -1;
 557
 558       HKEY sub_key;
 559       if (load_key (section, sub_key))
 560         return -1;
 561
 562       ACE_TCHAR name_buffer[ACE_DEFAULT_BUFSIZE];
 563       DWORD buffer_size = ACE_DEFAULT_BUFSIZE;
 564       // Note we don't increment the index because the
 565       // enumeration becomes invalid if we change the
 566       // subkey, which we do when we delete it.  By leaving
 567       // it 0, we always delete the top entry
 568       while (ACE_TEXT_RegEnumKeyEx (sub_key,
 569                                     0,
 570                                     name_buffer,
 571                                     &buffer_size,
 572                                     0,
 573                                     0,
 574                                     0,
 575                                     0) == ERROR_SUCCESS)
 576         {
 577           remove_section (section, name_buffer, 1);
 578           buffer_size = ACE_DEFAULT_BUFSIZE;
 579         }
 580     }
 581
 582   int errnum;
 583   errnum = ACE_TEXT_RegDeleteKey (base_key, sub_section);
 584   if (errnum != ERROR_SUCCESS)
 585     {
 586       errno = errnum;
 587       return -1;
 588     }
 589
 590   return 0;
 591 }
 592
 593 int
 594 ACE_Configuration_Win32Registry::enumerate_values (const ACE_Configuration_Section_Key& key,
 595                                                    int index,
 596                                                    ACE_TString& name,
 597                                                    VALUETYPE& type)
 598 {
 599   HKEY base_key;
 600   if (load_key (key, base_key))
 601     return -1;
 602
 603   ACE_TCHAR name_buffer[ACE_DEFAULT_BUFSIZE];
 604   DWORD buffer_size = ACE_DEFAULT_BUFSIZE;
 605   DWORD value_type;
 606
 607   int rc = ACE_TEXT_RegEnumValue (base_key,
 608                                   index,
 609                                   name_buffer,
 610                                   &buffer_size,
 611                                   0,
 612                                   &value_type,
 613                                   0,
 614                                   0);
 615   if (rc == ERROR_NO_MORE_ITEMS)
 616     return 1;
 617   else if (rc != ERROR_SUCCESS)
 618     {
 619       errno = rc;
 620       return -1;
 621     }
 622
 623   name = name_buffer;
 624
 625   switch (value_type)
 626     {
 627     case REG_BINARY:
 628       type = BINARY;
 629       break;
 630     case REG_SZ:
 631       type = STRING;
 632       break;
 633     case REG_DWORD:
 634       type = INTEGER;
 635       break;
 636     default:
 637       type = INVALID;
 638     }
 639
 640   return 0;
 641 }
 642
 643 int
 644 ACE_Configuration_Win32Registry::enumerate_sections (const ACE_Configuration_Section_Key& key,
 645                                                      int index,
 646                                                      ACE_TString& name)
 647 {
 648   HKEY base_key;
 649   if (load_key (key, base_key))
 650     return -1;
 651
 652   ACE_TCHAR name_buffer[ACE_DEFAULT_BUFSIZE];
 653   DWORD buffer_size = ACE_DEFAULT_BUFSIZE;
 654   int rc = ACE_TEXT_RegEnumKeyEx (base_key,
 655                                   index,
 656                                   name_buffer,
 657                                   &buffer_size,
 658                                   0,
 659                                   0,
 660                                   0,
 661                                   0);
 662   if (rc == ERROR_NO_MORE_ITEMS)
 663     return 1;
 664   else if (rc != ERROR_MORE_DATA && rc != ERROR_SUCCESS)
 665     {
 666       errno = rc;
 667       return -1;
 668     }
 669
 670   name = name_buffer;
 671
 672   return 0;
 673 }
 674
 675 int
 676 ACE_Configuration_Win32Registry::set_string_value (const ACE_Configuration_Section_Key& key,
 677                                                    const ACE_TCHAR* name,
 678                                                    const ACE_TString& value)
 679 {
 680   const ACE_TCHAR *t_name = temp_name (name);
 681   if (validate_value_name (t_name))
 682     return -1;
 683
 684   HKEY base_key;
 685   if (load_key (key, base_key))
 686     return -1;
 687
 688   int errnum;
 689   DWORD len = static_cast<DWORD> (value.length () + 1);
 690   len *= sizeof (ACE_TCHAR);
 691   if ((errnum = ACE_TEXT_RegSetValueEx (base_key,
 692                                        t_name,
 693                                        0,
 694                                        REG_SZ,
 695                                        (BYTE *) value.fast_rep (),
 696                                         len))
 697       != ERROR_SUCCESS)
 698     {
 699       errno = errnum;
 700       return -1;
 701     }
 702
 703   return 0;
 704 }
 705
 706 int
 707 ACE_Configuration_Win32Registry::set_integer_value (const ACE_Configuration_Section_Key& key,
 708                                                     const ACE_TCHAR* name,
 709                                                     u_int value)
 710 {
 711   const ACE_TCHAR *t_name = temp_name (name);
 712   if (validate_value_name (t_name))
 713     return -1;
 714
 715   HKEY base_key;
 716   if (load_key (key, base_key))
 717     return -1;
 718
 719   int errnum;
 720   if ((errnum = ACE_TEXT_RegSetValueEx (base_key,
 721                                         t_name,
 722                                         0,
 723                                         REG_DWORD,
 724                                         (BYTE *) &value,
 725                                         sizeof (value))) != ERROR_SUCCESS)
 726     {
 727       errno = errnum;
 728       return -1;
 729     }
 730
 731   return 0;
 732 }
 733
 734 int
 735 ACE_Configuration_Win32Registry::set_binary_value (const ACE_Configuration_Section_Key& key,
 736                                                    const ACE_TCHAR* name,
 737                                                    const void* data,
 738                                                    size_t length)
 739 {
 740   const ACE_TCHAR *t_name = temp_name (name);
 741   if (validate_value_name (t_name))
 742     return -1;
 743
 744   HKEY base_key;
 745   if (load_key (key, base_key))
 746     return -1;
 747
 748   int errnum;
 749   if ((errnum = ACE_TEXT_RegSetValueEx (base_key,
 750                                         t_name,
 751                                         0,
 752                                         REG_BINARY,
 753                                         (BYTE *) data,
 754                                         static_cast<DWORD> (length)))
 755       != ERROR_SUCCESS)
 756     {
 757       errno = errnum;
 758       return -1;
 759     }
 760
 761   return 0;
 762 }
 763
 764 int
 765 ACE_Configuration_Win32Registry::get_string_value (const ACE_Configuration_Section_Key& key,
 766                                                    const ACE_TCHAR* name,
 767                                                    ACE_TString& value)
 768 {
 769   const ACE_TCHAR *t_name = temp_name (name);
 770   if (validate_value_name (t_name))
 771     return -1;
 772
 773   HKEY base_key;
 774   if (load_key (key, base_key))
 775     return -1;
 776
 777   // Get the size of the binary data from windows
 778   int errnum;
 779   DWORD buffer_length = 0;
 780   DWORD type;
 781   if ((errnum = ACE_TEXT_RegQueryValueEx (base_key,
 782                                           t_name,
 783                                           0,
 784                                           &type,
 785                                           (BYTE *) 0,
 786                                           &buffer_length)) != ERROR_SUCCESS)
 787     {
 788       errno = errnum;
 789       return -1;
 790     }
 791
 792   if (type != REG_SZ)
 793     {
 794       errno = ERROR_INVALID_DATATYPE;
 795       return -1;
 796     }
 797
 798   ACE_TCHAR *temp = 0;
 799   ACE_NEW_RETURN (temp,
 800                   ACE_TCHAR[buffer_length],
 801                   -1);
 802
 803   ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> buffer (temp);
 804
 805   if ((errnum = ACE_TEXT_RegQueryValueEx (base_key,
 806                                           t_name,
 807                                           0,
 808                                           &type,
 809                                           (BYTE *) buffer.get (),
 810                                           &buffer_length)) != ERROR_SUCCESS)
 811     {
 812       errno = errnum;
 813       return -1;
 814     }
 815
 816   value = buffer.get ();
 817   return 0;
 818 }
 819
 820 int
 821 ACE_Configuration_Win32Registry::get_integer_value (const ACE_Configuration_Section_Key& key,
 822                                                     const ACE_TCHAR* name,
 823                                                     u_int& value)
 824 {
 825   const ACE_TCHAR *t_name = temp_name (name);
 826   if (validate_value_name (t_name))
 827     return -1;
 828
 829   HKEY base_key;
 830   if (load_key (key, base_key))
 831     return -1;
 832
 833   int errnum;
 834   DWORD length = sizeof (value);
 835   DWORD type;
 836   if ((errnum = ACE_TEXT_RegQueryValueEx (base_key,
 837                                           t_name,
 838                                           0,
 839                                           &type,
 840                                           (BYTE *) &value,
 841                                           &length)) != ERROR_SUCCESS)
 842     {
 843       errno = errnum;
 844       return -1;
 845     }
 846
 847   if (type != REG_DWORD)
 848     {
 849       errno = ERROR_INVALID_DATATYPE;
 850       return -1;
 851     }
 852
 853   return 0;
 854 }
 855
 856 int
 857 ACE_Configuration_Win32Registry::get_binary_value (
 858   const ACE_Configuration_Section_Key &key,
 859   const ACE_TCHAR *name,
 860   void *&data,
 861   size_t &length)
 862 {
 863   const ACE_TCHAR *t_name = temp_name (name);
 864   if (validate_value_name (t_name))
 865     return -1;
 866
 867   HKEY base_key;
 868   if (load_key (key, base_key))
 869     return -1;
 870
 871   // Get the size of the binary data from windows
 872   int errnum;
 873   DWORD buffer_length = 0;
 874   DWORD type;
 875   if ((errnum = ACE_TEXT_RegQueryValueEx (base_key,
 876                                           t_name,
 877                                           0,
 878                                           &type,
 879                                           (BYTE *) 0,
 880                                           &buffer_length)) != ERROR_SUCCESS)
 881     {
 882       errno = errnum;
 883       return -1;
 884     }
 885
 886   if (type != REG_BINARY)
 887     {
 888       errno = ERROR_INVALID_DATATYPE;
 889       return -1;
 890     }
 891
 892   length = buffer_length;
 893
 894   BYTE * the_data = 0;
 895   ACE_NEW_RETURN (the_data, BYTE[length], -1);
 896   ACE_Auto_Basic_Array_Ptr<BYTE> safe_data (the_data);
 897
 898   if ((errnum = ACE_TEXT_RegQueryValueEx (base_key,
 899                                           t_name,
 900                                           0,
 901                                           &type,
 902                                           the_data,
 903                                           &buffer_length)) != ERROR_SUCCESS)
 904     {
 905       data = 0;
 906       errno = errnum;
 907       return -1;
 908     }
 909
 910   data = safe_data.release ();
 911
 912   return 0;
 913 }
 914
 915 int
 916 ACE_Configuration_Win32Registry::find_value (const ACE_Configuration_Section_Key& key,
 917                                              const ACE_TCHAR* name,
 918                                              VALUETYPE& type_out)
 919 {
 920   const ACE_TCHAR *t_name = temp_name (name);
 921   if (validate_value_name (t_name))
 922     return -1;
 923
 924   HKEY base_key;
 925   if (load_key (key, base_key))
 926     return -1;
 927
 928   DWORD buffer_length=0;
 929   DWORD type;
 930   int result=ACE_TEXT_RegQueryValueEx (base_key,
 931                                        t_name,
 932                                        0,
 933                                        &type,
 934                                        0,
 935                                        &buffer_length);
 936   if (result != ERROR_SUCCESS)
 937     {
 938       errno = result;
 939       return -1;
 940     }
 941
 942   switch (type)
 943     {
 944     case REG_SZ:
 945       type_out = STRING;
 946       break;
 947     case REG_DWORD:
 948       type_out = INTEGER;
 949       break;
 950     case REG_BINARY:
 951       type_out = BINARY;
 952       break;
 953     default:
 954       return -1; // unknown type
 955     }
 956
 957   return 0;
 958 }
 959
 960 int
 961 ACE_Configuration_Win32Registry::remove_value (const ACE_Configuration_Section_Key& key,
 962                                                const ACE_TCHAR* name)
 963 {
 964   const ACE_TCHAR *t_name = temp_name (name);
 965   if (validate_value_name (t_name))
 966     return -1;
 967
 968   HKEY base_key;
 969   if (load_key (key, base_key))
 970     return -1;
 971
 972   int errnum;
 973   if ((errnum = ACE_TEXT_RegDeleteValue (base_key, t_name)) != ERROR_SUCCESS)
 974     {
 975       errno = errnum;
 976       return -1;
 977     }
 978
 979   return 0;
 980 }
 981
 982
 983 int
 984 ACE_Configuration_Win32Registry::load_key (const ACE_Configuration_Section_Key& key,
 985                                            HKEY& hKey)
 986 {
 987   ACE_Section_Key_Win32* pKey = dynamic_cast<ACE_Section_Key_Win32*> (get_internal_key (key));
 988   if (!pKey)
 989     return -1;
 990
 991   hKey = pKey->hKey_;
 992   return 0;
 993 }
 994
 995 HKEY
 996 ACE_Configuration_Win32Registry::resolve_key (HKEY hKey,
 997                                               const ACE_TCHAR* path,
 998                                               int create)
 999 {
1000   HKEY result = 0;
1001   // Make a copy of hKey
1002   int errnum;
1003 #if defined (ACE_HAS_WINCE)
1004   if ((errnum = RegOpenKeyEx (hKey, 0, 0, 0, &result)) != ERROR_SUCCESS)
1005 #else
1006   if ((errnum = RegOpenKey (hKey, 0, &result)) != ERROR_SUCCESS)
1007 #endif  // ACE_HAS_WINCE
1008     {
1009       errno = errnum;
1010       return 0;
1011     }
1012
1013   // recurse through the path
1014   ACE_TCHAR *temp_path = 0;
1015   ACE_NEW_RETURN (temp_path,
1016                   ACE_TCHAR[ACE_OS::strlen (path) + 1],
1017                   0);
1018   ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> pData (temp_path);
1019   ACE_OS::strcpy (pData.get (), path);
1020   ACE_Tokenizer parser (pData.get ());
1021   parser.delimiter_replace ('\\', '\0');
1022   parser.delimiter_replace ('/', '\0');
1023
1024   for (ACE_TCHAR *temp = parser.next ();
1025        temp != 0;
1026        temp = parser.next ())
1027     {
1028       // Open the key
1029       HKEY subkey;
1030
1031 #if defined (ACE_HAS_WINCE)
1032       if ((errnum = ACE_TEXT_RegOpenKeyEx (result,
1033                                            temp,
1034                                            0,
1035                                            0,
1036                                            &subkey)) != ERROR_SUCCESS)
1037 #else
1038       if ((errnum = ACE_TEXT_RegOpenKey (result,
1039                                          temp,
1040                                          &subkey)) != ERROR_SUCCESS)
1041 #endif  // ACE_HAS_WINCE
1042         {
1043           // try creating it
1044           if (!create || (errnum = ACE_TEXT_RegCreateKeyEx (result,
1045                                                             temp,
1046                                                             0,
1047                                                             0,
1048                                                             0,
1049                                                             KEY_ALL_ACCESS,
1050                                                             0,
1051                                                             &subkey,
1052 #if defined (__MINGW32__)
1053                                                             (PDWORD) 0
1054 #else
1055                                                             0
1056 #endif /* __MINGW32__ */
1057                                                             )) !=ERROR_SUCCESS)
1058             {
1059               errno = errnum;
1060               // error
1061               ::RegCloseKey (result);
1062               return 0;
1063             }
1064         }
1065       // release our open key handle
1066       ::RegCloseKey (result);
1067       result = subkey;
1068     }
1069
1070   return result;
1071 }
1072
1073 #endif /* ACE_WIN32 && !ACE_LACKS_WIN32_REGISTRY */
1074
1075 ///////////////////////////////////////////////////////////////
1076
1077 ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (void)
1078   : type_ (ACE_Configuration::INVALID),
1079     length_ (0)
1080 {
1081   this->data_.ptr_ = 0;
1082 }
1083
1084 ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (ACE_TCHAR* string)
1085   : type_ (ACE_Configuration::STRING),
1086     length_ (0)
1087 {
1088   this->data_.ptr_ = string;
1089 }
1090
1091 ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (u_int integer)
1092   : type_ (ACE_Configuration::INTEGER),
1093     length_ (0)
1094 {
1095   this->data_.int_ = integer;
1096 }
1097
1098 ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (void* data, size_t length)
1099   : type_ (ACE_Configuration::BINARY),
1100     length_ (length)
1101 {
1102   this->data_.ptr_ = data;
1103 }
1104
1105 ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (const ACE_Configuration_Value_IntId& rhs)
1106   : type_ (rhs.type_),
1107     data_ (rhs.data_),
1108     length_ (rhs.length_)
1109 {
1110 }
1111
1112 ACE_Configuration_Value_IntId::~ACE_Configuration_Value_IntId (void)
1113 {
1114 }
1115
1116 ACE_Configuration_Value_IntId& ACE_Configuration_Value_IntId::operator= (const ACE_Configuration_Value_IntId& rhs)
1117 {
1118   if (this != &rhs)
1119     {
1120       type_ = rhs.type_;
1121       data_ = rhs.data_;
1122       length_ = rhs.length_;
1123     }
1124   return *this;
1125 }
1126
1127 void
1128 ACE_Configuration_Value_IntId::free (ACE_Allocator *alloc)
1129 {
1130   if (this->type_ == ACE_Configuration::STRING
1131       || this->type_ == ACE_Configuration::BINARY)
1132     alloc->free (data_.ptr_);
1133   // Do nothing in other cases...
1134 }
1135
1136 ACE_Configuration_ExtId::ACE_Configuration_ExtId (void)
1137   : name_ (0)
1138 {
1139 }
1140
1141 ACE_Configuration_ExtId::ACE_Configuration_ExtId (const ACE_TCHAR* name)
1142   : name_ (name)
1143 {
1144 }
1145
1146 ACE_Configuration_ExtId::ACE_Configuration_ExtId (const ACE_Configuration_ExtId& rhs)
1147   : name_ (rhs.name_)
1148 {
1149 }
1150
1151 ACE_Configuration_ExtId::~ACE_Configuration_ExtId (void)
1152 {
1153 }
1154
1155 ACE_Configuration_ExtId& ACE_Configuration_ExtId::operator= (const ACE_Configuration_ExtId& rhs)
1156 {
1157   if (this != &rhs)
1158     name_ = rhs.name_;
1159
1160   return *this;
1161 }
1162
1163 bool
1164 ACE_Configuration_ExtId::operator== (const ACE_Configuration_ExtId& rhs) const
1165 {
1166   return (ACE_OS::strcasecmp (name_, rhs.name_) == 0);
1167 }
1168
1169 bool
1170 ACE_Configuration_ExtId::operator!= (const ACE_Configuration_ExtId& rhs) const
1171 {
1172   return !this->operator== (rhs);
1173 }
1174
1175 u_long
1176 ACE_Configuration_ExtId::hash (void) const
1177 {
1178   ACE_TString temp (name_, 0, false);
1179   return temp.hash ();
1180 }
1181
1182 void
1183 ACE_Configuration_ExtId::free (ACE_Allocator *alloc)
1184 {
1185   alloc->free ((void *) (name_));
1186 }
1187
1188 ///////////////////////////////////////////////////////////////////////
1189
1190 ACE_Configuration_Section_IntId::ACE_Configuration_Section_IntId (void)
1191   : value_hash_map_ (0),
1192     section_hash_map_ (0)
1193 {
1194 }
1195
1196 ACE_Configuration_Section_IntId::ACE_Configuration_Section_IntId (VALUE_MAP* value_hash_map, SUBSECTION_MAP* section_hash_map)
1197   : value_hash_map_ (value_hash_map),
1198     section_hash_map_ (section_hash_map)
1199 {
1200 }
1201
1202 ACE_Configuration_Section_IntId::ACE_Configuration_Section_IntId (const ACE_Configuration_Section_IntId& rhs)
1203   : value_hash_map_ (rhs.value_hash_map_),
1204     section_hash_map_ (rhs.section_hash_map_)
1205 {
1206
1207 }
1208
1209 ACE_Configuration_Section_IntId::~ACE_Configuration_Section_IntId ()
1210 {
1211 }
1212
1213 ACE_Configuration_Section_IntId&
1214 ACE_Configuration_Section_IntId::operator= (const ACE_Configuration_Section_IntId& rhs)
1215 {
1216   if (this != &rhs)
1217     {
1218       value_hash_map_ = rhs.value_hash_map_;
1219       section_hash_map_ = rhs.section_hash_map_;
1220     }
1221   return *this;
1222 }
1223
1224 void
1225 ACE_Configuration_Section_IntId::free (ACE_Allocator *alloc)
1226 {
1227   alloc->free ((void *) (value_hash_map_));
1228   alloc->free ((void *) (section_hash_map_));
1229 }
1230
1231 ACE_Configuration_Section_Key_Heap::ACE_Configuration_Section_Key_Heap (const ACE_TCHAR* path)
1232   : path_ (0),
1233     value_iter_ (0),
1234     section_iter_ (0)
1235 {
1236   path_ = ACE_OS::strdup (path);
1237 }
1238
1239 ACE_Configuration_Section_Key_Heap::~ACE_Configuration_Section_Key_Heap ()
1240 {
1241   delete value_iter_;
1242   delete section_iter_;
1243   ACE_OS::free (path_);
1244 }
1245
1246 //////////////////////////////////////////////////////////////////////////////
1247
1248 ACE_Configuration_Heap::ACE_Configuration_Heap (void)
1249   : allocator_ (0),
1250     index_ (0),
1251     default_map_size_ (0)
1252 {
1253   ACE_Configuration_Section_Key_Heap *temp = 0;
1254
1255   ACE_NEW (temp, ACE_Configuration_Section_Key_Heap (ACE_TEXT ("")));
1256   root_ = ACE_Configuration_Section_Key (temp);
1257 }
1258
1259 ACE_Configuration_Heap::~ACE_Configuration_Heap (void)
1260 {
1261   if (allocator_)
1262     allocator_->sync ();
1263
1264   delete allocator_;
1265 }
1266
1267 int
1268 ACE_Configuration_Heap::open (size_t default_map_size)
1269 {
1270   default_map_size_ = default_map_size;
1271   // Create the allocator with the appropriate options.
1272   // The name used for  the lock is the same as one used
1273   // for the file.
1274   ACE_NEW_RETURN (this->allocator_,
1275                   HEAP_ALLOCATOR (),
1276                   -1);
1277   return create_index ();
1278 }
1279
1280
1281 int
1282 ACE_Configuration_Heap::open (const ACE_TCHAR* file_name,
1283                               void* base_address,
1284                               size_t default_map_size)
1285 {
1286   default_map_size_ = default_map_size;
1287
1288   // Make sure that the file name is of the legal length.
1289   if (ACE_OS::strlen (file_name) >= MAXNAMELEN + MAXPATHLEN)
1290     {
1291       errno = ENAMETOOLONG;
1292       return -1;
1293     }
1294
1295   ACE_MMAP_Memory_Pool::OPTIONS options (base_address);
1296
1297   // Create the allocator with the appropriate options.  The name used
1298   // for  the lock is the same as one used for the file.
1299   ACE_NEW_RETURN (this->allocator_,
1300                   PERSISTENT_ALLOCATOR (file_name,
1301                                         file_name,
1302                                         &options),
1303                   -1);
1304
1305 #if !defined (ACE_LACKS_ACCESS)
1306   // Now check if the backing store has been created successfully.
1307   if (ACE_OS::access (file_name, F_OK) != 0)
1308     ACE_ERROR_RETURN ((LM_ERROR,
1309                        ACE_TEXT ("create_index\n")),
1310                       -1);
1311 #endif /* ACE_LACKS_ACCESS */
1312
1313   return create_index ();
1314 }
1315
1316 int
1317 ACE_Configuration_Heap::create_index (void)
1318 {
1319   void *section_index = 0;
1320
1321   // This is the easy case since if we find hash table in the
1322   // memory-mapped file we know it's already initialized.
1323   if (this->allocator_->find (ACE_CONFIG_SECTION_INDEX, section_index) == 0)
1324     this->index_ = (SECTION_MAP *) section_index;
1325
1326   // Create a new <index_> (because we've just created a new
1327   // memory-mapped file).
1328   else
1329     {
1330       size_t index_size = sizeof (SECTION_MAP);
1331       section_index = this->allocator_->malloc (index_size);
1332
1333       if (section_index == 0
1334           || create_index_helper (section_index) == -1
1335           || this->allocator_->bind (ACE_CONFIG_SECTION_INDEX,
1336                                      section_index) == -1)
1337         {
1338           // Attempt to clean up.
1339           ACE_ERROR ((LM_ERROR,
1340                       ACE_TEXT ("create_index failed\n")));
1341           this->allocator_->remove ();
1342           return -1;
1343         }
1344       // Add the root section
1345       return new_section (ACE_TEXT (""), root_);
1346     }
1347   return 0;
1348 }
1349
1350 int
1351 ACE_Configuration_Heap::create_index_helper (void *buffer)
1352 {
1353   ACE_ASSERT (this->allocator_);
1354   this->index_ = new (buffer) SECTION_MAP (this->allocator_);
1355   return 0;
1356 }
1357
1358 int
1359 ACE_Configuration_Heap::load_key (const ACE_Configuration_Section_Key& key,
1360                                   ACE_TString& name)
1361 {
1362   ACE_ASSERT (this->allocator_);
1363   ACE_Configuration_Section_Key_Heap* pKey =
1364     dynamic_cast<ACE_Configuration_Section_Key_Heap*> (get_internal_key (key));
1365
1366   if (!pKey)
1367     {
1368       return -1;
1369     }
1370
1371   ACE_TString temp (pKey->path_, 0, false);
1372   name.assign_nocopy (temp);
1373   return 0;
1374 }
1375
1376
1377 int
1378 ACE_Configuration_Heap::add_section (const ACE_Configuration_Section_Key& base,
1379                                      const ACE_TCHAR* sub_section,
1380                                      ACE_Configuration_Section_Key& result)
1381 {
1382   ACE_ASSERT (this->allocator_);
1383   ACE_TString section;
1384   if (load_key (base, section))
1385     return -1;
1386
1387   // Find the base section
1388   ACE_Configuration_ExtId ExtId (section.fast_rep ());
1389   ACE_Configuration_Section_IntId IntId;
1390   if (index_->find (ExtId, IntId, allocator_))
1391     return -1;
1392
1393   // See if this section already exists
1394   ACE_Configuration_ExtId SubSectionExtId (sub_section);
1395   int ignored = 0;
1396
1397   if (!IntId.section_hash_map_->find (SubSectionExtId, ignored, allocator_))
1398     {
1399       // already exists!
1400       errno = EEXIST;
1401       return -1;
1402     }
1403
1404   // Create the new section name
1405   // only prepend a separater if were not at the root
1406   if (section.length ())
1407     section += ACE_TEXT ("\\");
1408
1409   section += sub_section;
1410
1411   // Add it to the base section
1412   ACE_TCHAR* pers_name = (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (sub_section) + 1) * sizeof (ACE_TCHAR));
1413   ACE_OS::strcpy (pers_name, sub_section);
1414   ACE_Configuration_ExtId SSExtId (pers_name);
1415   if (IntId.section_hash_map_->bind (SSExtId, ignored, allocator_))
1416     {
1417       allocator_->free (pers_name);
1418       return -1;
1419     }
1420   return (new_section (section, result));
1421 }
1422
1423 int
1424 ACE_Configuration_Heap::new_section (const ACE_TString& section,
1425                                      ACE_Configuration_Section_Key& result)
1426 {
1427   ACE_ASSERT (this->allocator_);
1428   // Create a new section and add it to the global list
1429
1430   // Allocate memory for items to be stored in the table.
1431   size_t section_len = section.length () + 1;
1432   ACE_TCHAR *ptr = (ACE_TCHAR*) this->allocator_->malloc (section_len * sizeof (ACE_TCHAR));
1433
1434   int return_value = -1;
1435
1436   if (ptr == 0)
1437     return -1;
1438   else
1439     {
1440       // Populate memory with data.
1441       ACE_OS::strcpy (ptr, section.fast_rep ());
1442
1443       void *value_hash_map = 0;
1444       size_t map_size = sizeof (VALUE_MAP);
1445       value_hash_map = this->allocator_->malloc (map_size);
1446
1447       // If allocation failed ...
1448       if (value_hash_map == 0)
1449         return -1;
1450
1451       // Initialize allocated hash map through placement new.
1452       if (value_open_helper (default_map_size_, value_hash_map ) == -1)
1453         {
1454           this->allocator_->free (value_hash_map );
1455           return -1;
1456         }
1457
1458       // create the section map
1459       void* section_hash_map = 0;
1460       map_size = sizeof (SUBSECTION_MAP);
1461       section_hash_map = this->allocator_->malloc (map_size);
1462
1463       // If allocation failed
1464       if (section_hash_map == 0)
1465         return -1;
1466
1467       // initialize allocated hash map through placement new
1468       if (section_open_helper (default_map_size_, section_hash_map) == -1)
1469         {
1470           this->allocator_->free (value_hash_map );
1471           this->allocator_->free (section_hash_map);
1472           return -1;
1473         }
1474
1475       ACE_Configuration_ExtId name (ptr);
1476       ACE_Configuration_Section_IntId entry ((VALUE_MAP*) value_hash_map,
1477                                              (SUBSECTION_MAP*) section_hash_map);
1478
1479       // Do a normal bind.  This will fail if there's already an
1480       // entry with the same name.
1481       return_value = this->index_->bind (name, entry, this->allocator_);
1482
1483       if (return_value == 1      /* Entry already existed so bind failed. */
1484           || return_value == -1  /* Unable to bind for other reasons. */)
1485         {
1486           // Free our dynamically allocated memory.
1487           this->allocator_->free (static_cast<void *> (ptr));
1488           return return_value;
1489         }
1490
1491       // If bind () succeed, it will automatically sync
1492       // up the map manager entry.  However, we must sync up our
1493       // name/value memory.
1494       this->allocator_->sync (ptr, section_len);
1495     }
1496
1497   // set the result
1498   ACE_Configuration_Section_Key_Heap *temp;
1499   ACE_NEW_RETURN (temp,
1500                   ACE_Configuration_Section_Key_Heap (ptr),
1501                   -1);
1502   result = ACE_Configuration_Section_Key (temp);
1503   return return_value;
1504 }
1505
1506 int
1507 ACE_Configuration_Heap::value_open_helper (size_t hash_table_size,
1508                                           void *buffer)
1509 {
1510   ACE_ASSERT (this->allocator_);
1511   new (buffer) VALUE_MAP (hash_table_size, this->allocator_);
1512   return 0;
1513 }
1514
1515 int
1516 ACE_Configuration_Heap::section_open_helper (size_t hash_table_size,
1517                                              void *buffer)
1518 {
1519   ACE_ASSERT (this->allocator_);
1520   new (buffer) SUBSECTION_MAP (hash_table_size, this->allocator_);
1521   return 0;
1522 }
1523
1524 int
1525 ACE_Configuration_Heap::open_section (const ACE_Configuration_Section_Key& base,
1526                                       const ACE_TCHAR* sub_section,
1527                                       int create,
1528                                       ACE_Configuration_Section_Key& result)
1529 {
1530   ACE_ASSERT (this->allocator_);
1531   if (validate_name (sub_section, 1))    // 1 == allow_path
1532     return -1;
1533
1534   result = base;
1535
1536   for (const ACE_TCHAR* separator;
1537        (separator = ACE_OS::strchr (sub_section, ACE_TEXT ('\\'))) != 0;
1538        )
1539     {
1540       ACE_TString simple_section (sub_section, separator - sub_section);
1541       int ret_val =
1542         open_simple_section (result, simple_section.c_str (), create, result);
1543       if (ret_val)
1544         return ret_val;
1545       sub_section = separator + 1;
1546     }
1547
1548   return open_simple_section (result, sub_section, create, result);
1549 }
1550
1551 int
1552 ACE_Configuration_Heap::open_simple_section (const ACE_Configuration_Section_Key& base,
1553                                              const ACE_TCHAR* sub_section,
1554                                              int create,
1555                                              ACE_Configuration_Section_Key& result)
1556 {
1557   ACE_TString section (0, 0, false);
1558
1559   if (load_key (base, section))
1560     {
1561       return -1;
1562     }
1563
1564   // Only add the \\ if were not at the root
1565   if (section.length ())
1566     {
1567       section += ACE_TEXT ("\\");
1568     }
1569
1570   section += sub_section;
1571
1572   // resolve the section
1573   ACE_Configuration_ExtId ExtId (section.fast_rep ());
1574   ACE_Configuration_Section_IntId IntId;
1575
1576   if (index_->find (ExtId, IntId, allocator_))
1577     {
1578       if (!create)
1579         {
1580           errno = ENOENT;
1581           return -1;
1582         }
1583
1584       return add_section (base, sub_section, result);
1585     }
1586
1587   ACE_Configuration_Section_Key_Heap *temp;
1588   ACE_NEW_RETURN (temp,
1589                   ACE_Configuration_Section_Key_Heap (section.fast_rep ()),
1590                   -1);
1591   result = ACE_Configuration_Section_Key (temp);
1592   return 0;
1593 }
1594
1595 int
1596 ACE_Configuration_Heap::remove_section (const ACE_Configuration_Section_Key& key,
1597                                         const ACE_TCHAR* sub_section,
1598                                         int recursive)
1599 {
1600   ACE_ASSERT (this->allocator_);
1601   if (validate_name (sub_section))
1602     return -1;
1603
1604   ACE_TString section;
1605   if (load_key (key, section))
1606     return -1;
1607
1608   // Find this key
1609   ACE_Configuration_ExtId ParentExtId (section.fast_rep ());
1610   ACE_Configuration_Section_IntId ParentIntId;
1611   if (index_->find (ParentExtId, ParentIntId, allocator_))
1612     return -1;// no parent key
1613
1614   // Find this subkey
1615   if (section.length ())
1616     section += ACE_TEXT ("\\");
1617
1618   section += sub_section;
1619   ACE_Configuration_ExtId SectionExtId (section.fast_rep ());
1620   SECTION_HASH::ENTRY* section_entry;
1621   SECTION_HASH* hashmap = index_;
1622   if (hashmap->find (SectionExtId, section_entry))
1623     return -1;
1624
1625   if (recursive)
1626     {
1627       ACE_Configuration_Section_Key section;
1628       if (open_section (key, sub_section, 0, section))
1629         return -1;
1630
1631       int index = 0;
1632       ACE_TString name;
1633       while (!enumerate_sections (section, index, name))
1634         {
1635           if (remove_section (section, name.fast_rep (), 1))
1636             return -1;
1637
1638           ++index;
1639         }
1640     }
1641
1642   // Now make sure we dont have any subkeys
1643   if (section_entry->int_id_.section_hash_map_->current_size ())
1644     {
1645       errno = ENOTEMPTY;
1646       return -1;
1647     }
1648
1649   // Now remove subkey from parent key
1650   ACE_Configuration_ExtId SubSExtId (sub_section);
1651   SUBSECTION_HASH::ENTRY* subsection_entry;
1652   if (((SUBSECTION_HASH*)ParentIntId.section_hash_map_)->
1653       find (SubSExtId, subsection_entry))
1654     return -1;
1655
1656   if (ParentIntId.section_hash_map_->unbind (SubSExtId, allocator_))
1657     return -1;
1658
1659   subsection_entry->ext_id_.free (allocator_);
1660
1661   // Remember the pointers so we can free them after we unbind
1662   ACE_Configuration_ExtId ExtIdToFree (section_entry->ext_id_);
1663   ACE_Configuration_Section_IntId IntIdToFree (section_entry->int_id_);
1664
1665   // iterate over all values and free memory
1666   VALUE_HASH* value_hash_map = section_entry->int_id_.value_hash_map_;
1667   VALUE_HASH::ITERATOR value_iter = value_hash_map->begin ();
1668   while (!value_iter.done ())
1669     {
1670       VALUE_HASH::ENTRY* value_entry = 0;
1671       if (!value_iter.next (value_entry))
1672         return 1;
1673
1674       value_entry->ext_id_.free (allocator_);
1675       value_entry->int_id_.free (allocator_);
1676
1677       value_iter.advance ();
1678     }
1679
1680   // remove it
1681   if (index_->unbind (SectionExtId, allocator_))
1682     return -1;
1683
1684   value_hash_map->close ();
1685   section_entry->int_id_.section_hash_map_->close (allocator_);
1686
1687   // Free the memory
1688   ExtIdToFree.free (allocator_);
1689   IntIdToFree.free (allocator_);
1690
1691   return 0;
1692 }
1693
1694 int
1695 ACE_Configuration_Heap::enumerate_values (const ACE_Configuration_Section_Key& key,
1696                                           int index,
1697                                           ACE_TString& name,
1698                                           VALUETYPE& type)
1699 {
1700   ACE_ASSERT (this->allocator_);
1701   ACE_Configuration_Section_Key_Heap* pKey =
1702     dynamic_cast<ACE_Configuration_Section_Key_Heap*> (get_internal_key (key));
1703   if (!pKey)
1704     return -1;
1705
1706   name = pKey->path_;
1707
1708   // resolve the section
1709   ACE_Configuration_ExtId ExtId (pKey->path_);
1710   ACE_Configuration_Section_IntId IntId;
1711   if (index_->find (ExtId, IntId, allocator_))
1712     return -1;
1713
1714   // Handle iterator resets
1715   if (index == 0)
1716     {
1717       ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId ,
1718                               ACE_Configuration_Value_IntId,
1719                               ACE_Hash<ACE_Configuration_ExtId>,
1720                               ACE_Equal_To<ACE_Configuration_ExtId>,
1721                               ACE_Null_Mutex>* hash_map = IntId.value_hash_map_;
1722       delete pKey->value_iter_;
1723
1724       ACE_NEW_RETURN (pKey->value_iter_,
1725                       VALUE_HASH::ITERATOR (hash_map->begin ()),
1726                       -1);
1727     }
1728
1729   // Get the next entry
1730   ACE_Hash_Map_Entry<ACE_Configuration_ExtId, ACE_Configuration_Value_IntId>* entry = 0;
1731
1732   if (!pKey->value_iter_->next (entry))
1733     return 1;
1734
1735   // Return the value of the iterator and advance it
1736   name = entry->ext_id_.name_;
1737   type = entry->int_id_.type_;
1738   pKey->value_iter_->advance ();
1739
1740   return 0;
1741 }
1742
1743 int
1744 ACE_Configuration_Heap::enumerate_sections (const ACE_Configuration_Section_Key& key,
1745                                             int index,
1746                                             ACE_TString& name)
1747 {
1748   ACE_ASSERT (this->allocator_);
1749   // cast to a heap section key
1750   ACE_Configuration_Section_Key_Heap* pKey =
1751     dynamic_cast<ACE_Configuration_Section_Key_Heap*> (get_internal_key (key));
1752   if (!pKey)
1753     return -1;  // not a heap key!
1754
1755   // resolve the section
1756   ACE_Configuration_ExtId ExtId (pKey->path_);
1757   ACE_Configuration_Section_IntId IntId;
1758   if (index_->find (ExtId, IntId, allocator_))
1759     return -1; // unknown section
1760
1761   // Handle iterator resets
1762   if (index == 0)
1763     {
1764       if (pKey->section_iter_)
1765         delete pKey->section_iter_;
1766
1767       ACE_NEW_RETURN (pKey->section_iter_,
1768                       SUBSECTION_HASH::ITERATOR (IntId.section_hash_map_->begin ()),
1769                       -1);
1770     }
1771
1772   // Get the next entry
1773   ACE_Hash_Map_Entry<ACE_Configuration_ExtId, int>* entry = 0;
1774   if (!pKey->section_iter_->next (entry))
1775     return 1;
1776
1777   // Return the value of the iterator and advance it
1778   pKey->section_iter_->advance ();
1779   name = entry->ext_id_.name_;
1780
1781   return 0;
1782 }
1783
1784 int
1785 ACE_Configuration_Heap::set_string_value (const ACE_Configuration_Section_Key& key,
1786                                           const ACE_TCHAR* name,
1787                                           const ACE_TString& value)
1788 {
1789   ACE_ASSERT (this->allocator_);
1790   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
1791   if (validate_value_name (t_name))
1792     return -1;
1793
1794   ACE_TString section;
1795   if (load_key (key, section))
1796     return -1;
1797
1798   ACE_Configuration_ExtId section_ext (section.fast_rep ());
1799   ACE_Configuration_Section_IntId section_int;
1800   if (index_->find (section_ext, section_int, allocator_))
1801     return -1;
1802
1803   // Get the entry for this item (if it exists)
1804   VALUE_HASH::ENTRY* entry;
1805   ACE_Configuration_ExtId item_name (t_name);
1806   if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0)
1807     {
1808       // found item, replace it
1809       // Free the old value
1810       entry->int_id_.free (allocator_);
1811       // Allocate the new value in this heap
1812       ACE_TCHAR* pers_value =
1813  (ACE_TCHAR *) allocator_->malloc ((value.length () + 1) * sizeof (ACE_TCHAR));
1814       ACE_OS::strcpy (pers_value, value.fast_rep ());
1815       ACE_Configuration_Value_IntId new_value_int (pers_value);
1816       entry->int_id_ = new_value_int;
1817     }
1818   else
1819     {
1820       // it doesn't exist, bind it
1821       ACE_TCHAR* pers_name =
1822  (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (t_name) + 1) * sizeof (ACE_TCHAR));
1823       ACE_OS::strcpy (pers_name, t_name);
1824       ACE_TCHAR* pers_value =
1825  (ACE_TCHAR *) allocator_->malloc ((value.length () + 1) * sizeof (ACE_TCHAR));
1826       ACE_OS::strcpy (pers_value, value.fast_rep ());
1827       ACE_Configuration_ExtId item_name (pers_name);
1828       ACE_Configuration_Value_IntId item_value (pers_value);
1829       if (section_int.value_hash_map_->bind (item_name, item_value, allocator_))
1830         {
1831           allocator_->free (pers_value);
1832           allocator_->free (pers_name);
1833           return -1;
1834         }
1835       return 0;
1836     }
1837
1838   return 0;
1839 }
1840
1841 int
1842 ACE_Configuration_Heap::set_integer_value (const ACE_Configuration_Section_Key& key,
1843                                            const ACE_TCHAR* name,
1844                                            u_int value)
1845 {
1846   ACE_ASSERT (this->allocator_);
1847   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
1848   if (validate_value_name (t_name))
1849     return -1;
1850
1851   // Get the section name from the key
1852   ACE_TString section;
1853   if (load_key (key, section))
1854     return -1;
1855
1856   // Find this section
1857   ACE_Configuration_ExtId section_ext (section.fast_rep ());
1858   ACE_Configuration_Section_IntId section_int;
1859   if (index_->find (section_ext, section_int, allocator_))
1860     return -1;  // section does not exist
1861
1862   // Get the entry for this item (if it exists)
1863   VALUE_HASH::ENTRY* entry;
1864   ACE_Configuration_ExtId item_name (t_name);
1865   if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0)
1866     {
1867       // found item, replace it
1868       ACE_Configuration_Value_IntId new_value_int (value);
1869       entry->int_id_ = new_value_int;
1870     }
1871   else
1872     {
1873       // it doesn't exist, bind it
1874       ACE_TCHAR* pers_name =
1875  (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (t_name) + 1) * sizeof (ACE_TCHAR));
1876       ACE_OS::strcpy (pers_name, t_name);
1877       ACE_Configuration_ExtId item_name (pers_name);
1878       ACE_Configuration_Value_IntId item_value (value);
1879       if (section_int.value_hash_map_->bind (item_name, item_value, allocator_))
1880         {
1881           allocator_->free (pers_name);
1882           return -1;
1883         }
1884       return 0;
1885     }
1886
1887   return 0;
1888 }
1889
1890 int
1891 ACE_Configuration_Heap::set_binary_value (const ACE_Configuration_Section_Key& key,
1892                                           const ACE_TCHAR* name,
1893                                           const void* data,
1894                                           size_t length)
1895 {
1896   ACE_ASSERT (this->allocator_);
1897   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
1898   if (validate_value_name (t_name))
1899     return -1;
1900
1901   // Get the section name from the key
1902   ACE_TString section;
1903   if (load_key (key, section))
1904     return -1;
1905
1906   // Find this section
1907   ACE_Configuration_ExtId section_ext (section.fast_rep ());
1908   ACE_Configuration_Section_IntId section_int;
1909   if (index_->find (section_ext, section_int, allocator_))
1910     return -1;    // section does not exist
1911
1912   // Get the entry for this item (if it exists)
1913   VALUE_HASH::ENTRY* entry;
1914   ACE_Configuration_ExtId item_name (t_name);
1915   if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0)
1916     {
1917       // found item, replace it
1918       // Free the old value
1919       entry->int_id_.free (allocator_);
1920       // Allocate the new value in this heap
1921       ACE_TCHAR* pers_value = (ACE_TCHAR *) allocator_->malloc (length);
1922       ACE_OS::memcpy (pers_value, data, length);
1923       ACE_Configuration_Value_IntId new_value_int (pers_value, length);
1924       entry->int_id_ = new_value_int;
1925     }
1926   else
1927     {
1928       // it doesn't exist, bind it
1929       ACE_TCHAR* pers_name =
1930  (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (t_name) + 1) * sizeof (ACE_TCHAR));
1931       ACE_OS::strcpy (pers_name, t_name);
1932       ACE_TCHAR* pers_value = (ACE_TCHAR *) allocator_->malloc (length);
1933       ACE_OS::memcpy (pers_value, data, length);
1934       ACE_Configuration_ExtId item_name (pers_name);
1935       ACE_Configuration_Value_IntId item_value (pers_value, length);
1936       if (section_int.value_hash_map_->bind (item_name, item_value, allocator_))
1937         {
1938           allocator_->free (pers_value);
1939           allocator_->free (pers_name);
1940           return -1;
1941         }
1942       return 0;
1943     }
1944
1945   return 0;
1946 }
1947
1948 int
1949 ACE_Configuration_Heap::get_string_value (const ACE_Configuration_Section_Key& key,
1950                                           const ACE_TCHAR* name,
1951                                           ACE_TString& value)
1952 {
1953   ACE_ASSERT (this->allocator_);
1954   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
1955   if (validate_value_name (t_name))
1956     return -1;
1957
1958   // Get the section name from the key
1959   ACE_TString section;
1960   if (load_key (key, section))
1961     return -1;
1962
1963   // Find this section
1964   ACE_Configuration_ExtId ExtId (section.fast_rep ());
1965   ACE_Configuration_Section_IntId IntId;
1966   if (index_->find (ExtId, IntId, allocator_))
1967     return -1;    // section does not exist
1968
1969   // See if it exists first
1970   ACE_Configuration_ExtId VExtId (t_name);
1971   ACE_Configuration_Value_IntId VIntId;
1972   if (IntId.value_hash_map_->find (VExtId, VIntId, allocator_))
1973     return -1;    // unknown value
1974
1975   // Check type
1976   if (VIntId.type_ != ACE_Configuration::STRING)
1977     {
1978       errno = ENOENT;
1979       return -1;
1980     }
1981
1982   // everythings ok, return the data
1983   value = static_cast<ACE_TCHAR*> (VIntId.data_.ptr_);
1984   return 0;
1985 }
1986
1987 int
1988 ACE_Configuration_Heap::get_integer_value (const ACE_Configuration_Section_Key& key,
1989                                            const ACE_TCHAR* name,
1990                                            u_int& value)
1991 {
1992   ACE_ASSERT (this->allocator_);
1993
1994   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
1995   if (validate_value_name (t_name))
1996     return -1;
1997
1998   // Get the section name from the key
1999   ACE_TString section (0, 0, false);
2000
2001   if (this->load_key (key, section) != 0)
2002     {
2003       return -1;
2004     }
2005
2006   // Find this section
2007   ACE_Configuration_ExtId ExtId (section.fast_rep ());
2008   ACE_Configuration_Section_IntId IntId;
2009
2010   if (index_->find (ExtId, IntId, allocator_) != 0)
2011     {
2012       return -1;    // section does not exist
2013     }
2014
2015
2016   // See if it exists first
2017   ACE_Configuration_ExtId VExtId (t_name);
2018   ACE_Configuration_Value_IntId VIntId;
2019
2020   if (IntId.value_hash_map_->find (VExtId, VIntId, allocator_) != 0)
2021     {
2022       return -1;    // unknown value
2023     }
2024
2025   // Check type
2026   if (VIntId.type_ != ACE_Configuration::INTEGER)
2027     {
2028       errno = ENOENT;
2029       return -1;
2030     }
2031
2032   // Everythings ok, return the data
2033   value = VIntId.data_.int_;
2034   return 0;
2035 }
2036
2037 int
2038 ACE_Configuration_Heap::get_binary_value (
2039   const ACE_Configuration_Section_Key& key,
2040   const ACE_TCHAR* name,
2041   void*& data,
2042   size_t& length)
2043 {
2044   ACE_ASSERT (this->allocator_);
2045   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
2046   if (validate_value_name (t_name))
2047     return -1;
2048
2049   // Get the section name from the key
2050   ACE_TString section;
2051   if (load_key (key, section))
2052     return -1;
2053
2054   // Find this section
2055   ACE_Configuration_ExtId ExtId (section.fast_rep ());
2056   ACE_Configuration_Section_IntId IntId;
2057   if (index_->find (ExtId, IntId, allocator_))
2058     return -1;    // section does not exist
2059
2060   ACE_Configuration_ExtId VExtId (t_name);
2061   ACE_Configuration_Value_IntId VIntId;
2062   // See if it exists first
2063   if (IntId.value_hash_map_->find (VExtId, VIntId, allocator_))
2064     return -1;    // unknown value
2065
2066   // Check type
2067   if (VIntId.type_ != ACE_Configuration::BINARY)
2068     {
2069       errno = ENOENT;
2070       return -1;
2071     }
2072
2073   // Make a copy
2074   ACE_NEW_RETURN (data, char[VIntId.length_], -1);
2075   ACE_OS::memcpy (data, VIntId.data_.ptr_, VIntId.length_);
2076   length = VIntId.length_;
2077   return 0;
2078 }
2079
2080 int
2081 ACE_Configuration_Heap::find_value (const ACE_Configuration_Section_Key& key,
2082                                     const ACE_TCHAR* name,
2083                                     VALUETYPE& type_out)
2084 {
2085   ACE_ASSERT (this->allocator_);
2086   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
2087   if (validate_value_name (t_name))
2088     return -1;
2089
2090   // Get the section name from the key
2091   ACE_TString section;
2092   if (load_key (key, section))
2093     return -1;
2094
2095   // Find this section
2096   ACE_Configuration_ExtId ExtId (section.fast_rep ());
2097   ACE_Configuration_Section_IntId IntId;
2098   if (index_->find (ExtId, IntId, allocator_))
2099     return -1;    // section does not exist
2100
2101   // Find it
2102   ACE_Configuration_ExtId ValueExtId (t_name);
2103   VALUE_HASH::ENTRY* value_entry;
2104   if (((VALUE_HASH *) IntId.value_hash_map_)->find (ValueExtId, value_entry))
2105     return -1;  // value does not exist
2106
2107   type_out = value_entry->int_id_.type_;
2108   return 0;
2109 }
2110
2111 int
2112 ACE_Configuration_Heap::remove_value (const ACE_Configuration_Section_Key& key,
2113                                       const ACE_TCHAR* name)
2114 {
2115   ACE_ASSERT (this->allocator_);
2116   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
2117   if (validate_value_name (t_name))
2118     return -1;
2119
2120   // Get the section name from the key
2121   ACE_TString section;
2122   if (load_key (key, section))
2123     return -1;
2124
2125   // Find this section
2126   ACE_Configuration_ExtId ExtId (section.fast_rep ());
2127   ACE_Configuration_Section_IntId IntId;
2128   if (index_->find (ExtId, IntId, allocator_))
2129     return -1;    // section does not exist
2130
2131   // Find it
2132   ACE_Configuration_ExtId ValueExtId (t_name);
2133   VALUE_HASH::ENTRY* value_entry;
2134   if (((VALUE_HASH *) IntId.value_hash_map_)->find (ValueExtId, value_entry))
2135     return -1;
2136
2137   // free it
2138   value_entry->ext_id_.free (allocator_);
2139   value_entry->int_id_.free (allocator_);
2140
2141   // Unbind it
2142   if (IntId.value_hash_map_->unbind (ValueExtId, allocator_))
2143     return -1;
2144
2145   return 0;
2146 }
2147
2148 ACE_END_VERSIONED_NAMESPACE_DECL