hfs-556.60.1.tar.gz

[apple/hfs.git] / fsck_hfs / dfalib / dirhardlink.c

/*
 * Copyright (c) 2007-2008 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include "Scavenger.h"
#include "SRuntime.h"
#include <sys/stat.h>
#include <ctype.h>

/* Looks up a catalog file/folder record for given file/folder ID.  
 * The functionality of this routine is same as GetCatalogRecord() in 
 * dfalib/SRepair.c, but this implementation is better because it does not 
 * change the lastIterator stored in the catalog BTreeControlBlock.
 * Therefore this function does not interfere with other catalog btree 
 * iterations.
 */
OSErr GetCatalogRecordByID(SGlobPtr GPtr, UInt32 file_id, Boolean isHFSPlus, CatalogKey *key, CatalogRecord *rec, uint16_t *recsize)
{
        int retval = 0;
        SFCB *fcb;
        BTreeControlBlock *btcb;
        FSBufferDescriptor buf_desc;
        BTreeIterator search_iterator;
        BTreeIterator result_iterator;
        uint32_t thread_key_parentID = 0;

        fcb = GPtr->calculatedCatalogFCB;
        btcb = (BTreeControlBlock *)fcb->fcbBtree;

        /* Lookup the thread record with given file/folderID */
        bzero(&buf_desc, sizeof(buf_desc));
        bzero(&search_iterator, sizeof(search_iterator));
        buf_desc.bufferAddress = rec;
        buf_desc.itemCount = 1;
        buf_desc.itemSize = sizeof(CatalogRecord);

        BuildCatalogKey(file_id, NULL, isHFSPlus, (CatalogKey *)&(search_iterator.key));
        retval = BTSearchRecord(fcb, &search_iterator, kInvalidMRUCacheKey, 
                        &buf_desc, recsize, &result_iterator);
        if (retval) {
                goto out;
        }

        /* Check if really we found a thread record */
        if (isHFSPlus) {
                if ((rec->recordType != kHFSPlusFolderThreadRecord) &&
                    (rec->recordType != kHFSPlusFileThreadRecord)) {
                        retval = ENOENT;
                        goto out;
                }
        } else {
                if ((rec->recordType != kHFSFolderThreadRecord) &&
                    (rec->recordType != kHFSFileThreadRecord)) {
                        retval = ENOENT;
                        goto out;
                }
        }

        if (isHFSPlus) {
                thread_key_parentID = ((CatalogKey *)&(result_iterator.key))->hfsPlus.parentID;
        }
        
        /* Lookup the corresponding file/folder record */
        bzero(&buf_desc, sizeof(buf_desc));
        bzero(&search_iterator, sizeof(search_iterator));
        buf_desc.bufferAddress = rec;
        buf_desc.itemCount = 1;
        buf_desc.itemSize = sizeof(CatalogRecord);

        if (isHFSPlus) {
                BuildCatalogKey(rec->hfsPlusThread.parentID, 
                        (CatalogName *)&(rec->hfsPlusThread.nodeName),
                        isHFSPlus, (CatalogKey *)&(search_iterator.key));
        } else {
                BuildCatalogKey(rec->hfsThread.parentID, 
                        (CatalogName *)&(rec->hfsThread.nodeName),
                        isHFSPlus, (CatalogKey *)&(search_iterator.key));
        }
        retval = BTSearchRecord(fcb, &search_iterator, kInvalidMRUCacheKey, 
                        &buf_desc, recsize, &result_iterator);
        if (retval) {
                goto out;
        }
        
        bcopy(&(result_iterator.key), key, CalcKeySize(btcb, &(result_iterator.key)));
        
        if (isHFSPlus) {
                /* For catalog file or folder record, the parentID in the thread 
                 * record's key should be equal to the fileID in the file/folder 
                 * record --- which is equal to the ID of the file/folder record
                 * that is being looked up.  If not, mark the volume for repair. 
                 */
                if (thread_key_parentID != rec->hfsPlusFile.fileID) {
                        RcdError(GPtr, E_IncorrectNumThdRcd);
                        if (fsckGetVerbosity(GPtr->context) >= kDebugLog) {
                                plog("\t%s: fileID=%u, thread.key.parentID=%u, record.fileID=%u\n", 
                                        __FUNCTION__, file_id, thread_key_parentID, rec->hfsPlusFile.fileID);
                        }
                        GPtr->CBTStat |= S_Orphan;
                }
        }

out:
        return retval;
}

/* Record minor repair order for invalid permissions for directory hardlink priv dir */
static int record_privdir_bad_perm(SGlobPtr gptr, uint32_t cnid)
{
        RepairOrderPtr p;

        RcdError (gptr, E_BadPermPrivDir);
        p = AllocMinorRepairOrder(gptr, 0);
        if (p == NULL) {
                return ENOMEM;
        }

        p->type = E_BadPermPrivDir;
        p->parid = cnid;
        gptr->CatStat |= S_LinkErrRepair;

        return 0;
}

/* Record minor repair order for invalid flags for file/directory hard links */
int record_link_badflags(SGlobPtr gptr, uint32_t link_id, Boolean isdir,
                uint32_t incorrect, uint32_t correct)
{
        RepairOrderPtr p;
        char str1[12];
        char str2[12];

        fsckPrint(gptr->context, isdir? E_DirLinkBadFlags : E_FileLinkBadFlags, link_id);
        snprintf(str1, sizeof(str1), "0x%x", correct);
        snprintf(str2, sizeof(str2), "0x%x", incorrect);
        fsckPrint(gptr->context, E_BadValue, str1, str2);
        
        p = AllocMinorRepairOrder(gptr, 0);
        if (p == NULL) {
                return ENOMEM;
        }
        
        p->type = isdir ? E_DirLinkBadFlags : E_FileLinkBadFlags;
        p->correct = correct;
        p->incorrect = incorrect;
        p->parid = link_id;

        gptr->CatStat |= S_LinkErrRepair;

        return 0;
}

/* Record minor repair order for invalid flags for file/directory inode 
 * If a corruption is recorded during verification, do not check for 
 * duplicates as none should exist.  If this corruption is recorded 
 * during repair, check for duplicates because before early termination 
 * of verification we might have seen this corruption.
 */
int record_inode_badflags(SGlobPtr gptr, uint32_t inode_id, Boolean isdir,
                uint32_t incorrect, uint32_t correct, Boolean check_duplicates)
{
        RepairOrderPtr p;
        char str1[12];
        char str2[12];

        p = AllocMinorRepairOrder(gptr, 0);
        if (p == NULL) {
                return ENOMEM;
        }
        
        p->type = isdir ? E_DirInodeBadFlags : E_FileInodeBadFlags;
        p->correct = correct;
        p->incorrect = incorrect;
        p->parid = inode_id;

        gptr->CatStat |= S_LinkErrRepair;

        if ((check_duplicates != 0) && 
            (IsDuplicateRepairOrder(gptr, p) == 1)) {
                DeleteRepairOrder(gptr, p);
        } else {
                fsckPrint(gptr->context, isdir? E_DirInodeBadFlags : E_FileInodeBadFlags, inode_id);
                snprintf(str1, sizeof(str1), "0x%x", correct);
                snprintf(str2, sizeof(str2), "0x%x", incorrect);
                fsckPrint(gptr->context, E_BadValue, str1, str2);
        }

        return 0;
}

/* Record minor repair order for invalid parent of directory/file inode */
/* XXX -- not repaired yet (file or directory) */
static int record_inode_badparent(SGlobPtr gptr, uint32_t inode_id, Boolean isdir,
                uint32_t incorrect, uint32_t correct)
{
        char str1[12];
        char str2[12];

        fsckPrint(gptr->context, isdir? E_DirInodeBadParent : E_FileInodeBadParent, inode_id);
        snprintf(str1, sizeof(str1), "%u", correct);
        snprintf(str2, sizeof(str2), "%u", incorrect);
        fsckPrint(gptr->context, E_BadValue, str1, str2);

        gptr->CatStat |= S_LinkErrNoRepair;

        return 0;
}

/* Record minor repair order for invalid name of directory inode */
/* XXX - not repaired yet (file or directory) */
static int record_inode_badname(SGlobPtr gptr, uint32_t inode_id,
                char *incorrect, char *correct)
{
        fsckPrint(gptr->context, E_DirInodeBadName, inode_id);
        fsckPrint(gptr->context, E_BadValue, correct, incorrect);

        gptr->CatStat |= S_LinkErrNoRepair;

        return 0;
}

/* Record corruption for incorrect number of directory hard links and 
 * directory inode, and invalid list of directory hard links
 */
void record_link_badchain(SGlobPtr gptr, Boolean isdir)
{
        int fval = (isdir ? S_DirHardLinkChain : S_FileHardLinkChain);
        int err = (isdir ? E_DirHardLinkChain : E_FileHardLinkChain);
        if ((gptr->CatStat & fval) == 0) {
                fsckPrint(gptr->context, err);
                gptr->CatStat |= fval;
        }
}

/* Record minor repair for invalid ownerflags for directory hard links.
 * If corruption is recorded during verification, do not check for 
 * duplicates as none should exist.  If this corruption is recorded 
 * during repair, check for duplicates because before early termination 
 * of verification, we might have seen this corruption.
 */
int record_dirlink_badownerflags(SGlobPtr gptr, uint32_t file_id,
                        uint8_t incorrect, uint8_t correct, int check_duplicates)
{
        RepairOrderPtr p;
        char str1[12];
        char str2[12];

        p = AllocMinorRepairOrder(gptr, 0);
        if (p == NULL) {
                return ENOMEM;
        }
        
        p->type = E_DirHardLinkOwnerFlags;
        p->correct = correct;
        p->incorrect = incorrect;
        p->parid = file_id;

        gptr->CatStat |= S_LinkErrRepair;

        if ((check_duplicates != 0) && 
            (IsDuplicateRepairOrder(gptr, p) == 1)) {
                DeleteRepairOrder(gptr, p);
        } else {
                fsckPrint(gptr->context, E_DirHardLinkOwnerFlags, file_id);
                snprintf(str1, sizeof(str1), "0x%x", correct);
                snprintf(str2, sizeof(str2), "0x%x", incorrect);
                fsckPrint(gptr->context, E_BadValue, str1, str2);
        }

        return 0;
}

/* Record minor repair for invalid finderInfo for directory hard links */
int record_link_badfinderinfo(SGlobPtr gptr, uint32_t file_id, Boolean isdir)
{
        RepairOrderPtr p;

        p = AllocMinorRepairOrder(gptr, 0);
        if (p == NULL) {
                return ENOMEM;
        }
        
        p->type = isdir ? E_DirHardLinkFinderInfo : E_FileHardLinkFinderInfo;
        p->parid = file_id;

        gptr->CatStat |= (isdir ? S_DirHardLinkChain : S_FileHardLinkChain);

        /* Recording this corruption is being called from both 
         * inode_check() and dirlink_check().  It is possible that 
         * the error we are adding is a duplicate error.  Check for 
         * duplicates, and if any duplicates are found delete the new
         * repair order.
         */
        if (IsDuplicateRepairOrder(gptr, p) == 1) {
                DeleteRepairOrder(gptr, p);
        } else {
                fsckPrint(gptr->context, p->type, file_id);
        }

        return 0;
}

/* Record minor repair for invalid flags in one of the parent directories 
 * of a directory hard link.
 */
static int record_parent_badflags(SGlobPtr gptr, uint32_t dir_id,
                uint32_t incorrect, uint32_t correct)
{
        RepairOrderPtr p;
        char str1[12];
        char str2[12];

        p = AllocMinorRepairOrder(gptr, 0);
        if (p == NULL) {
                return ENOMEM;
        }
        
        p->type = E_DirLinkAncestorFlags;
        p->correct = correct;
        p->incorrect = incorrect;
        p->parid = dir_id;

        gptr->CatStat |= S_LinkErrRepair;

        /* This corruption is logged when traversing ancestors of all
         * directory hard links.  Therefore common corrupt ancestors of 
         * directory hard link will result in duplicate repair orders. 
         * Check for duplicates, and if any duplicates are found delete 
         * the new repair order.
         */
        if (IsDuplicateRepairOrder(gptr, p) == 1) {
                DeleteRepairOrder(gptr, p);
        } else {
                fsckPrint(gptr->context, E_DirLinkAncestorFlags, dir_id);
                snprintf(str1, sizeof(str1), "0x%x", correct);
                snprintf(str2, sizeof(str2), "0x%x", incorrect);
                fsckPrint(gptr->context, E_BadValue, str1, str2);
        }

        return 0;
}

/* Look up the ".HFS+ Private Directory Data\xd" directory */
static int priv_dir_lookup(SGlobPtr gptr, CatalogKey *key, CatalogRecord *rec) 
{
        int i;
        int retval;
        char *dirname = HFSPLUS_DIR_METADATA_FOLDER;
        CatalogName cat_dirname;
        uint16_t recsize;
        uint32_t hint;

        /* Look up the catalog btree record for the private metadata directory */
        cat_dirname.ustr.length = strlen(dirname);
        for (i = 0; i < cat_dirname.ustr.length; i++) {
                cat_dirname.ustr.unicode[i] = (u_int16_t) dirname[i];
        }
        BuildCatalogKey(kHFSRootFolderID, &cat_dirname, true, key);
        retval = SearchBTreeRecord (gptr->calculatedCatalogFCB, key, kNoHint, 
                                    NULL, rec, &recsize, &hint);
        return retval;
} 

/* This function initializes the directory hard link check by looking up
 * private directory that stores directory inodes.  
 */
int dirhardlink_init(SGlobPtr gptr)
{
        int retval = 0; 
        CatalogRecord rec;
        CatalogKey key;

        /* Check if the volume is HFS+. */ 
        if (VolumeObjectIsHFSPlus() == false) {
                goto out;
        }

        /* Look up the private metadata directory */
        retval = priv_dir_lookup(gptr, &key, &rec);
        if (retval == 0) {
                gptr->dirlink_priv_dir_id = rec.hfsPlusFolder.folderID;
                gptr->dirlink_priv_dir_valence = rec.hfsPlusFolder.valence;
        } else {
                gptr->dirlink_priv_dir_id = 0;
                gptr->dirlink_priv_dir_valence = 0;
        }

        retval = 0;

out:
        return retval;
}

/* Check the private directory for directory hard links */
static void dirlink_priv_dir_check(SGlobPtr gptr, HFSPlusCatalogFolder *rec, 
                HFSPlusCatalogKey *key)
{
        /* ownerFlags should have UF_IMMUTABLE and UF_HIDDEN set, and 
           fileMode should have S_ISVTX set */
        if (((rec->bsdInfo.ownerFlags & UF_IMMUTABLE) == 0) ||
            //(((rec->bsdInfo.adminFlags << 16) & UF_HIDDEN) == 0) || 
            ((rec->bsdInfo.fileMode & S_ISVTX) == 0)) {
                record_privdir_bad_perm(gptr, rec->folderID);
        }
}

/* Get the first link ID information for a hard link inode.
 * For directory inodes, we get it from the extended attribute 
 * of the directory inode; for files, we get it from hl_firstLinkID
 * Returns - zero if the lookup succeeded with the first link ID 
 * in the pointer provided, and non-zero if the extended attribute
 * does not exist, or any other error encountered during lookup.
 */
int get_first_link_id(SGlobPtr gptr, CatalogRecord *inode_rec, uint32_t inode_id, 
                Boolean isdir, uint32_t *first_link_id)
{
        int retval = 0;
        int i;
        BTreeIterator iterator;
        FSBufferDescriptor bt_data;
        HFSPlusAttrData *rec;
        HFSPlusAttrKey *key;
        u_int8_t attrdata[FIRST_LINK_XATTR_REC_SIZE];
        size_t unicode_bytes = 0;

        bzero(&iterator, sizeof(iterator));

        if (isdir) {
                /* Create key for the required attribute */
                key = (HFSPlusAttrKey *)&iterator.key;
                utf_decodestr((unsigned char *)FIRST_LINK_XATTR_NAME, 
                              strlen(FIRST_LINK_XATTR_NAME), key->attrName, 
                              &unicode_bytes, sizeof(key->attrName));
                key->attrNameLen = unicode_bytes / sizeof(UniChar);
                key->keyLength = kHFSPlusAttrKeyMinimumLength + unicode_bytes;
                key->pad = 0;
                key->fileID = inode_id;
                key->startBlock = 0;

                rec = (HFSPlusAttrData *)&attrdata[0];
                bt_data.bufferAddress = rec;
                bt_data.itemSize = sizeof(attrdata);
                bt_data.itemCount = 1;

                retval = BTSearchRecord(gptr->calculatedAttributesFCB, &iterator, kNoHint, 
                                        &bt_data, NULL, NULL);
                if (retval == 0) {
            unsigned long link_id;

                        /* Attribute should be an inline attribute */
                        if (rec->recordType != kHFSPlusAttrInlineData) {
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog ("\tfirst link EA is not inline for dirinode=%u (found=0x%x)\n", inode_id, rec->recordType);
                                }
                                retval = ENOENT;
                                goto out;
                        }
                                
                        /* Attribute data should be null terminated, attrSize includes
                         * size of the attribute data including the null termination.
                         */
                        if (rec->attrData[rec->attrSize-1] != '\0') {
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog ("\tfirst link EA attrData is not NULL terminated for dirinode=%u\n", inode_id);
                                }
                                retval = ENOENT;
                                goto out;
                        }

                        /* All characters are numbers in the attribute data */
                        for (i = 0; i < rec->attrSize-1; i++) {
                                if (isdigit(rec->attrData[i]) == 0) {
                                        if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                                plog ("\tfirst link EA attrData contains non-digit 0x%x for dirinode=%u\n", rec->attrData[i], inode_id);
                                        }
                                        retval = ENOENT;
                                goto out;
                                }
                        }

            link_id = strtoul((char *)&rec->attrData[0], NULL, 10);
            if (link_id > UINT32_MAX) {
                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                    plog ("\tfirst link ID=%lu is > UINT32_MAX for dirinode=%u\n", link_id, inode_id);
                }
                *first_link_id = 0;
                retval = ENOENT;
                goto out;
            }
                        *first_link_id = (uint32_t)link_id;
                        if (*first_link_id < kHFSFirstUserCatalogNodeID) {
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog ("\tfirst link ID=%u is < 16 for dirinode=%u\n", *first_link_id, inode_id);
                                }
                                *first_link_id = 0;
                                retval = ENOENT;
                        goto out;
                        }
                } 
        } else {
                *first_link_id = 0;
                if ((inode_rec != NULL) && 
                    (inode_rec->recordType == kHFSPlusFileRecord)) {
                        *first_link_id = inode_rec->hfsPlusFile.hl_firstLinkID;
                        if (*first_link_id < kHFSFirstUserCatalogNodeID) {
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog("\tfirst link ID=%u is < 16 for fileinode=%u\n", *first_link_id, inode_id);
                                }
                                *first_link_id = 0;
                                retval = ENOENT;
                                goto out;
                        }
                } else {
                        CatalogRecord rec;
                        CatalogKey key;
                        uint16_t recsize;

                        /* No record or bad record provided, look it up */
                        retval = GetCatalogRecordByID(gptr, inode_id, true, &key, &rec, &recsize);
                        if (retval == 0) {
                                *first_link_id = rec.hfsPlusFile.hl_firstLinkID;
                                if (rec.recordType != kHFSPlusFileRecord ||
                                        *first_link_id < kHFSFirstUserCatalogNodeID) {
                                        if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                                plog("\tfirst link ID=%u is < 16 for fileinode=%u\n", *first_link_id, inode_id);
                                        }
                                        *first_link_id = 0;
                                        retval = ENOENT;
                                }
                        } else {
                                *first_link_id = 0;
                                retval = ENOENT;
                        }
                }
        }

out:
        return retval;
}

/* Adds the directory inode, and directory hard link pair to the 
 * prime remainder bucket provided.  This is based on Chinese Remainder
 * Theorem, and the buckets are later compared to find if the directory 
 * hard link chains for all directory inodes are valid.   
 */
void hardlink_add_bucket(PrimeBuckets *bucket, uint32_t inode_id, 
                uint32_t cur_link_id) 
{
        uint64_t num;

        num = ((uint64_t)inode_id << 32) | cur_link_id;

        add_prime_bucket_uint64(bucket, num);
}

/* Structure to store the directory hard link IDs found during doubly linked 
 * list traversal in inode_check() 
 */ 
struct link_list {
        uint32_t link_id;
        struct link_list *next;
};

/* Verifies the inode record.  Validates if the flags are set 
 * correctly, parent is the private metadata directory, first link ID 
 * is stored correctly, and the doubly linked * list of hard links is valid.  
 *
 * Returns - 
 *      zero -  if no corruption is detected, or the corruption detected is 
 *              such that a repair order can be created. 
 *  non-zero -  if the corruption detected requires complete knowledge of 
 *              all the related directory hard links to suggest repair.
 */
int inode_check(SGlobPtr gptr, PrimeBuckets *bucket, 
                CatalogRecord *rec, CatalogKey *key, Boolean isdir)
{
        int retval = 0;
        uint32_t inode_id;
        uint32_t cur_link_id;
        uint32_t prev_link_id;
        uint32_t count;
        uint32_t linkCount;
        char calc_name[32];
        char found_name[NAME_MAX];
        size_t calc_len;
        size_t found_len;
        CatalogKey linkkey;
        CatalogRecord linkrec;
        uint16_t recsize;
        int flags;
        uint32_t parentid;
        uint32_t link_ref_num = 0;

        struct link_list *head = NULL;
        struct link_list *cur;

        (void) utf_encodestr(key->hfsPlus.nodeName.unicode, key->hfsPlus.nodeName.length * 2, 
                        (unsigned char *)found_name, &found_len, NAME_MAX);
        found_name[found_len] = '\0';

        if (isdir) {
                inode_id = rec->hfsPlusFolder.folderID;
                flags = rec->hfsPlusFolder.flags;
                linkCount = rec->hfsPlusFolder.bsdInfo.special.linkCount;
                parentid = gptr->dirlink_priv_dir_id;
        } else {
        unsigned long ref_num;

                inode_id = rec->hfsPlusFile.fileID;
                flags = rec->hfsPlusFile.flags;
                linkCount = rec->hfsPlusFile.bsdInfo.special.linkCount;
                parentid = gptr->filelink_priv_dir_id;
        ref_num = strtoul(&found_name[strlen(HFS_INODE_PREFIX)], NULL, 10);
        if (ref_num > UINT32_MAX) {
            if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                plog ("\tlink reference num=%lu is > UINT32_MAX for inode=%u\n", ref_num, inode_id);
            }
            retval = 1;
            goto out;
        }
                link_ref_num = (uint32_t)ref_num;
        }

        /* inode should only reside in its corresponding private directory */
        if ((parentid != 0) && (key->hfsPlus.parentID != parentid)) {
                (void) record_inode_badparent(gptr, inode_id, isdir, key->hfsPlus.parentID, parentid);
        }

        /* Compare the names for directory inode only because the names 
         * of file inodes can have random number suffixed.
         */
        if (isdir) {
                (void) snprintf(calc_name, sizeof(calc_name), "%s%u", HFS_DIRINODE_PREFIX, inode_id);
                calc_len = strlen(calc_name);
        
                if ((found_len != calc_len) ||
                    (strncmp(calc_name, found_name, calc_len) != 0)) {
                        (void) record_inode_badname(gptr, inode_id, found_name,
                                        calc_name);
                }
        }

        /* At least one hard link should always point at an inode. */
        if (linkCount == 0) {
                record_link_badchain(gptr, isdir);
                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                        plog ("\tlinkCount=0 for dirinode=%u\n", inode_id);
                }
                retval = 1;
                goto out;
        }

        /* A directory inode should always have kHFSHasLinkChainBit 
         * set.  A file inode created on pre-Leopard OS does not have 
         * kHFSHasLinkChainBit set and firstLinkID is zero.  Therefore 
         * ignore such file inodes from CRT check and instead add the 
         * the inode to hash used for checking link count. 
         */
        if ((flags & kHFSHasLinkChainMask) == 0) {
                if ((isdir) || (!isdir && (rec->hfsPlusFile.hl_firstLinkID != 0))) {
                        (void) record_inode_badflags(gptr, inode_id, isdir, 
                                        flags, flags | kHFSHasLinkChainMask, false);
                } else {
                        filelink_hash_inode(link_ref_num, linkCount);
                        retval = 0;
                        goto out;
                }
        }

        /* Lookup the ID of first link from the extended attribute */
        retval = get_first_link_id(gptr, rec, inode_id, isdir, &cur_link_id);
        if (retval) {
                record_link_badchain(gptr, isdir);
                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                        plog ("\tError getting first link ID for inode=%u\n", inode_id);
                }
                goto out;
        }

        /* Check doubly linked list of hard links that point to this inode */
        prev_link_id = 0;
        count = 0;

        while (cur_link_id != 0) {
                /* Lookup the current directory link record */
                retval = GetCatalogRecordByID(gptr, cur_link_id, true, 
                                &linkkey, &linkrec, &recsize);
                if (retval) {
                        record_link_badchain(gptr, isdir);
                        if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                plog ("\tError getting link=%u for inode=%u\n", cur_link_id, inode_id);
                        }
                        goto out;
                }

                /* Hard link is a file record */
                if (linkrec.recordType != kHFSPlusFileRecord) {
                        record_link_badchain(gptr, isdir);
                        if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                plog ("\tIncorrect record type for link=%u for inode=%u (expected=2, found=%u)\n", cur_link_id, inode_id, linkrec.recordType);
                        }
                        retval = 1;
                        goto out;
                }
                   
                /* Hard link should have hard link bit set */
                if ((linkrec.hfsPlusFile.flags & kHFSHasLinkChainMask) == 0) {
                        (void) record_link_badchain(gptr, isdir);
                        if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                plog ("\tIncorrect flag for link=%u for inode=%u (found=0x%x)\n", cur_link_id, inode_id, linkrec.hfsPlusFile.flags);
                        }
                        retval = 1;
                        goto out;
                }
                
                if (isdir) {
                        /* Check if the hard link has correct finder info */
                        if ((linkrec.hfsPlusFile.userInfo.fdType != kHFSAliasType) ||
                            (linkrec.hfsPlusFile.userInfo.fdCreator != kHFSAliasCreator) || 
                            ((linkrec.hfsPlusFile.userInfo.fdFlags & kIsAlias) == 0)) {
                                record_link_badfinderinfo(gptr, linkrec.hfsPlusFile.fileID, isdir);
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog("\tdirlink: fdType = 0x%08lx, fdCreator = 0x%08lx\n", 
                                                (unsigned long)linkrec.hfsPlusFile.userInfo.fdType, 
                                                (unsigned long)linkrec.hfsPlusFile.userInfo.fdCreator);
                                }
                        }

                        /* Check if hard link points to the current inode */
                        if (linkrec.hfsPlusFile.hl_linkReference != inode_id) {
                                record_link_badchain(gptr, isdir);
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog ("\tIncorrect dirinode ID for dirlink=%u (expected=%u, found=%u)\n", cur_link_id, inode_id, linkrec.hfsPlusFile.hl_linkReference);
                                }
                                retval = 1;
                                goto out;
                        }

                } else {
                        /* Check if the hard link has correct finder info */
                        if ((linkrec.hfsPlusFile.userInfo.fdType != kHardLinkFileType) ||
                            (linkrec.hfsPlusFile.userInfo.fdCreator != kHFSPlusCreator)) {
                                record_link_badfinderinfo(gptr, linkrec.hfsPlusFile.fileID, isdir);
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog("\tfilelink: fdType = 0x%08lx, fdCreator = 0x%08lx\n", 
                                                (unsigned long)linkrec.hfsPlusFile.userInfo.fdType, 
                                                (unsigned long)linkrec.hfsPlusFile.userInfo.fdCreator);
                                }
                        }

                        /* Check if hard link has correct link reference number */
                        if (linkrec.hfsPlusFile.hl_linkReference != link_ref_num) {
                                record_link_badchain(gptr, isdir);
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog ("\tIncorrect link reference number for filelink=%u (expected=%u, found=%u)\n", cur_link_id, inode_id, linkrec.hfsPlusFile.hl_linkReference);
                                }
                                retval = 1;
                                goto out;
                        }
                }

                /* For directory hard links, add the directory inode ID and 
                 * the current link ID pair to the prime bucket.  For file 
                 * hard links, add the link reference number and current 
                 * link ID pair to the prime bucket.
                 */
                if (isdir) {
                        hardlink_add_bucket(bucket, inode_id, cur_link_id);
                } else {
                        hardlink_add_bucket(bucket, link_ref_num, cur_link_id);
                }

                /* Check the previous directory hard link */
                if (prev_link_id != linkrec.hfsPlusFile.hl_prevLinkID) {
                        record_link_badchain(gptr, isdir);
                        if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                plog ("\tIncorrect prevLinkID for link=%u for inode=%u (expected=%u, found=%u)\n", cur_link_id, inode_id, prev_link_id, linkrec.hfsPlusFile.hl_prevLinkID);
                        }
                        retval = 1;
                        goto out;
                }
                
                /* Check if we saw this directory hard link previously */
                cur = head;
                while (cur) {
                        if (cur->link_id == cur_link_id) {
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog ("\tDuplicate link=%u found in list for inode=%u\n", cur_link_id, inode_id);
                                }
                                record_link_badchain(gptr, isdir);
                                retval = 1;
                                goto out;
                        }
                        cur = cur->next;
                }
                
                /* Add the new unique directory hard link to our list */
                cur = malloc(sizeof(struct link_list));
                if (!cur) {
                        retval = ENOMEM;
                        goto out;
                }
                cur->link_id = cur_link_id;
                cur->next = head;
                head = cur;

                count++;
                prev_link_id = cur_link_id;
                cur_link_id = linkrec.hfsPlusFile.hl_nextLinkID;
        }

        /* If the entire chain looks good, match the link count */
        if (linkCount != count) {
                record_link_badchain(gptr, isdir);
                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                        plog ("\tIncorrect linkCount for inode=%u (expected=%u, found=%u)\n", inode_id, count, linkCount);
                }
                retval = 1;
                goto out;
        }

out:
        /* Free memory used for checking duplicates in the doubly linked list */
        while(head) {
                cur = head;
                head = head->next;
                free(cur);
        }

        return retval;
}


/* Check if the parent ancestors starting at the given directory has
 * the kHFSHasChildLinkBit set.  This bit indicates that a descendant of 
 * this directory is a directory hard link.  Note that the root folder
 * and the "private directory data" directory does not have this bit 
 * set, and the check stops as soon as we encounter one of these 
 * directories.
 */
static void check_dirlink_ancestors(SGlobPtr gptr, uint32_t dir_id)
{
        int retval = 0;
        CatalogRecord rec;
        CatalogKey key;
        uint16_t recsize;

        while ((dir_id != kHFSRootFolderID) && (dir_id != gptr->dirlink_priv_dir_id)) {
                retval = GetCatalogRecordByID(gptr, dir_id, true, &key, &rec, &recsize);
                if (retval != 0) {
                        break;
                }

                if (rec.recordType != kHFSPlusFolderRecord) {
                        break;
                }

                if ((rec.hfsPlusFolder.flags & kHFSHasChildLinkMask) == 0) {
                        (void) record_parent_badflags(gptr, dir_id,
                                        rec.hfsPlusFolder.flags,
                                        rec.hfsPlusFolder.flags | kHFSHasChildLinkMask);
                }

                dir_id = key.hfsPlus.parentID;
        }

        /* If there was any problem in looking up parent directory, 
         * the catalog check should have also detected the problem.  
         * But there are cases which are not detected like names in 
         * thread record and file/folder record key do not match. 
         * Therefore force repair for incorrect number of thread 
         * records if lookup fails.
         */
        if ((dir_id != kHFSRootFolderID) && (dir_id != gptr->dirlink_priv_dir_id)) {
                fsckPrint(gptr->context, E_BadParentHierarchy, dir_id);
                gptr->CBTStat |= S_Orphan;
        }

        return;
}

/* Verifies the directory hard link record.  Validates if the flags are set 
 * correctly, the finderInfo fields are correct, and if the parent hierarchy 
 * till the root folder (except the root folder) has the kHFSHasChildLinkBit 
 * set correctly.  This function also add the directory inode, and the  
 * directory hard link pair to the prime buckets for comparison later.
 *
 * This function does not verify the first and the next directory hard link
 * pointers in the doubly linked list because the check is already done 
 * in directory inode check (inode_check()) .  Any orphan directory 
 * hard link will also be detected later by the prime bucket comparison.
 */
static void dirlink_check(SGlobPtr gptr, PrimeBuckets *bucket, 
                HFSPlusCatalogFile *rec, HFSPlusCatalogKey *key, Boolean isdir)
{
        /* Add this directory hard link and corresponding inode number pair
         * to prime buckets
         */
#if DEBUG_HARDLINKCHECK
        if (fsckGetVerbosity(gptr->context) >= kDebugLog)
                plog("link_check:  adding <%u, %u>\n", rec->hl_linkReference, rec->fileID);
#endif

        hardlink_add_bucket(bucket, rec->hl_linkReference, rec->fileID);

        /* Check if the directory hard link has UF_IMMUTABLE bit set */
        if ((rec->bsdInfo.ownerFlags & UF_IMMUTABLE) == 0) {
                record_dirlink_badownerflags(gptr, rec->fileID, 
                        rec->bsdInfo.ownerFlags, 
                        rec->bsdInfo.ownerFlags | UF_IMMUTABLE, false);
        }

        /* Check Finder Info */
        if ((rec->userInfo.fdType != kHFSAliasType) ||
            (rec->userInfo.fdCreator != kHFSAliasCreator) ||
            ((rec->userInfo.fdFlags & kIsAlias) == 0)) {
                record_link_badfinderinfo(gptr, rec->fileID, isdir);
        }

        /* XXX - Check resource fork/alias data */

        /* Check if all the parent directories have the kHFSHasChildLinkBit set */
        check_dirlink_ancestors(gptr, key->parentID);
}

/* Searches the next child directory record to return given the parent ID
 * and the current child ID.  If the current child ID is zero, this is the 
 * first time we are looking up this directory, therefore return the 
 * first child directory or directory hard link found.  If child ID is 
 * non-zero, return the first child directory or directory hard 
 * link found after the current child record.
 * 
 * For normal directories, the folder ID is returned as the new child inode_id
 * and catalog_id.  For directory hard links, the inode_id of the directory 
 * inode is returned in the inode_id, and the fileID of the directory hard link
 * is returned in the catalog_id.  If the inode_id returned corresponds to a 
 * directory inode, is_dirinode is set to true.  If no child record is found, 
 * or an error occurred on btree traversal, these values are zero.
 *
 * Returns -
 *      zero - on successfully determining if the next child record exists 
 *             or not.
 *  non-zero - error, like during btree lookup, etc.
 */
static int find_next_child_dir(SGlobPtr gptr, uint32_t parent_id, 
                uint32_t cur_child_catalog_id, uint32_t *child_inode_id, 
                uint32_t *child_catalog_id, uint32_t *is_dirinode)
{       
        int retval;
        SFCB *fcb;
        int return_next_rec = true;
        BTreeIterator iterator;
        FSBufferDescriptor buf_desc;
        uint16_t recsize;
        CatalogRecord rec;
        CatalogKey *key;

        *child_inode_id = 0;
        *child_catalog_id = 0;
        *is_dirinode = false;

        fcb = gptr->calculatedCatalogFCB;
        key = (CatalogKey *)&iterator.key;

        /* If no child record for this parent has been looked up previously, 
         * return the first child record found.  Otherwise lookup the 
         * catalog record for the last child ID provided and return the 
         * next valid child ID.  If the lookup of the last child failed, 
         * fall back to iterating all child records for given parent
         * directory and returning next child found after given child ID. 
         */
        if (cur_child_catalog_id == 0) {
iterate_parent:
                /* Lookup catalog record with key containing given parent ID and NULL 
                 * name.  This will place iterator just before the first child record 
                 * for this directory.
                 */
                bzero(&iterator, sizeof(iterator));
                bzero(&buf_desc, sizeof(buf_desc));
                buf_desc.bufferAddress = &rec;
                buf_desc.itemCount = 1;
                buf_desc.itemSize = sizeof(rec);
                BuildCatalogKey(parent_id, NULL, true, key);
                retval = BTSearchRecord(fcb, &iterator, kNoHint, &buf_desc, &recsize, 
                                &iterator);
                if ((retval != 0) && (retval != btNotFound)) {
                        goto out;
                }
        } else {
                /* Lookup the thread record for the last child seen */
                bzero(&iterator, sizeof(iterator));
                bzero(&buf_desc, sizeof(buf_desc));
                buf_desc.bufferAddress = &rec;
                buf_desc.itemCount = 1;
                buf_desc.itemSize = sizeof(rec);
                BuildCatalogKey(cur_child_catalog_id, NULL, true, key);
                retval = BTSearchRecord(fcb, &iterator, kNoHint, &buf_desc,
                                &recsize, &iterator);
                if (retval) {
                        return_next_rec = false;
                        goto iterate_parent;
                }

                /* Check if really we found a thread record */
                if ((rec.recordType != kHFSPlusFolderThreadRecord) &&
                    (rec.recordType != kHFSPlusFileThreadRecord)) {
                        return_next_rec = false;
                        goto iterate_parent;
                }
        
                /* Lookup the corresponding file/folder record */
                bzero(&iterator, sizeof(iterator));
                bzero(&buf_desc, sizeof(buf_desc));
                buf_desc.bufferAddress = &rec;
                buf_desc.itemCount = 1;
                buf_desc.itemSize = sizeof(rec);
                BuildCatalogKey(rec.hfsPlusThread.parentID, 
                        (CatalogName *)&(rec.hfsPlusThread.nodeName),
                        true, (CatalogKey *)&(iterator.key));
                retval = BTSearchRecord(fcb, &iterator, kInvalidMRUCacheKey, 
                                &buf_desc, &recsize, &iterator);
                if (retval) {
                        return_next_rec = false;
                        goto iterate_parent;
                }
        }

        /* Lookup the next record */
        retval = BTIterateRecord(fcb, kBTreeNextRecord, &iterator, &buf_desc, 
                        &recsize);
        while (retval == 0) {
                /* Not the same parent anymore, stop the search */
                if (key->hfsPlus.parentID != parent_id) {
                        break;
                }

                if (rec.recordType == kHFSPlusFolderRecord) {
                        /* Found a catalog folder record, and if we are 
                         * supposed to return the next record found, return 
                         * this catalog folder.
                         */ 
                        if (return_next_rec) {
                                if (rec.hfsPlusFolder.flags & kHFSHasLinkChainMask) {
                                        *is_dirinode = true;
                                }
                                *child_inode_id = rec.hfsPlusFolder.folderID;
                                *child_catalog_id = rec.hfsPlusFolder.folderID;
                                break;
                        }
                        /* If the current record is the current child, we 
                         * have to return the next child record.
                         */
                        if (rec.hfsPlusFolder.folderID == cur_child_catalog_id) {
                                return_next_rec = true;
                        }
                } else if (rec.recordType == kHFSPlusFileRecord) {
                        /* Check if the hard link bit is set with correct 
                         * alias type/creator.  If the parent is private 
                         * metadata directory for file hard links, this 
                         * is a hard link inode for an alias, and not 
                         * directory hard link.  Skip this file from our 
                         * check.
                         */
                        if ((rec.hfsPlusFile.flags & kHFSHasLinkChainMask) &&
                            (rec.hfsPlusFile.userInfo.fdType == kHFSAliasType) &&
                            (rec.hfsPlusFile.userInfo.fdCreator == kHFSAliasCreator) &&
                            (key->hfsPlus.parentID != gptr->filelink_priv_dir_id)) {
                                /* Found a directory hard link, and if we are 
                                 * supposed to return the next record found,
                                 * then return this directory hard link.
                                 */
                                if (return_next_rec) {
                                        *child_inode_id = rec.hfsPlusFile.hl_linkReference; 
                                        *child_catalog_id = rec.hfsPlusFile.fileID;
                                        *is_dirinode = true;
                                        break;
                                }
                                /* If the current record is the current child,
                                 * we have to return the next child record.
                                 */
                                if (rec.hfsPlusFile.fileID == cur_child_catalog_id) {
                                        return_next_rec = true;
                                }
                        }
                }
                
                /* Lookup the next record */
                retval = BTIterateRecord(fcb, kBTreeNextRecord, &iterator, 
                                &buf_desc, &recsize);
        }

        if (retval == btNotFound) {
                retval = 0;
        }

out:
        return retval;
} 

/* In-memory state for depth first traversal for finding loops in 
 * directory hierarchy.  inode_id is the user visible ID of the given 
 * directory or directory hard link, and catalog_id is the inode ID for 
 * normal directories, and the directory hard link ID (file ID of the 
 * directory hard link record).
 * 
 * The inode_id is used for checking loops in the hierarchy, whereas 
 * the catalog_id is used to maintain state for depth first traversal.
 */
struct dfs_id {
        uint32_t inode_id;
        uint32_t catalog_id;
};

struct dfs_stack {
        uint32_t depth;
        struct dfs_id *idptr;
};

/* Assuming that the name of a directory is single byte, the maximum depth 
 * of a directory hierarchy that can accommodate in PATH_MAX will be 
 * PATH_MAX/2.  Note that catalog hierarchy check puts limitation of 100 
 * on the maximum depth of a directory hierarchy.
 */
#define DIRLINK_DEFAULT_DFS_MAX_DEPTH   PATH_MAX/2

/* Check if the current directory exists in the current traversal path.  
 * If yes, loops in directory exists and return non-zero value.  If not,
 * return zero.
 */
static int check_loops(struct dfs_stack *dfs, struct dfs_id id)
{
        int retval = 0;
        int i;

        for (i = 0; i < dfs->depth; i++) {
                if (dfs->idptr[i].inode_id == id.inode_id) {
                        retval = 1;
                        break;
                }
        }

        return retval;
}

static void print_dfs(struct dfs_stack *dfs)
{
        int i;

        plog ("\t");
        for (i = 0; i < dfs->depth; i++) {
                plog ("(%u,%u) ", dfs->idptr[i].inode_id, dfs->idptr[i].catalog_id);
        }
        plog ("\n");
}

/* Store information about visited directory inodes such that we do not 
 * reenter the directory multiple times while following directory hard links.
 */
struct visited_dirinode {
        uint32_t *list;         /* Pointer to array of IDs */
        uint32_t size;          /* Maximum number of entries in the array */
        uint32_t offset;        /* Offset where next ID will be added */
        uint32_t wrapped;       /* Boolean, true if list wraps around */
};

/* Add the given dirinode_id to the list of visited nodes.  If all the slots 
 * in visited list are used, wrap around and add the new ID.
 */
static void mark_dirinode_visited(uint32_t dirinode_id, struct visited_dirinode *visited)
{
        if (visited->list == NULL) {
                return;
        } 

        if (visited->offset >= visited->size) {
                visited->offset = 0;
                visited->wrapped = true;
        }
        visited->list[visited->offset] = dirinode_id;
        visited->offset++;
}

/* Check if given directory inode exists in the visited list or not */
static int is_dirinode_visited(uint32_t dirinode_id, struct visited_dirinode *visited)
{
        int is_visited = false;
        uint32_t end_offset;
        uint32_t off;

        if (visited->list == NULL) {
                return is_visited;
        } 

        /* If the list had wrapped, search the entire list */
        if (visited->wrapped == true) {
                end_offset = visited->size;     
        } else {
                end_offset = visited->offset;
        }

        for (off = 0; off < end_offset; off++) {
                if (visited->list[off] == dirinode_id) {
                        is_visited = true;
                        break;
                }
        }

        return is_visited;
}

/* Check if there are any loops in the directory hierarchy.  
 *
 * This function performs a depth first traversal of directories as they 
 * will be visible to the user.  If the lookup of private metadata directory 
 * succeeded in dirlink_init(), the traversal starts from the private 
 * metadata directory.  Otherwise it starts at the root folder.  It stores 
 * the current depth first traversal state, and looks up catalog records as 
 * required.  The current traversal state consists of two IDs, the user 
 * visible ID or inode_id, and the on-disk ID or catalog_id.  For normal 
 * directories, the user visible ID is same as the on-disk ID, but for 
 * directory hard links, the user visible ID is the inode ID, and the 
 * on-disk ID is the file ID of the directory hard link.  This function 
 * stores the list of visited directory inode ID and checks the list before 
 * traversing down the directory inode hierarchy.  After traversing down a 
 * directory inode and checking that is valid, it adds the directory inode 
 * ID to the visited list.  
 * 
 * The inode_id is used for checking loops in the hierarchy, whereas 
 * the catalog_id is used to maintain state for depth first traversal.
 * 
 * Returns - 
 *      zero - if the check was performed successfully, and no loops exist
 *             in the directory hierarchy.
 *  non-zero - on error, or if loops were detected in directory hierarchy.
 */
static int check_hierarchy_loops(SGlobPtr gptr) 
{
        int retval = 0;
        struct dfs_stack dfs;
        struct dfs_id unknown_child;
        struct dfs_id child;
        struct dfs_id parent;
        struct visited_dirinode visited;
        size_t max_alloc_depth = DIRLINK_DEFAULT_DFS_MAX_DEPTH;
        uint32_t is_dirinode;

#define DFS_PUSH(dfsid) \
                { \
                        dfs.idptr[dfs.depth].inode_id = dfsid.inode_id; \
                        dfs.idptr[dfs.depth].catalog_id = dfsid.catalog_id; \
                        dfs.depth++; \
                        if (dfs.depth == max_alloc_depth) { \
                                void *tptr = realloc(dfs.idptr, (max_alloc_depth + DIRLINK_DEFAULT_DFS_MAX_DEPTH) * sizeof(struct dfs_id)); \
                                if (tptr == NULL) { \
                                        break; \
                                } else { \
                                        dfs.idptr = tptr; \
                                        max_alloc_depth += DIRLINK_DEFAULT_DFS_MAX_DEPTH; \
                                } \
                        } \
                }

#define DFS_POP(dfsid) \
                { \
                        dfs.depth--; \
                        dfsid.inode_id = dfs.idptr[dfs.depth].inode_id; \
                        dfsid.catalog_id = dfs.idptr[dfs.depth].catalog_id; \
                }
        
#define DFS_PEEK(dfsid) \
                { \
                        dfsid.inode_id = dfs.idptr[dfs.depth-1].inode_id; \
                        dfsid.catalog_id = dfs.idptr[dfs.depth-1].catalog_id; \
                }

        /* Initialize the traversal stack */
        dfs.idptr = malloc(max_alloc_depth * sizeof(struct dfs_id));
        if (!dfs.idptr) {
                return ENOMEM;
        }
        dfs.depth = 0;

        /* Initialize unknown child IDs which are used when a directory is 
         * seen for the first time.
         */
        unknown_child.inode_id = unknown_child.catalog_id = 0;

        /* Allocate visited list for total number of directory inodes seen */
        if (gptr->calculated_dirinodes) {
                visited.size = gptr->calculated_dirinodes;
        } else {
                visited.size = 1024;
        }

        /* If visited list allocation failed, perform search without cache */
        visited.list = malloc(visited.size * sizeof(uint32_t)); 
        if (visited.list == NULL) {
                visited.size = 0;
                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                        plog ("\tcheck_loops: Allocation failed for visited list\n");
                }
        }
        visited.offset = 0;
        visited.wrapped = false;

        /* Set the starting directory for traversal */
        if (gptr->dirlink_priv_dir_id) {
                parent.inode_id = parent.catalog_id = gptr->dirlink_priv_dir_id;
        } else {
                parent.inode_id = parent.catalog_id = kHFSRootFolderID;
        }

        /* Initialize the first parent and its first unknown child */
        do {
                DFS_PUSH(parent);
                DFS_PUSH(unknown_child);
        } while (0);

        while (dfs.depth > 1) {
                DFS_POP(child);
                DFS_PEEK(parent);
                retval = find_next_child_dir(gptr, parent.inode_id,
                                child.catalog_id, &(child.inode_id),
                                &(child.catalog_id), &is_dirinode);
                if (retval) {
                        break;
                }

                if (child.inode_id) {
                        retval = check_loops(&dfs, child);
                        if (retval) {
                                fsckPrint(gptr->context, E_DirLoop);
                                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                        plog ("\tDetected when adding (%u,%u) to following traversal stack -\n", child.inode_id, child.catalog_id);
                                        print_dfs(&dfs);
                                }
                                gptr->CatStat |= S_LinkErrNoRepair;
                                retval = E_DirLoop;
                                break;
                        }

                        /* Push the current child on traversal stack */
                        DFS_PUSH(child);

                        /* Traverse down directory inode only if it was not 
                         * visited previously and mark it visited.  
                         */
                        if (is_dirinode == true) {
                                if (is_dirinode_visited(child.inode_id, &visited)) {
                                        continue;
                                } else {
                                        mark_dirinode_visited(child.inode_id, &visited);
                                }
                        }

                        /* Push unknown child to traverse down the child directory */ 
                        DFS_PUSH(unknown_child);
                }
        }

        if (dfs.depth >= max_alloc_depth) {
                fsckPrint(gptr->context, E_DirHardLinkNesting);
                if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                        print_dfs(&dfs);
                }
                gptr->CatStat |= S_LinkErrNoRepair;
                retval = E_DirHardLinkNesting;
        }

        if (dfs.idptr) {
                free(dfs.idptr);
        }
        if (visited.list) {
                free(visited.list);
        }
        return retval;
}

/* This function traverses the entire catalog btree, and checks all
 * directory inodes and directory hard links found.
 *
 * Returns zero if the check is successful, and non-zero if an error was 
 * encountered during verification.
 */
int dirhardlink_check(SGlobPtr gptr) 
{
        int retval = 0;
        uint16_t selcode;
        uint32_t hint;
        
        CatalogRecord catrec;
        CatalogKey catkey;
        uint16_t recsize;

        PrimeBuckets *inode_view = NULL;
        PrimeBuckets *dirlink_view = NULL;

        /* Check if the volume is HFS+ */
        if (VolumeObjectIsHFSPlus() == false) {
                goto out;
        }

        /* Shortcut out if no directory hard links exists on the disk */
        if ((gptr->dirlink_priv_dir_valence == 0) &&
            (gptr->calculated_dirlinks == 0) &&
            (gptr->calculated_dirinodes == 0)) {
                goto out;
        }

        fsckPrint(gptr->context, hfsMultiLinkDirCheck);

        if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                plog ("\tprivdir_valence=%u, calc_dirlinks=%u, calc_dirinode=%u\n", gptr->dirlink_priv_dir_valence, gptr->calculated_dirlinks, gptr->calculated_dirinodes); 
        }

        /* If lookup of private directory failed and the volume has 
         * some directory hard links and directory inodes, we will need
         * to create the private directory for directory hard links.
         */
        if (gptr->dirlink_priv_dir_id == 0) {
                fsckPrint(gptr->context, E_MissingPrivDir);
                gptr->CatStat |= S_LinkErrNoRepair;
        }

        /* Initialize the two prime number buckets, both buckets keep track
         * of inode ID and corresponding directory hard link ID.  The first 
         * bucket is filled when traversing the directory hard link doubly 
         * linked list from the directory inode, and the second bucket is 
         * filled when btree traversal encounters directory hard links.
         * This method quickly allows us to check if the mapping of all 
         * inodes and directory hard links is same, and no orphans exists.
         */
        inode_view = (PrimeBuckets *)calloc(1, sizeof(PrimeBuckets));
        if (!inode_view) {
                retval = ENOMEM;
                goto out;
        }

        dirlink_view = (PrimeBuckets *)calloc(1, sizeof(PrimeBuckets));
        if (!dirlink_view) {
                retval = ENOMEM;
                goto out;
        }
        
        /* Traverse the catalog btree from the first record */
        selcode = 0x8001;
        retval = GetBTreeRecord(gptr->calculatedCatalogFCB, selcode, &catkey,
                        &catrec, &recsize, &hint);
        if (retval != 0) {
                goto out;
        }

        /* Set code to get the next record */
        selcode = 1;
        do {
                if (catrec.hfsPlusFolder.recordType == kHFSPlusFolderRecord) {
                        /* Check directory hard link private metadata directory */
                        if (catrec.hfsPlusFolder.folderID == gptr->dirlink_priv_dir_id) {
                                dirlink_priv_dir_check(gptr, 
                                        &(catrec.hfsPlusFolder), &(catkey.hfsPlus));
                        }

                        /* Check directory inode */
                        if ((catrec.hfsPlusFolder.flags & kHFSHasLinkChainMask) ||
                            (catkey.hfsPlus.parentID == gptr->dirlink_priv_dir_id)) {
                                retval = inode_check(gptr, inode_view,
                                                &catrec,
                                                &catkey,
                                                true);
                                if (retval) {
                                        /* If the corruption detected requires
                                         * knowledge of all associated directory
                                         * hard links for repair, stop the 
                                         * catalog btree traversal
                                         */
                                        retval = 0;
                                        break;
                                }
                        }
                } else 
                if (catrec.recordType == kHFSPlusFileRecord) {
                        /* Check if the hard link bit is set with correct 
                         * alias type/creator.  If the parent is private 
                         * metadata directory for file hard links, this 
                         * is a hard link inode for an alias, and not 
                         * directory hard link.  Skip this file from our 
                         * check.
                         */
                        if ((catrec.hfsPlusFile.flags & kHFSHasLinkChainMask) &&
                            (catrec.hfsPlusFile.userInfo.fdType == kHFSAliasType) &&
                            (catrec.hfsPlusFile.userInfo.fdCreator == kHFSAliasCreator) &&
                            (catkey.hfsPlus.parentID != gptr->filelink_priv_dir_id)) {
                                dirlink_check(gptr, dirlink_view, 
                                        &(catrec.hfsPlusFile), &(catkey.hfsPlus), true);
                        }
                }

                retval = GetBTreeRecord(gptr->calculatedCatalogFCB, 1, 
                                &catkey, &catrec, &recsize, &hint);
        } while (retval == noErr);

        if (retval == btNotFound) {
                retval = 0;
        } else if (retval != 0) {
                goto out;
        }

        /* Compare the two prime number buckets only the if catalog traversal did 
         * not detect incorrect number of directory hard links corruption.
         */
        if ((gptr->CatStat & S_DirHardLinkChain) == 0) {
                retval = compare_prime_buckets(inode_view, dirlink_view);
                if (retval) {
                        record_link_badchain(gptr, true);
                        if (fsckGetVerbosity(gptr->context) >= kDebugLog) {
                                plog ("\tdirlink prime buckets do not match\n");
                        }
                        retval = 0;
                }
        }

        /* Check if there are any loops in the directory hierarchy */
        retval = check_hierarchy_loops(gptr);
        if (retval) {
                retval = 0;
                goto out;
        }

out:
        if (inode_view) {
                free (inode_view);
        }
        if (dirlink_view) {
                free (dirlink_view);
        }

        return retval;
}