store/source/storpage.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include "storpage.hxx"
  31
  32 #include "sal/types.h"
  33 #include "rtl/string.h"
  34 #include "rtl/ref.hxx"
  35 #include "osl/diagnose.h"
  36 #include "osl/mutex.hxx"
  37
  38 #include "store/types.h"
  39
  40 #include "object.hxx"
  41 #include "lockbyte.hxx"
  42
  43 #include "storbase.hxx"
  44 #include "stordata.hxx"
  45 #include "stortree.hxx"
  46
  47 using namespace store;
  48
  49 /*========================================================================
  50  *
  51  * OStorePageManager implementation.
  52  *
  53  *======================================================================*/
  54 const sal_uInt32 OStorePageManager::m_nTypeId = sal_uInt32(0x62190120);
  55
  56 /*
  57  * OStorePageManager.
  58  */
  59 OStorePageManager::OStorePageManager (void)
  60 {
  61 }
  62
  63 /*
  64  * ~OStorePageManager.
  65  */
  66 OStorePageManager::~OStorePageManager (void)
  67 {
  68 }
  69
  70 /*
  71  * isKindOf.
  72  */
  73 sal_Bool SAL_CALL OStorePageManager::isKindOf (sal_uInt32 nTypeId)
  74 {
  75     return (nTypeId == m_nTypeId);
  76 }
  77
  78 /*
  79  * initialize (two-phase construction).
  80  * Precond: none.
  81  */
  82 storeError OStorePageManager::initialize (
  83     ILockBytes *    pLockBytes,
  84     storeAccessMode eAccessMode,
  85     sal_uInt16 &    rnPageSize)
  86 {
  87     // Acquire exclusive access.
  88     osl::MutexGuard aGuard(*this);
  89
  90     // Check arguments.
  91     if (!pLockBytes)
  92         return store_E_InvalidParameter;
  93
  94     // Initialize base.
  95     storeError eErrCode = base::initialize (pLockBytes, eAccessMode, rnPageSize);
  96     if (eErrCode != store_E_None)
  97         return eErrCode;
  98
  99     // Check for (not) writeable.
 100     if (!base::isWriteable())
 101     {
 102         // Readonly. Load RootNode.
 103         return base::loadObjectAt (m_aRoot, rnPageSize);
 104     }
 105
 106     // Writeable. Load or Create RootNode.
 107     eErrCode = m_aRoot.loadOrCreate (rnPageSize, *this);
 108     if (eErrCode == store_E_Pending)
 109     {
 110         // Creation notification.
 111         PageHolderObject< page > xRoot (m_aRoot.get());
 112
 113         // Pre-allocate left most entry (ugly, but we can't insert to left).
 114         OStorePageKey aKey (rtl_crc32 (0, "/", 1), 0);
 115         xRoot->insert (0, entry(aKey));
 116
 117         // Save RootNode.
 118         eErrCode = base::saveObjectAt (m_aRoot, rnPageSize);
 119     }
 120
 121     // Done.
 122     return eErrCode;
 123 }
 124
 125 /*
 126  * find_lookup (w/o split()).
 127  * Internal: Precond: initialized, readable, exclusive access.
 128  */
 129 storeError OStorePageManager::find_lookup (
 130     OStoreBTreeNodeObject & rNode,
 131     sal_uInt16 &            rIndex,
 132     OStorePageKey const &   rKey)
 133 {
 134     // Find Node and Index.
 135     storeError eErrCode = m_aRoot.find_lookup (rNode, rIndex, rKey, *this);
 136     if (eErrCode != store_E_None)
 137         return eErrCode;
 138
 139     // Greater or Equal.
 140     PageHolderObject< page > xPage (rNode.get());
 141     OSL_POSTCOND(rIndex < xPage->usageCount(), "store::PageManager::find_lookup(): logic error");
 142     entry e (xPage->m_pData[rIndex]);
 143
 144     // Check for exact match.
 145     if (e.compare(entry(rKey)) != entry::COMPARE_EQUAL)
 146     {
 147         // Page not present.
 148         return store_E_NotExists;
 149     }
 150
 151     // Check address.
 152     if (e.m_aLink.location() == STORE_PAGE_NULL)
 153     {
 154         // Page not present.
 155         return store_E_NotExists;
 156     }
 157
 158     return store_E_None;
 159 }
 160
 161 /*
 162  * remove_Impl (possibly down from root).
 163  * Internal: Precond: initialized, writeable, exclusive access.
 164  */
 165
 166 storeError OStorePageManager::remove_Impl (entry & rEntry)
 167 {
 168     OStoreBTreeNodeObject aNode (m_aRoot.get());
 169
 170     // Check current page index.
 171     PageHolderObject< page > xPage (aNode.get());
 172     sal_uInt16 i = xPage->find (rEntry), n = xPage->usageCount();
 173     if (!(i < n))
 174     {
 175         // Path to entry not exists (Must not happen(?)).
 176         return store_E_NotExists;
 177     }
 178
 179     // Compare entry.
 180     entry::CompareResult result = rEntry.compare (xPage->m_pData[i]);
 181
 182     // Iterate down until equal match.
 183     while ((result == entry::COMPARE_GREATER) && (xPage->depth() > 0))
 184     {
 185         // Check link address.
 186         sal_uInt32 const nAddr = xPage->m_pData[i].m_aLink.location();
 187         if (nAddr == STORE_PAGE_NULL)
 188         {
 189             // Path to entry not exists (Must not happen(?)).
 190             return store_E_NotExists;
 191         }
 192
 193         // Load link page.
 194         storeError eErrCode = loadObjectAt (aNode, nAddr);
 195         if (eErrCode != store_E_None)
 196             return eErrCode;
 197
 198         PageHolderObject< page > xNext (aNode.get());
 199         xNext.swap (xPage);
 200
 201         // Check index.
 202         i = xPage->find (rEntry), n = xPage->usageCount();
 203         if (!(i < n))
 204         {
 205             // Path to entry not exists (Must not happen(?)).
 206             return store_E_NotExists;
 207         }
 208
 209         // Compare entry.
 210         result = rEntry.compare (xPage->m_pData[i]);
 211     }
 212
 213     OSL_POSTCOND(
 214         result != entry::COMPARE_LESS,
 215         "OStorePageManager::remove(): find failed");
 216
 217     // Check entry comparison.
 218     if (result == entry::COMPARE_LESS)
 219     {
 220         // Must not happen.
 221         return store_E_Unknown;
 222     }
 223
 224     // Remove down from current page (recursive).
 225     return aNode.remove (i, rEntry, *this);
 226 }
 227
 228 /*
 229  * namei.
 230  * Precond: none (static).
 231  */
 232 storeError OStorePageManager::namei (
 233     const rtl_String *pPath, const rtl_String *pName, OStorePageKey &rKey)
 234 {
 235     // Check parameter.
 236     if (!(pPath && pName))
 237         return store_E_InvalidParameter;
 238
 239     // Check name length.
 240     if (!(pName->length < STORE_MAXIMUM_NAMESIZE))
 241         return store_E_NameTooLong;
 242
 243     // Transform pathname into key.
 244     rKey.m_nLow  = store::htonl(rtl_crc32 (0, pName->buffer, pName->length));
 245     rKey.m_nHigh = store::htonl(rtl_crc32 (0, pPath->buffer, pPath->length));
 246
 247     // Done.
 248     return store_E_None;
 249 }
 250
 251 /*
 252  * iget.
 253  * Precond: initialized.
 254  */
 255 storeError OStorePageManager::iget (
 256     OStoreDirectoryPageObject & rPage,
 257     sal_uInt32                  nAttrib,
 258     const rtl_String          * pPath,
 259     const rtl_String          * pName,
 260     storeAccessMode             eMode)
 261 {
 262     // Acquire exclusive access.
 263     osl::MutexGuard aGuard(*this);
 264
 265     // Check precond.
 266     if (!self::isValid())
 267         return store_E_InvalidAccess;
 268
 269     // Setup inode page key.
 270     OStorePageKey aKey;
 271     storeError eErrCode = namei (pPath, pName, aKey);
 272     if (eErrCode != store_E_None)
 273         return eErrCode;
 274
 275     // Check for directory.
 276     if (nAttrib & STORE_ATTRIB_ISDIR)
 277     {
 278         // Ugly, but necessary (backward compatibility).
 279         aKey.m_nLow = store::htonl(rtl_crc32 (store::ntohl(aKey.m_nLow), "/", 1));
 280     }
 281
 282     // Load inode page.
 283     eErrCode = load_dirpage_Impl (aKey, rPage);
 284     if (eErrCode != store_E_None)
 285     {
 286         // Check mode and reason.
 287         if (eErrCode != store_E_NotExists)
 288             return eErrCode;
 289
 290         if (eMode == store_AccessReadWrite)
 291             return store_E_NotExists;
 292         if (eMode == store_AccessReadOnly)
 293             return store_E_NotExists;
 294
 295         if (!base::isWriteable())
 296             return store_E_AccessViolation;
 297
 298         // Create inode page.
 299         eErrCode = rPage.construct< inode >(base::allocator());
 300         if (eErrCode != store_E_None)
 301             return eErrCode;
 302
 303         // Setup inode nameblock.
 304         PageHolderObject< inode > xPage (rPage.get());
 305
 306         rPage.key (aKey);
 307         rPage.attrib (nAttrib);
 308
 309         memcpy (
 310             &(xPage->m_aNameBlock.m_pData[0]),
 311             pName->buffer, pName->length);
 312
 313         // Save inode page.
 314         eErrCode = save_dirpage_Impl (aKey, rPage);
 315         if (eErrCode != store_E_None)
 316             return eErrCode;
 317     }
 318
 319     // Check for symbolic link.
 320     if (rPage.attrib() & STORE_ATTRIB_ISLINK)
 321     {
 322         // Obtain 'Destination' page key.
 323         PageHolderObject< inode > xPage (rPage.get());
 324         OStorePageKey aDstKey;
 325         memcpy (&aDstKey, &(xPage->m_pData[0]), sizeof(aDstKey));
 326
 327         // Load 'Destination' inode.
 328         eErrCode = load_dirpage_Impl (aDstKey, rPage);
 329         if (eErrCode != store_E_None)
 330             return eErrCode;
 331     }
 332
 333     // Done.
 334     return store_E_None;
 335 }
 336
 337 /*
 338  * iterate.
 339  * Precond: initialized.
 340  * ToDo: skip hardlink entries.
 341  */
 342 storeError OStorePageManager::iterate (
 343     OStorePageKey &  rKey,
 344     OStorePageLink & rLink,
 345     sal_uInt32 &     rAttrib)
 346 {
 347     // Acquire exclusive access.
 348     osl::MutexGuard aGuard(*this);
 349
 350     // Check precond.
 351     if (!self::isValid())
 352         return store_E_InvalidAccess;
 353
 354     // Find NodePage and Index.
 355     OStoreBTreeNodeObject aNode;
 356     sal_uInt16 i = 0;
 357     storeError eErrCode = m_aRoot.find_lookup (aNode, i, rKey, *this);
 358     if (eErrCode != store_E_None)
 359         return eErrCode;
 360
 361     // GreaterEqual. Found next entry.
 362     PageHolderObject< page > xNode (aNode.get());
 363     entry e (xNode->m_pData[i]);
 364
 365     // Setup result.
 366     rKey    = e.m_aKey;
 367     rLink   = e.m_aLink;
 368     rAttrib = store::ntohl(e.m_nAttrib);
 369
 370     // Done.
 371     return store_E_None;
 372 }
 373
 374 /*
 375  * load => private: iget() @@@
 376  * Internal: Precond: initialized, exclusive access.
 377  */
 378 storeError OStorePageManager::load_dirpage_Impl (
 379     const OStorePageKey       &rKey,
 380     OStoreDirectoryPageObject &rPage)
 381 {
 382     // Find Node and Index.
 383     OStoreBTreeNodeObject aNode;
 384     sal_uInt16 i = 0;
 385     storeError eErrCode = find_lookup (aNode, i, rKey);
 386     if (eErrCode != store_E_None)
 387         return eErrCode;
 388
 389     // Existing entry. Load page.
 390     PageHolderObject< page > xNode (aNode.get());
 391     entry e (xNode->m_pData[i]);
 392     return loadObjectAt (rPage, e.m_aLink.location());
 393 }
 394
 395 /*
 396  * save => private: iget(), rebuild() @@@
 397  * Internal: Precond: initialized, writeable, exclusive access.
 398  */
 399 storeError OStorePageManager::save_dirpage_Impl (
 400     const OStorePageKey       &rKey,
 401     OStoreDirectoryPageObject &rPage)
 402 {
 403     // Find NodePage and Index.
 404     node aNode;
 405     sal_uInt16 i = 0;
 406
 407     storeError eErrCode = m_aRoot.find_insert (aNode, i, rKey, *this);
 408     PageHolderObject< page > xNode (aNode.get());
 409     if (eErrCode != store_E_None)
 410     {
 411         if (eErrCode != store_E_AlreadyExists)
 412             return eErrCode;
 413
 414         // Existing entry.
 415         entry e (xNode->m_pData[i]);
 416         if (e.m_aLink.location() != STORE_PAGE_NULL)
 417         {
 418             // Save page to existing location.
 419             return saveObjectAt (rPage, e.m_aLink.location());
 420         }
 421
 422         // Allocate page.
 423         eErrCode = base::allocate (rPage);
 424         if (eErrCode != store_E_None)
 425             return eErrCode;
 426
 427         // Update page location.
 428         xNode->m_pData[i].m_aLink = rPage.location();
 429
 430         // Save modified NodePage.
 431         return saveObjectAt (aNode, aNode.location());
 432     }
 433
 434     // Allocate page.
 435     eErrCode = base::allocate (rPage);
 436     if (eErrCode != store_E_None)
 437         return eErrCode;
 438
 439     // Insert.
 440     OStorePageLink aLink (rPage.location());
 441     xNode->insert (i + 1, entry (rKey, aLink));
 442
 443     // Save modified NodePage.
 444     return saveObjectAt (aNode, aNode.location());
 445 }
 446
 447 /*
 448  * attrib [nAttrib = ((nAttrib & ~nMask1) | nMask2)].
 449  * Precond: initialized.
 450  */
 451 storeError OStorePageManager::attrib (
 452     const OStorePageKey &rKey,
 453     sal_uInt32           nMask1,
 454     sal_uInt32           nMask2,
 455     sal_uInt32          &rAttrib)
 456 {
 457     // Acquire exclusive access.
 458     osl::MutexGuard aGuard(*this);
 459
 460     // Check precond.
 461     if (!self::isValid())
 462         return store_E_InvalidAccess;
 463
 464     // Find NodePage and index.
 465     OStoreBTreeNodeObject aNode;
 466     sal_uInt16 i = 0;
 467     storeError eErrCode = find_lookup (aNode, i, rKey);
 468     if (eErrCode != store_E_None)
 469         return eErrCode;
 470
 471     // Existing entry.
 472     PageHolderObject< page > xNode (aNode.get());
 473     entry e (xNode->m_pData[i]);
 474     if (nMask1 != nMask2)
 475     {
 476         // Evaluate new attributes.
 477         sal_uInt32 nAttrib = store::ntohl(e.m_nAttrib);
 478
 479         nAttrib &= ~nMask1;
 480         nAttrib |=  nMask2;
 481
 482         if (store::htonl(nAttrib) != e.m_nAttrib)
 483         {
 484             // Check access mode.
 485             if (base::isWriteable())
 486             {
 487                 // Set new attributes.
 488                 e.m_nAttrib = store::htonl(nAttrib);
 489                 xNode->m_pData[i] = e;
 490
 491                 // Save modified NodePage.
 492                 eErrCode = saveObjectAt (aNode, aNode.location());
 493             }
 494             else
 495             {
 496                 // Access denied.
 497                 eErrCode = store_E_AccessViolation;
 498             }
 499         }
 500     }
 501
 502     // Obtain current attributes.
 503     rAttrib = store::ntohl(e.m_nAttrib);
 504     return eErrCode;
 505 }
 506
 507 /*
 508  * link (insert 'Source' as hardlink to 'Destination').
 509  * Precond: initialized, writeable.
 510  */
 511 storeError OStorePageManager::link (
 512     const OStorePageKey &rSrcKey,
 513     const OStorePageKey &rDstKey)
 514 {
 515     // Acquire exclusive access.
 516     osl::MutexGuard aGuard(*this);
 517
 518     // Check precond.
 519     if (!self::isValid())
 520         return store_E_InvalidAccess;
 521
 522     if (!base::isWriteable())
 523         return store_E_AccessViolation;
 524
 525     // Find 'Destination' NodePage and Index.
 526     OStoreBTreeNodeObject aDstNode;
 527     sal_uInt16 i = 0;
 528     storeError eErrCode = find_lookup (aDstNode, i, rDstKey);
 529     if (eErrCode != store_E_None)
 530         return eErrCode;
 531
 532     // Existing 'Destination' entry.
 533     PageHolderObject< page > xDstNode (aDstNode.get());
 534     entry e (xDstNode->m_pData[i]);
 535     OStorePageLink aDstLink (e.m_aLink);
 536
 537     // Find 'Source' NodePage and Index.
 538     OStoreBTreeNodeObject aSrcNode;
 539     eErrCode = m_aRoot.find_insert (aSrcNode, i, rSrcKey, *this);
 540     if (eErrCode != store_E_None)
 541         return eErrCode;
 542
 543     // Insert 'Source' entry.
 544     PageHolderObject< page > xSrcNode (aSrcNode.get());
 545     xSrcNode->insert (i + 1, entry (rSrcKey, aDstLink, STORE_ATTRIB_ISLINK));
 546     return saveObjectAt (aSrcNode, aSrcNode.location());
 547 }
 548
 549 /*
 550  * symlink (insert 'Source' DirectoryPage as symlink to 'Destination').
 551  * Precond: initialized, writeable.
 552  */
 553 storeError OStorePageManager::symlink (
 554     const rtl_String    *pSrcPath,
 555     const rtl_String    *pSrcName,
 556     const OStorePageKey &rDstKey)
 557 {
 558     // Acquire exclusive access.
 559     osl::MutexGuard aGuard(*this);
 560
 561     // Check precond.
 562     if (!self::isValid())
 563         return store_E_InvalidAccess;
 564
 565     if (!base::isWriteable())
 566         return store_E_AccessViolation;
 567
 568     // Check 'Source' parameter.
 569     storeError eErrCode = store_E_InvalidParameter;
 570     if (!(pSrcPath && pSrcName))
 571         return eErrCode;
 572
 573     // Setup 'Source' page key.
 574     OStorePageKey aSrcKey;
 575     eErrCode = namei (pSrcPath, pSrcName, aSrcKey);
 576     if (eErrCode != store_E_None)
 577         return eErrCode;
 578
 579     // Find 'Source' NodePage and Index.
 580     OStoreBTreeNodeObject aSrcNode;
 581     sal_uInt16 i = 0;
 582     eErrCode = m_aRoot.find_insert (aSrcNode, i, aSrcKey, *this);
 583     if (eErrCode != store_E_None)
 584         return eErrCode;
 585
 586     // Initialize directory page.
 587     OStoreDirectoryPageObject aPage;
 588     eErrCode = aPage.construct< inode >(base::allocator());
 589     if (eErrCode != store_E_None)
 590         return eErrCode;
 591
 592     // Setup as 'Source' directory page.
 593     inode_holder_type xNode (aPage.get());
 594     aPage.key (aSrcKey);
 595     memcpy (
 596         &(xNode->m_aNameBlock.m_pData[0]),
 597         pSrcName->buffer, pSrcName->length);
 598
 599     // Store 'Destination' page key.
 600     OStorePageKey aDstKey (rDstKey);
 601     memcpy (&(xNode->m_pData[0]), &aDstKey, sizeof(aDstKey));
 602
 603     // Mark 'Source' as symbolic link to 'Destination'.
 604     aPage.attrib (STORE_ATTRIB_ISLINK);
 605     aPage.dataLength (sal_uInt32(sizeof(aDstKey)));
 606
 607     // Allocate and save 'Source' directory page.
 608     eErrCode = base::allocate (aPage);
 609     if (eErrCode != store_E_None)
 610         return eErrCode;
 611
 612     // Insert 'Source' entry.
 613     PageHolderObject< page > xSrcNode (aSrcNode.get());
 614     OStorePageLink aSrcLink (aPage.location());
 615     xSrcNode->insert (i + 1, entry(aSrcKey, aSrcLink));
 616
 617     // Save modified NodePage.
 618     return saveObjectAt (aSrcNode, aSrcNode.location());
 619 }
 620
 621 /*
 622  * rename.
 623  * Precond: initialized, writeable.
 624  */
 625 storeError OStorePageManager::rename (
 626     const OStorePageKey &rSrcKey,
 627     const rtl_String    *pDstPath,
 628     const rtl_String    *pDstName)
 629 {
 630     // Acquire exclusive access.
 631     osl::MutexGuard aGuard(*this);
 632
 633     // Check precond.
 634     if (!self::isValid())
 635         return store_E_InvalidAccess;
 636
 637     if (!base::isWriteable())
 638         return store_E_AccessViolation;
 639
 640     // Check 'Destination' parameter.
 641     storeError eErrCode = store_E_InvalidParameter;
 642     if (!(pDstPath && pDstName))
 643         return eErrCode;
 644
 645     // Setup 'Destination' page key.
 646     OStorePageKey aDstKey;
 647     eErrCode = namei (pDstPath, pDstName, aDstKey);
 648     if (eErrCode != store_E_None)
 649         return eErrCode;
 650
 651     // Find 'Source' NodePage and Index.
 652     OStoreBTreeNodeObject aSrcNode;
 653     sal_uInt16 i = 0;
 654     eErrCode = find_lookup (aSrcNode, i, rSrcKey);
 655     if (eErrCode != store_E_None)
 656         return eErrCode;
 657
 658     // Existing 'Source' entry.
 659     PageHolderObject< page > xSrcNode (aSrcNode.get());
 660     entry e (xSrcNode->m_pData[i]);
 661
 662     // Check for (not a) hardlink.
 663     OStoreDirectoryPageObject aPage;
 664     if (!(store::ntohl(e.m_nAttrib) & STORE_ATTRIB_ISLINK))
 665     {
 666         // Load directory page.
 667         eErrCode = base::loadObjectAt (aPage, e.m_aLink.location());
 668         if (eErrCode != store_E_None)
 669             return eErrCode;
 670
 671         // Check for directory.
 672         if (aPage.attrib() & STORE_ATTRIB_ISDIR)
 673         {
 674             // Ugly, but necessary (backward compatibility).
 675             aDstKey.m_nLow = store::htonl(rtl_crc32 (store::ntohl(aDstKey.m_nLow), "/", 1));
 676         }
 677     }
 678
 679     // Let 'Source' entry be 'Destination' entry.
 680     e.m_aKey = aDstKey;
 681
 682     // Find 'Destination' NodePage and Index.
 683     OStoreBTreeNodeObject aDstNode;
 684     eErrCode = m_aRoot.find_insert (aDstNode, i, e.m_aKey, *this);
 685     if (eErrCode != store_E_None)
 686         return eErrCode;
 687
 688     // Insert 'Destination' entry.
 689     PageHolderObject< page > xDstNode (aDstNode.get());
 690     xDstNode->insert (i + 1, e);
 691
 692     eErrCode = saveObjectAt (aDstNode, aDstNode.location());
 693     if (eErrCode != store_E_None)
 694         return eErrCode;
 695
 696     // Check for (not a) hardlink.
 697     if (!(store::ntohl(e.m_nAttrib) & STORE_ATTRIB_ISLINK))
 698     {
 699         // Modify 'Source' directory page.
 700         inode_holder_type xNode (aPage.get());
 701
 702         // Setup 'Destination' NameBlock.
 703         sal_Int32 nDstLen = pDstName->length;
 704         memcpy (
 705             &(xNode->m_aNameBlock.m_pData[0]),
 706             pDstName->buffer, pDstName->length);
 707         memset (
 708             &(xNode->m_aNameBlock.m_pData[nDstLen]),
 709             0, STORE_MAXIMUM_NAMESIZE - nDstLen);
 710         aPage.key (e.m_aKey);
 711
 712         // Save directory page.
 713         eErrCode = base::saveObjectAt (aPage, e.m_aLink.location());
 714         if (eErrCode != store_E_None)
 715             return eErrCode;
 716     }
 717
 718     // Remove 'Source' entry.
 719     e.m_aKey = rSrcKey;
 720     return remove_Impl (e);
 721 }
 722
 723 /*
 724  * remove.
 725  * Precond: initialized, writeable.
 726  */
 727 storeError OStorePageManager::remove (const OStorePageKey &rKey)
 728 {
 729     // Acquire exclusive access.
 730     osl::MutexGuard aGuard(*this);
 731
 732     // Check precond.
 733     if (!self::isValid())
 734         return store_E_InvalidAccess;
 735
 736     if (!base::isWriteable())
 737         return store_E_AccessViolation;
 738
 739     // Find NodePage and index.
 740     OStoreBTreeNodeObject aNodePage;
 741     sal_uInt16 i = 0;
 742     storeError eErrCode = find_lookup (aNodePage, i, rKey);
 743     if (eErrCode != store_E_None)
 744         return eErrCode;
 745
 746     // Existing entry.
 747     PageHolderObject< page > xNodePage (aNodePage.get());
 748     entry e (xNodePage->m_pData[i]);
 749
 750     // Check for (not a) hardlink.
 751     if (!(store::ntohl(e.m_nAttrib) & STORE_ATTRIB_ISLINK))
 752     {
 753         // Load directory page.
 754         OStoreDirectoryPageObject aPage;
 755         eErrCode = base::loadObjectAt (aPage, e.m_aLink.location());
 756         if (eErrCode != store_E_None)
 757             return eErrCode;
 758
 759         inode_holder_type xNode (aPage.get());
 760
 761         // Acquire page write access.
 762         OStorePageDescriptor aDescr (xNode->m_aDescr);
 763         eErrCode = base::acquirePage (aDescr, store_AccessReadWrite);
 764         if (eErrCode != store_E_None)
 765             return eErrCode;
 766
 767         // Check for symbolic link.
 768         if (!(aPage.attrib() & STORE_ATTRIB_ISLINK))
 769         {
 770             // Ordinary inode. Determine 'Data' scope.
 771             inode::ChunkScope eScope = xNode->scope (aPage.dataLength());
 772             if (eScope == inode::SCOPE_EXTERNAL)
 773             {
 774                 // External 'Data' scope. Truncate all external data pages.
 775                 eErrCode = aPage.truncate (0, *this);
 776                 if (eErrCode != store_E_None)
 777                     return eErrCode;
 778             }
 779
 780             // Truncate internal data page.
 781             memset (&(xNode->m_pData[0]), 0, xNode->capacity());
 782             aPage.dataLength (0);
 783         }
 784
 785         // Release page write access.
 786         eErrCode = base::releasePage (aDescr);
 787
 788         // Release and free directory page.
 789         eErrCode = base::free (aPage.location());
 790     }
 791
 792     // Remove entry.
 793     return remove_Impl (e);
 794 }
 795
 796 /*
 797  * RebuildContext.
 798  */
 799 struct RebuildContext
 800 {
 801     /** Representation.
 802     */
 803     rtl::Reference<OStorePageBIOS> m_xBIOS;
 804     OStorePageBIOS::ScanContext    m_aCtx;
 805     sal_uInt16                     m_nPageSize;
 806
 807     /** Construction.
 808      */
 809     RebuildContext (void)
 810         : m_xBIOS     (new OStorePageBIOS()),
 811           m_nPageSize (0)
 812     {}
 813
 814     /** initialize (PageBIOS and ScanContext).
 815     */
 816     storeError initialize (ILockBytes *pLockBytes, sal_uInt32 nMagic = 0)
 817     {
 818         storeError eErrCode = store_E_InvalidParameter;
 819         if (pLockBytes)
 820         {
 821             m_xBIOS->initialize (pLockBytes, store_AccessReadOnly, m_nPageSize);
 822             eErrCode = m_xBIOS->scanBegin (m_aCtx, nMagic);
 823         }
 824         return eErrCode;
 825     }
 826
 827     /** initialize (ScanContext).
 828     */
 829     storeError initialize (sal_uInt32 nMagic = 0)
 830     {
 831         return m_xBIOS->scanBegin (m_aCtx, nMagic);
 832     }
 833
 834     /** load (next ScanContext matching page).
 835     */
 836     storeError load (OStorePageObject &rPage)
 837     {
 838         if (m_aCtx.isValid())
 839             return m_xBIOS->scanNext (m_aCtx, rPage);
 840         else
 841             return store_E_CantSeek;
 842     }
 843 };
 844
 845 /*
 846  * rebuild.
 847  * Precond: none.
 848  */
 849 storeError OStorePageManager::rebuild (
 850     ILockBytes *pSrcLB, ILockBytes *pDstLB)
 851 {
 852     // Acquire exclusive access.
 853     osl::MutexGuard aGuard(*this);
 854
 855     // Check arguments.
 856     storeError eErrCode = store_E_InvalidParameter;
 857     if (!(pSrcLB && pDstLB))
 858         return eErrCode;
 859
 860     // Initialize 'Source' rebuild context.
 861     RebuildContext aCtx;
 862     eErrCode = aCtx.initialize (pSrcLB, STORE_MAGIC_DIRECTORYPAGE);
 863     if (eErrCode != store_E_None)
 864         return eErrCode;
 865     rtl::Reference<OStorePageBIOS> xSrcBIOS (aCtx.m_xBIOS);
 866
 867     // Initialize as 'Destination' with 'Source' page size.
 868     eErrCode = self::initialize (pDstLB, store_AccessCreate, aCtx.m_nPageSize);
 869     if (eErrCode != store_E_None)
 870         return eErrCode;
 871
 872     // Pass One: Scan 'Source' directory pages.
 873     {
 874         // Scan 'Source' directory pages.
 875         OStoreDirectoryPageObject aSrcPage;
 876         while ((eErrCode = aCtx.load(aSrcPage)) == store_E_None)
 877         {
 878             OStoreDirectoryPageObject aDstPage;
 879             eErrCode = aDstPage.construct< inode >(base::allocator());
 880             if (eErrCode != store_E_None)
 881                 break;
 882
 883             inode_holder_type xSrcDir (aSrcPage.get());
 884             inode_holder_type xDstDir (aDstPage.get());
 885
 886             // Copy NameBlock @@@ OLD @@@
 887             memcpy (&(xDstDir->m_aNameBlock), &(xSrcDir->m_aNameBlock), sizeof(xSrcDir->m_aNameBlock));
 888
 889             // Obtain 'Source' data length.
 890             sal_uInt32 nDataLen = aSrcPage.dataLength();
 891             if (nDataLen > 0)
 892             {
 893                 // Copy internal data area @@@ OLD @@@
 894                 memcpy (&(xDstDir->m_pData[0]), &(xSrcDir->m_pData[0]), xSrcDir->capacity());
 895             }
 896
 897             // Insert 'Destination' directory page.
 898             eErrCode = save_dirpage_Impl (aDstPage.key(), aDstPage);
 899             if (eErrCode != store_E_None)
 900                 break;
 901
 902             // Check for external data page scope.
 903             if (xSrcDir->scope(nDataLen) != inode::SCOPE_INTERNAL)
 904             {
 905                 // Initialize 'Destination' data page.
 906                 typedef OStoreDataPageData data;
 907                 PageHolderObject< data > xData;
 908                 if (!xData.construct(base::allocator()))
 909                     return store_E_OutOfMemory;
 910
 911                 // Determine data page count.
 912                 inode::ChunkDescriptor aDescr (
 913                     nDataLen - xDstDir->capacity(), xData->capacity());
 914
 915                 sal_uInt32 i, n = aDescr.m_nPage;
 916                 if (aDescr.m_nOffset) n += 1;
 917
 918                 // Copy data pages.
 919                 OStoreDataPageObject aData;
 920                 for (i = 0; i < n; i++)
 921                 {
 922                     // Read 'Source' data page.
 923                     osl::MutexGuard aSrcGuard (*xSrcBIOS);
 924
 925                     eErrCode = aSrcPage.read (i, aData, *xSrcBIOS);
 926                     if (eErrCode != store_E_None)
 927                         continue;
 928
 929                     // Write 'Destination' data page. @@@ READONLY @@@
 930                     eErrCode = aDstPage.write (i, aData, *this);
 931                 }
 932             }
 933
 934             // Update 'Destination' directory page.
 935             aDstPage.dataLength (nDataLen);
 936             eErrCode = base::saveObjectAt (aDstPage, aDstPage.location());
 937         }
 938
 939         // Save directory scan results.
 940         flush();
 941     }
 942
 943     // Pass Two: Scan 'Source' BTree nodes.
 944     {
 945         // Re-start 'Source' rebuild context.
 946         aCtx.initialize (STORE_MAGIC_BTREENODE);
 947
 948         // Scan 'Source' BTree nodes.
 949         OStoreBTreeNodeObject aNode;
 950         while ((eErrCode = aCtx.load(aNode)) == store_E_None)
 951         {
 952             // Check for leaf node.
 953             PageHolderObject< page > xNode (aNode.get());
 954             if (xNode->depth() == 0)
 955             {
 956                 sal_uInt16 i, n = xNode->usageCount();
 957                 for (i = 0; i < n; i++)
 958                 {
 959                     entry e (xNode->m_pData[i]);
 960
 961                     // Check for Hard link.
 962                     if (e.m_nAttrib & STORE_ATTRIB_ISLINK)
 963                     {
 964                         // Load the hard link destination.
 965                         OStoreDirectoryPageObject aSrcPage;
 966                         eErrCode = xSrcBIOS->loadObjectAt (aSrcPage, e.m_aLink.location());
 967                         if (eErrCode == store_E_None)
 968                         {
 969                             OStorePageKey aDstKey (aSrcPage.key());
 970                             eErrCode = link (e.m_aKey, aDstKey);
 971                         }
 972                         e.m_nAttrib &= ~STORE_ATTRIB_ISLINK;
 973                     }
 974
 975                     if (e.m_nAttrib)
 976                     {
 977                         // Ordinary attributes.
 978                         sal_uInt32 nAttrib = 0;
 979                         eErrCode = attrib (e.m_aKey, 0, e.m_nAttrib, nAttrib);
 980                     }
 981                 }
 982             }
 983         }
 984
 985         // Save BTree node scan results.
 986         flush();
 987     }
 988
 989     // Done.
 990     return store_E_None;
 991 }
 992
 993 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */