]> git.saurik.com Git - apple/xnu.git/blobdiff - bsd/hfs/hfs_search.c
projects / apple / xnu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xnu-792.6.70.tar.gz
[apple/xnu.git] / bsd / hfs / hfs_search.c
diff --git a/bsd/hfs/hfs_search.c b/bsd/hfs/hfs_search.c
index 979e5241472903ccb8b3ac40b7b22e0fdc725e1f..0d013ced4d78a9662c5912aefedf47599b15b74a 100644 (file)
--- a/bsd/hfs/hfs_search.c
+++ b/bsd/hfs/hfs_search.c
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1997-2004 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_LICENSE_HEADER_START@
  * 
@@ -18,21 +18,14 @@
  * under the License.
  * 
  * @APPLE_LICENSE_HEADER_END@
  * under the License.
  * 
  * @APPLE_LICENSE_HEADER_END@
- */
-/*     @(#)hfs_search.c
- *
- *     (c) 1997-2000   Apple Computer, Inc.  All Rights Reserved
- *     
  *
  *
- *     MODIFICATION HISTORY:
- *      04-May-1999    Don Brady               Split off from hfs_vnodeops.c.
+ *     @(#)hfs_search.c
  */
 
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
  */
 
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
-#include <sys/buf.h>
 #include <sys/proc.h>
 #include <sys/conf.h>
 #include <mach/machine/vm_types.h>
 #include <sys/proc.h>
 #include <sys/conf.h>
 #include <mach/machine/vm_types.h>
@@ -41,33 +34,77 @@
 #include <sys/signalvar.h>
 #include <sys/attr.h>
 #include <sys/utfconv.h>
 #include <sys/signalvar.h>
 #include <sys/attr.h>
 #include <sys/utfconv.h>
+#include <sys/kauth.h>
+#include <sys/vnode_internal.h>
 
 #include "hfs.h"
 #include "hfs_dbg.h"
 
 #include "hfs.h"
 #include "hfs_dbg.h"
+#include "hfs_catalog.h"
+#include "hfs_attrlist.h"
+#include "hfs_endian.h"
+
 #include "hfscommon/headers/FileMgrInternal.h"
 #include "hfscommon/headers/FileMgrInternal.h"
-#include "hfscommon/headers/CatalogPrivate.h"
 #include "hfscommon/headers/HFSUnicodeWrappers.h"
 #include "hfscommon/headers/BTreesPrivate.h"
 #include "hfscommon/headers/BTreeScanner.h"
 #include "hfscommon/headers/HFSUnicodeWrappers.h"
 #include "hfscommon/headers/BTreesPrivate.h"
 #include "hfscommon/headers/BTreeScanner.h"
+#include "hfscommon/headers/CatalogPrivate.h"
 
 
+/* Search criterea. */
+struct directoryInfoSpec
+{
+       u_int32_t   numFiles;
+};
 
 
-static int UnpackSearchAttributeBlock(struct vnode *vp, struct attrlist        *alist, searchinfospec_t *searchInfo, void *attributeBuffer);
+struct fileInfoSpec
+{
+       off_t           dataLogicalLength;
+       off_t           dataPhysicalLength;
+       off_t           resourceLogicalLength;
+       off_t           resourcePhysicalLength;
+};
 
 
-Boolean CheckCriteria( ExtendedVCB *vcb,
-                                               u_long searchBits, 
-                                               struct attrlist *attrList,
-                                               CatalogNodeData *cnp, 
-                                               CatalogKey *key,
-                                               searchinfospec_t *searchInfo1, 
-                                               searchinfospec_t *searchInfo2,
-                                               Boolean lookForDup);
+struct searchinfospec
+{
+       u_char                  name[kHFSPlusMaxFileNameBytes];
+       u_long                  nameLength;
+       char                    attributes;             // see IM:Files 2-100
+       u_long                  nodeID;
+       u_long                  parentDirID;
+       struct timespec         creationDate;           
+       struct timespec         modificationDate;               
+       struct timespec         changeDate;     
+       struct timespec         accessDate;             
+       struct timespec         lastBackupDate; 
+       uint8_t                 finderInfo[32];
+       uid_t                   uid;    
+       gid_t                   gid;
+       mode_t                  mask;
+       struct fileInfoSpec     f;
+       struct directoryInfoSpec d;
+};
+typedef struct searchinfospec searchinfospec_t;
+
+static void ResolveHardlink(ExtendedVCB *vcb, HFSPlusCatalogFile *recp);
+
+
+static int UnpackSearchAttributeBlock(struct hfsmount *hfsmp, struct attrlist *alist,
+               searchinfospec_t *searchInfo, void *attributeBuffer);
+
+static int CheckCriteria(      ExtendedVCB *vcb, 
+                                                       u_long searchBits,
+                                                       struct attrlist *attrList, 
+                                                       CatalogRecord *rec,
+                                                       CatalogKey *key, 
+                                                       searchinfospec_t *searchInfo1,
+                                                       searchinfospec_t *searchInfo2,
+                                                       Boolean lookForDup );
 
 
-static int CheckAccess(CatalogNodeData *cnp, CatalogKey *key, struct proc *p);
+static int CheckAccess(ExtendedVCB *vcb, u_long searchBits, CatalogKey *key, struct proc *p);
 
 
-static int InsertMatch(struct vnode *vp, struct uio *a_uio, CatalogNodeData *cnp,
+static int InsertMatch(struct hfsmount *hfsmp, uio_t a_uio, CatalogRecord *rec,
                        CatalogKey *key, struct attrlist *returnAttrList,
                        void *attributesBuffer, void *variableBuffer,
                        CatalogKey *key, struct attrlist *returnAttrList,
                        void *attributesBuffer, void *variableBuffer,
-                       u_long bufferSize, u_long * nummatches );
+                       u_long * nummatches );
 
 static Boolean CompareRange(u_long val, u_long low, u_long high);
 static Boolean CompareWideRange(u_int64_t val, u_int64_t low, u_int64_t high);
 
 static Boolean CompareRange(u_long val, u_long low, u_long high);
 static Boolean CompareWideRange(u_int64_t val, u_int64_t low, u_int64_t high);
@@ -82,12 +119,16 @@ static Boolean CompareWideRange( u_int64_t val, u_int64_t low, u_int64_t high )
        return( (val >= low) && (val <= high) );
 }
 //#define CompareRange(val, low, high) ((val >= low) && (val <= high))
        return( (val >= low) && (val <= high) );
 }
 //#define CompareRange(val, low, high) ((val >= low) && (val <= high))
-
+                       
+#if 1 // Installer workaround (2940423)
 static Boolean IsTargetName( searchinfospec_t * searchInfoPtr, Boolean isHFSPlus );
 static Boolean IsTargetName( searchinfospec_t * searchInfoPtr, Boolean isHFSPlus );
+#endif // Installer workaround
+
+__private_extern__ int hfs_vnop_search(struct vnop_searchfs_args *ap);
 
 
 /************************************************************************/
 
 
 /************************************************************************/
-/*     Entry for searchfs()                                                                                            */
+/* Entry for searchfs()                                                 */
 /************************************************************************/
 
 #define        errSearchBufferFull     101     /* Internal search errors */
 /************************************************************************/
 
 #define        errSearchBufferFull     101     /* Internal search errors */
@@ -95,103 +136,147 @@ static Boolean IsTargetName( searchinfospec_t * searchInfoPtr, Boolean isHFSPlus
 #
 #% searchfs    vp      L L L
 #
 #
 #% searchfs    vp      L L L
 #
-vop_searchfs {
+vnop_searchfs {
     IN struct vnode *vp;
     IN off_t length;
     IN int flags;
     IN struct vnode *vp;
     IN off_t length;
     IN int flags;
-    IN struct ucred *cred;
+    IN kauth_cred_t cred;
     IN struct proc *p;
 };
 */
 
     IN struct proc *p;
 };
 */
 
+__private_extern__
 int
 int
-hfs_search( ap )
-struct vop_searchfs_args *ap; /*
- struct vnodeop_desc *a_desc;
- struct vnode *a_vp;
- void *a_searchparams1;
- void *a_searchparams2;
- struct attrlist *a_searchattrs;
- u_long a_maxmatches;
- struct timeval *a_timelimit;
- struct attrlist *a_returnattrs;
- u_long *a_nummatches;
- u_long a_scriptcode;
- u_long a_options;
- struct uio *a_uio;
- struct searchstate *a_searchstate;
-*/
+hfs_vnop_search(ap)
+       struct vnop_searchfs_args *ap; /*
+               struct vnodeop_desc *a_desc;
+               struct vnode *a_vp;
+               void *a_searchparams1;
+               void *a_searchparams2;
+               struct attrlist *a_searchattrs;
+               u_long a_maxmatches;
+               struct timeval *a_timelimit;
+               struct attrlist *a_returnattrs;
+               u_long *a_nummatches;
+               u_long a_scriptcode;
+               u_long a_options;
+               struct uio *a_uio;
+               struct searchstate *a_searchstate;
+               vfs_context_t a_context;
+       */
 {
 {
-       FCB*                            catalogFCB;
-       searchinfospec_t        searchInfo1;
-       searchinfospec_t        searchInfo2;
-       void                            *attributesBuffer;
-       void                            *variableBuffer;
-       short                           recordSize;
-       short                           operation;
-       u_long                          fixedBlockSize;
-       u_long                          eachReturnBufferSize;
-       struct proc                     *p = current_proc();
-       CatalogNodeData         myCNodeData;
-       CatalogNodeData *       myCNodeDataPtr;
-       CatalogKey *            myCurrentKeyPtr;
-       CatalogRecord *         myCurrentDataPtr;
-       CatPosition *           myCatPositionPtr;
-       BTScanState             myBTScanState;
-       Boolean                         timerExpired = false;
-       Boolean                         doQuickExit = false;
-       u_long                          lastNodeNum = 0XFFFFFFFF;
-       ExtendedVCB                     *vcb = VTOVCB(ap->a_vp);
-       int                                     err = E_NONE;
-       int                                     isHFSPlus;
+       ExtendedVCB *vcb = VTOVCB(ap->a_vp);
+       struct hfsmount *hfsmp;
+       FCB * catalogFCB;
+       searchinfospec_t searchInfo1;
+       searchinfospec_t searchInfo2;
+       void *attributesBuffer;
+       void *variableBuffer;
+       u_long fixedBlockSize;
+       u_long eachReturnBufferSize;
+       struct proc *p = proc_self();
+       int err = E_NONE;
+       int isHFSPlus;
+       int timerExpired = false;
+       int doQuickExit = false;
+       CatalogKey * myCurrentKeyPtr;
+       CatalogRecord * myCurrentDataPtr;
+       CatPosition * myCatPositionPtr;
+       BTScanState myBTScanState;
+       user_addr_t user_start = 0;
+       user_size_t user_len = 0;
+       int32_t searchTime;
+       int lockflags;
 
        /* XXX Parameter check a_searchattrs? */
 
        *(ap->a_nummatches) = 0;
 
 
        /* XXX Parameter check a_searchattrs? */
 
        *(ap->a_nummatches) = 0;
 
-       if ( ap->a_options & ~SRCHFS_VALIDOPTIONSMASK )
-               return( EINVAL );
+       if (ap->a_options & ~SRCHFS_VALIDOPTIONSMASK)
+               return (EINVAL);
+
+       /* SRCHFS_SKIPLINKS requires root access.
+        * This option cannot be used with either
+        * the ATTR_CMN_NAME or ATTR_CMN_PAROBJID
+        * attributes.
+        */
+       if (ap->a_options & SRCHFS_SKIPLINKS) {
+               attrgroup_t attrs;
+
+               attrs = ap->a_searchattrs->commonattr | ap->a_returnattrs->commonattr;
+               if (attrs & (ATTR_CMN_NAME | ATTR_CMN_PAROBJID))
+                       return (EINVAL);
+               if ((err = suser(kauth_cred_get(), 0)))
+                       return (err);
+       }
 
 
-       if (ap->a_uio->uio_resid <= 0)
+       if (uio_resid(ap->a_uio) <= 0)
                return (EINVAL);
 
        isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord);
                return (EINVAL);
 
        isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord);
+       hfsmp = VTOHFS(ap->a_vp);
+       
+       searchTime = kMaxMicroSecsInKernel;
+       if (ap->a_timelimit->tv_sec == 0 &&
+           ap->a_timelimit->tv_usec > 0 &&
+           ap->a_timelimit->tv_usec < kMaxMicroSecsInKernel) {
+               searchTime = ap->a_timelimit->tv_usec;
+       }
 
        /* UnPack the search boundries, searchInfo1, searchInfo2 */
 
        /* UnPack the search boundries, searchInfo1, searchInfo2 */
-       err = UnpackSearchAttributeBlock( ap->a_vp, ap->a_searchattrs, &searchInfo1, ap->a_searchparams1 );
+       err = UnpackSearchAttributeBlock(hfsmp, ap->a_searchattrs,
+                               &searchInfo1, ap->a_searchparams1);
        if (err) return err;
        if (err) return err;
-       err = UnpackSearchAttributeBlock( ap->a_vp, ap->a_searchattrs, &searchInfo2, ap->a_searchparams2 );
+       err = UnpackSearchAttributeBlock(hfsmp, ap->a_searchattrs,
+                               &searchInfo2, ap->a_searchparams2);
        if (err) return err;
 
        if (err) return err;
 
-       fixedBlockSize = sizeof(u_long) + AttributeBlockSize( ap->a_returnattrs );      /* u_long for length longword */
+    fixedBlockSize = sizeof(uint32_t) + hfs_attrblksize(ap->a_returnattrs);    /* uint32_t for length word */
+
        eachReturnBufferSize = fixedBlockSize;
        eachReturnBufferSize = fixedBlockSize;
-       
+
        if ( ap->a_returnattrs->commonattr & ATTR_CMN_NAME )    /* XXX should be more robust! */
                eachReturnBufferSize += kHFSPlusMaxFileNameBytes + 1;
 
        MALLOC( attributesBuffer, void *, eachReturnBufferSize, M_TEMP, M_WAITOK );
        variableBuffer = (void*)((char*) attributesBuffer + fixedBlockSize);
 
        if ( ap->a_returnattrs->commonattr & ATTR_CMN_NAME )    /* XXX should be more robust! */
                eachReturnBufferSize += kHFSPlusMaxFileNameBytes + 1;
 
        MALLOC( attributesBuffer, void *, eachReturnBufferSize, M_TEMP, M_WAITOK );
        variableBuffer = (void*)((char*) attributesBuffer + fixedBlockSize);
 
-       /* Lock catalog b-tree */
-       err = hfs_metafilelocking( VTOHFS(ap->a_vp), kHFSCatalogFileID, LK_SHARED, p );
-       if ( err != E_NONE ) {
-               goto ExitThisRoutine;
-       };
+       // XXXdbg - have to lock the user's buffer so we don't fault
+       // while holding the shared catalog file lock.  see the comment
+       // in hfs_readdir() for more details.
+       //
+       if (hfsmp->jnl && uio_isuserspace(ap->a_uio)) {
+               user_start = uio_curriovbase(ap->a_uio);
+               user_len = uio_curriovlen(ap->a_uio);
+
+               if ((err = vslock(user_start, user_len)) != 0) {
+                       user_start = 0;
+                       goto ExitThisRoutine;
+               }
+       }
 
 
-       catalogFCB = VTOFCB( vcb->catalogRefNum );
+       lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
+
+       catalogFCB = GetFileControlBlock(vcb->catalogRefNum);
        myCurrentKeyPtr = NULL;
        myCurrentDataPtr = NULL;
        myCatPositionPtr = (CatPosition *)ap->a_searchstate;
 
        if (ap->a_options & SRCHFS_START) {
                /* Starting a new search. */
        myCurrentKeyPtr = NULL;
        myCurrentDataPtr = NULL;
        myCatPositionPtr = (CatPosition *)ap->a_searchstate;
 
        if (ap->a_options & SRCHFS_START) {
                /* Starting a new search. */
-               /* make sure our meta data is synced up */
-               err = VOP_FSYNC(vcb->catalogRefNum, NOCRED, MNT_WAIT, p);
+               /* Make sure the on-disk Catalog file is current */
+               (void) hfs_fsync(vcb->catalogRefNum, MNT_WAIT, 0, p);
+               if (hfsmp->jnl) {
+                   hfs_systemfile_unlock(hfsmp, lockflags);
+                   journal_flush(hfsmp->jnl);
+                   lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
+               }
+
                ap->a_options &= ~SRCHFS_START;
                bzero( (caddr_t)myCatPositionPtr, sizeof( *myCatPositionPtr ) );
                err = BTScanInitialize(catalogFCB, 0, 0, 0, kCatSearchBufferSize, &myBTScanState);
                ap->a_options &= ~SRCHFS_START;
                bzero( (caddr_t)myCatPositionPtr, sizeof( *myCatPositionPtr ) );
                err = BTScanInitialize(catalogFCB, 0, 0, 0, kCatSearchBufferSize, &myBTScanState);
-
-#if 1 // Installer workaround
+               
+#if 1 // Installer workaround (2940423)
                // hack to get around installer problems when the installer expects search results 
                // to be in key order.  At this point the problem appears to be limited to 
                // searches for "Library".  The idea here is to go get the "Library" at root
                // hack to get around installer problems when the installer expects search results 
                // to be in key order.  At this point the problem appears to be limited to 
                // searches for "Library".  The idea here is to go get the "Library" at root
@@ -216,29 +301,22 @@ struct vop_searchfs_args *ap; /*
                        btrec.itemCount = 1;
                        btrec.itemSize = sizeof( rec );
 
                        btrec.itemCount = 1;
                        btrec.itemSize = sizeof( rec );
 
-                       result = BTSearchRecord( catalogFCB, &iterator, kInvalidMRUCacheKey, 
-                                                                        &btrec, &reclen, &iterator );
+                       result = BTSearchRecord( catalogFCB, &iterator, &btrec, &reclen, &iterator );
                        if ( result == E_NONE ) {
                        if ( result == E_NONE ) {
-                               if ( isHFSPlus ) {
-                                       // HFSPlus vols have CatalogRecords that map exactly to CatalogNodeData so there is no need 
-                                       // to copy.
-                                       myCNodeDataPtr = (CatalogNodeData *) &rec;
-                               } else {
-                                       CopyCatalogNodeData( vcb, &rec, &myCNodeData );
-                                       myCNodeDataPtr = &myCNodeData;
-                               }
-                                       
-                               if (CheckCriteria(vcb, ap->a_options, ap->a_searchattrs, myCNodeDataPtr,
+                               // need to unlock since CheckAccess assumes no lock held
+                               hfs_systemfile_unlock(hfsmp, lockflags);
+                               if (CheckCriteria(vcb, ap->a_options, ap->a_searchattrs, &rec,
                                                                  keyp, &searchInfo1, &searchInfo2, false) &&
                                                                  keyp, &searchInfo1, &searchInfo2, false) &&
-                                       CheckAccess(myCNodeDataPtr, keyp, ap->a_uio->uio_procp)) {
+                                       CheckAccess(vcb, ap->a_options, keyp, p)) {
                
                
-                                       result = InsertMatch(ap->a_vp, ap->a_uio, myCNodeDataPtr, 
+                                       result = InsertMatch(hfsmp, ap->a_uio, &rec, 
                                                                          keyp, ap->a_returnattrs,
                                                                          attributesBuffer, variableBuffer,
                                                                          keyp, ap->a_returnattrs,
                                                                          attributesBuffer, variableBuffer,
-                                                                         eachReturnBufferSize, ap->a_nummatches);
+                                                                         ap->a_nummatches);
                                        if (result == E_NONE && *(ap->a_nummatches) >= ap->a_maxmatches)
                                                doQuickExit = true;
                                }
                                        if (result == E_NONE && *(ap->a_nummatches) >= ap->a_maxmatches)
                                                doQuickExit = true;
                                }
+                               lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
                        }
                }
 #endif // Installer workaround
                        }
                }
 #endif // Installer workaround
@@ -249,22 +327,22 @@ struct vop_searchfs_args *ap; /*
                                        myCatPositionPtr->recordsFound,
                                        kCatSearchBufferSize, 
                                        &myBTScanState);
                                        myCatPositionPtr->recordsFound,
                                        kCatSearchBufferSize, 
                                        &myBTScanState);
-#if 0
                /* Make sure Catalog hasn't changed. */
                if (err == 0
                &&  myCatPositionPtr->writeCount != myBTScanState.btcb->writeCount) {
                        myCatPositionPtr->writeCount = myBTScanState.btcb->writeCount;
                        err = EBUSY; /* catChangedErr */
                }
                /* Make sure Catalog hasn't changed. */
                if (err == 0
                &&  myCatPositionPtr->writeCount != myBTScanState.btcb->writeCount) {
                        myCatPositionPtr->writeCount = myBTScanState.btcb->writeCount;
                        err = EBUSY; /* catChangedErr */
                }
-#endif
        }
        }
+       hfs_systemfile_unlock(hfsmp, lockflags);
 
 
-       /* Unlock catalog b-tree */
-       (void) hfs_metafilelocking(VTOHFS(ap->a_vp), kHFSCatalogFileID, LK_RELEASE, p);
        if (err)
                goto ExitThisRoutine;
        if (err)
                goto ExitThisRoutine;
+#if 1 // Installer workaround (2940423)
        if ( doQuickExit )
                goto QuickExit;
        if ( doQuickExit )
                goto QuickExit;
+#endif // Installer workaround
+
        /*
         * Check all the catalog btree records...
         *   return the attributes for matching items
        /*
         * Check all the catalog btree records...
         *   return the attributes for matching items
@@ -279,23 +357,18 @@ struct vop_searchfs_args *ap; /*
                if (err)
                        break;
 
                if (err)
                        break;
 
-               if ( isHFSPlus ) {
-                       // HFSPlus vols have CatalogRecords that map exactly to CatalogNodeData so there is no need 
-                       // to copy.
-                       myCNodeDataPtr = (CatalogNodeData *) myCurrentDataPtr;
-               } else {
-                       CopyCatalogNodeData( vcb, myCurrentDataPtr, &myCNodeData );
-                       myCNodeDataPtr = &myCNodeData;
+               /* Resolve any hardlinks */
+               if (isHFSPlus && (ap->a_options & SRCHFS_SKIPLINKS) == 0) {
+                       lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
+                       ResolveHardlink(vcb, (HFSPlusCatalogFile *) myCurrentDataPtr);
+                       hfs_systemfile_unlock(hfsmp, lockflags);
                }
                }
-                       
-               if (CheckCriteria(vcb, ap->a_options, ap->a_searchattrs, myCNodeDataPtr,
-                                 myCurrentKeyPtr, &searchInfo1, &searchInfo2, true) &&
-                   CheckAccess(myCNodeDataPtr, myCurrentKeyPtr, ap->a_uio->uio_procp)) {
-
-                       err = InsertMatch(ap->a_vp, ap->a_uio, myCNodeDataPtr, 
-                                         myCurrentKeyPtr, ap->a_returnattrs,
-                                         attributesBuffer, variableBuffer,
-                                         eachReturnBufferSize, ap->a_nummatches);
+               if (CheckCriteria( vcb, ap->a_options, ap->a_searchattrs, myCurrentDataPtr,
+                               myCurrentKeyPtr, &searchInfo1, &searchInfo2, true )
+               &&  CheckAccess(vcb, ap->a_options, myCurrentKeyPtr, p)) {
+                       err = InsertMatch(hfsmp, ap->a_uio, myCurrentDataPtr, 
+                                       myCurrentKeyPtr, ap->a_returnattrs,
+                                       attributesBuffer, variableBuffer, ap->a_nummatches);
                        if (err) {
                                /*
                                 * The last match didn't fit so come back
                        if (err) {
                                /*
                                 * The last match didn't fit so come back
@@ -305,6 +378,7 @@ struct vop_searchfs_args *ap; /*
                                --myBTScanState.recordNum;
                                break;
                        }
                                --myBTScanState.recordNum;
                                break;
                        }
+
                        if (*(ap->a_nummatches) >= ap->a_maxmatches)
                                break;
                }
                        if (*(ap->a_nummatches) >= ap->a_maxmatches)
                                break;
                }
@@ -314,21 +388,22 @@ struct vop_searchfs_args *ap; /*
                 * The idea here is to throttle the amount of time we
                 * spend in the kernel.
                 */
                 * The idea here is to throttle the amount of time we
                 * spend in the kernel.
                 */
-               myCurrentTime = time;
+               microuptime(&myCurrentTime);
                timersub(&myCurrentTime, &myBTScanState.startTime, &myElapsedTime);
                /* Note: assumes kMaxMicroSecsInKernel is less than 1,000,000 */
                if (myElapsedTime.tv_sec > 0
                timersub(&myCurrentTime, &myBTScanState.startTime, &myElapsedTime);
                /* Note: assumes kMaxMicroSecsInKernel is less than 1,000,000 */
                if (myElapsedTime.tv_sec > 0
-               ||  myElapsedTime.tv_usec >= kMaxMicroSecsInKernel) {
+               ||  myElapsedTime.tv_usec >= searchTime) {
                        timerExpired = true;
                }
        }
                        timerExpired = true;
                }
        }
+
 QuickExit:
        /* Update catalog position */
        myCatPositionPtr->writeCount = myBTScanState.btcb->writeCount;
 
 QuickExit:
        /* Update catalog position */
        myCatPositionPtr->writeCount = myBTScanState.btcb->writeCount;
 
-       BTScanTerminate(&myBTScanState, &myCatPositionPtr->nextNode,
-                                       &myCatPositionPtr->nextRecord, 
-                                       &myCatPositionPtr->recordsFound);
+       BTScanTerminate(&myBTScanState, &myCatPositionPtr->nextNode, 
+                       &myCatPositionPtr->nextRecord, 
+                       &myCatPositionPtr->recordsFound);
 
        if ( err == E_NONE ) {
                err = EAGAIN;   /* signal to the user to call searchfs again */
 
        if ( err == E_NONE ) {
                err = EAGAIN;   /* signal to the user to call searchfs again */
@@ -344,15 +419,37 @@ QuickExit:
        }
 
 ExitThisRoutine:
        }
 
 ExitThisRoutine:
-        FREE( attributesBuffer, M_TEMP );
+    FREE( attributesBuffer, M_TEMP );
+
+       if (hfsmp->jnl && user_start) {
+               vsunlock(user_start, user_len, TRUE);
+       }
 
        return (MacToVFSError(err));
 }
 
 
 
        return (MacToVFSError(err));
 }
 
 
+static void
+ResolveHardlink(ExtendedVCB *vcb, HFSPlusCatalogFile *recp)
+{
+       if ((recp->recordType == kHFSPlusFileRecord)
+       &&  (SWAP_BE32(recp->userInfo.fdType) == kHardLinkFileType)
+       &&  (SWAP_BE32(recp->userInfo.fdCreator) == kHFSPlusCreator)
+       &&  ((to_bsd_time(recp->createDate) == vcb->vcbCrDate) ||
+            (to_bsd_time(recp->createDate) == VCBTOHFS(vcb)->hfs_metadata_createdate))) {
+               cnid_t saved_cnid;
+
+               /* Export link's cnid (a unique value) instead of inode's cnid */
+               saved_cnid = recp->fileID;
+               (void) resolvelink(VCBTOHFS(vcb), recp->bsdInfo.special.iNodeNum, recp);
+               recp->fileID = saved_cnid;
+       }
+}
+
+
 static Boolean
 CompareMasked(const UInt32 *thisValue, const UInt32 *compareData,
 static Boolean
 CompareMasked(const UInt32 *thisValue, const UInt32 *compareData,
-                                                        const UInt32 *compareMask, UInt32 count)
+               const UInt32 *compareMask, UInt32 count)
 {
        Boolean matched;
        UInt32  i;
 {
        Boolean matched;
        UInt32  i;
@@ -411,40 +508,174 @@ ComparePartialPascalName ( register ConstStr31Param str, register ConstStr31Para
 }
 
 
 }
 
 
+//
+// Determine if a name is "inappropriate" where the definition
+// of "inappropriate" is up to higher level execs.  Currently
+// that's limited to /System.
+//
+static int
+is_inappropriate_name(char *name, int len)
+{
+    const char *bad_names[] = { "System" };
+    int   bad_len[]   = {        6 };
+    int  i;
+    
+    for(i=0; i < (int) (sizeof(bad_names) / sizeof(bad_names[0])); i++) {
+       if (len == bad_len[i] && strcmp(name, bad_names[i]) == 0) {
+           return 1;
+       }
+    }
+
+    // if we get here, no name matched
+    return 0;
+}
+
+
+
 /*
  * Check to see if caller has access rights to this item
  */
 /*
  * Check to see if caller has access rights to this item
  */
+
 static int
 static int
-CheckAccess(CatalogNodeData *cnp, CatalogKey *key, struct proc *p)
+CheckAccess(ExtendedVCB *theVCBPtr, u_long searchBits, CatalogKey *theKeyPtr, struct proc *theProcPtr)
 {
 {
-       return (1);
+       Boolean                         isHFSPlus;
+       int                                     myErr;
+       int                                     myResult;       
+       HFSCatalogNodeID        myNodeID;
+       hfsmount_t *            hfsmp;
+       struct FndrDirInfo      *finfop;
+       struct vnode *          vp = NULL;
+       struct vfs_context      my_context;
+
+       myResult = 0;   /* default to "no access" */
+       my_context.vc_proc = theProcPtr;
+       my_context.vc_ucred = kauth_cred_get();
+               
+       if (!proc_suser(theProcPtr)) {
+               myResult = 1;   /* allow access */
+               goto ExitThisRoutine; /* root always has access */
+       }
+
+       hfsmp = VCBTOHFS( theVCBPtr );
+       isHFSPlus = ( theVCBPtr->vcbSigWord == kHFSPlusSigWord );
+       if ( isHFSPlus )
+               myNodeID = theKeyPtr->hfsPlus.parentID;
+       else
+               myNodeID = theKeyPtr->hfs.parentID;
+       
+       while ( myNodeID >= kRootDirID ) {
+               cnode_t *       cp;
+               
+               /* now go get catalog data for this directory */
+               myErr = hfs_vget(hfsmp, myNodeID, &vp, 0);
+               if ( myErr ) {
+                       goto ExitThisRoutine;   /* no access */
+               }
+
+               cp = VTOC(vp);
+               finfop = (struct FndrDirInfo *)&cp->c_attr.ca_finderinfo[0];
+
+               if ( searchBits & SRCHFS_SKIPPACKAGES ) {
+                   if (   (SWAP_BE16(finfop->frFlags) & kHasBundle)
+                       || (cp->c_desc.cd_nameptr != NULL
+                           && is_package_name(cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen)) ) {
+                               myResult = 0;
+                               goto ExitThisRoutine;
+                   }
+               }
+
+               if ( searchBits & SRCHFS_SKIPINAPPROPRIATE ) {
+                   if ( cp->c_parentcnid == kRootDirID && cp->c_desc.cd_nameptr != NULL &&
+                            is_inappropriate_name(cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen) ) {
+                               myResult = 0;
+                               goto ExitThisRoutine;
+                   }
+               }
+
+               if ( (searchBits & SRCHFS_SKIPINVISIBLE) && 
+                        (SWAP_BE16(finfop->frFlags) & kIsInvisible) ) {
+                   myResult = 0;
+                   goto ExitThisRoutine;
+               }
+
+               myNodeID = cp->c_parentcnid;    /* move up the hierarchy */
+               hfs_unlock(VTOC(vp));
+               if (vp->v_type == VDIR) {
+                   myErr = vnode_authorize(vp, NULL, (KAUTH_VNODE_SEARCH | KAUTH_VNODE_LIST_DIRECTORY), &my_context);
+               } else {
+                   myErr = vnode_authorize(vp, NULL, (KAUTH_VNODE_SEARCH), &my_context);
+               }
+               vnode_put(vp);
+               vp = NULL;
+               if ( myErr ) {
+                       goto ExitThisRoutine;   /* no access */
+               }
+       }
+       myResult = 1;   /* allow access */
+
+ExitThisRoutine:
+       if ( vp != NULL ) {
+               hfs_unlock(VTOC(vp));
+               vnode_put(vp);
+       }
+       return ( myResult );
+       
 }
 
 }
 
-Boolean
-CheckCriteria( ExtendedVCB *vcb,
-                               u_long searchBits, 
-                               struct attrlist *attrList,
-                               CatalogNodeData *cnp, 
+static int
+CheckCriteria( ExtendedVCB *vcb, 
+                               u_long searchBits,
+                               struct attrlist *attrList, 
+                               CatalogRecord *rec, 
                                CatalogKey *key,
                                CatalogKey *key,
-                               searchinfospec_t *searchInfo1, 
+                               searchinfospec_t  *searchInfo1, 
                                searchinfospec_t *searchInfo2,
                                Boolean lookForDup )
 {
        Boolean matched, atleastone;
        Boolean isHFSPlus;
        attrgroup_t searchAttributes;
                                searchinfospec_t *searchInfo2,
                                Boolean lookForDup )
 {
        Boolean matched, atleastone;
        Boolean isHFSPlus;
        attrgroup_t searchAttributes;
+       struct cat_attr c_attr;
+       struct cat_fork datafork;
+       struct cat_fork rsrcfork;
        
        
+       bzero(&c_attr, sizeof(c_attr));
        isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord);
 
        isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord);
 
-       switch (cnp->cnd_type) {
-       case kCatalogFolderNode:
+       switch (rec->recordType) {
+       case kHFSFolderRecord:
+       case kHFSPlusFolderRecord:
                if ( (searchBits & SRCHFS_MATCHDIRS) == 0 ) {   /* If we are NOT searching folders */
                        matched = false;
                        goto TestDone;
                }
                break;
                        
                if ( (searchBits & SRCHFS_MATCHDIRS) == 0 ) {   /* If we are NOT searching folders */
                        matched = false;
                        goto TestDone;
                }
                break;
                        
-       case kCatalogFileNode:
+       case kHFSFileRecord:
+               if ( (searchBits & SRCHFS_MATCHFILES) == 0 ) {  /* If we are NOT searching files */
+                       matched = false;
+                       goto TestDone;
+               }
+               break;
+
+       case kHFSPlusFileRecord:
+               /* Check if hardlink links should be skipped. */
+               if (searchBits & SRCHFS_SKIPLINKS) {
+                       cnid_t parid = key->hfsPlus.parentID;
+                       HFSPlusCatalogFile *filep = (HFSPlusCatalogFile *)rec;
+
+                       if ((SWAP_BE32(filep->userInfo.fdType) == kHardLinkFileType) &&
+                           (SWAP_BE32(filep->userInfo.fdCreator) == kHFSPlusCreator)) {
+                               return (false); /* skip over link records */
+                       } else if ((parid == VCBTOHFS(vcb)->hfs_privdir_desc.cd_cnid) &&
+                                  (filep->bsdInfo.special.linkCount == 0)) {
+                               return (false); /* skip over unlinked files */
+                       }
+               } else if (key->hfsPlus.parentID == VCBTOHFS(vcb)->hfs_privdir_desc.cd_cnid) {
+                       return (false); /* skip over private files */
+               }
+
                if ( (searchBits & SRCHFS_MATCHFILES) == 0 ) {  /* If we are NOT searching files */
                        matched = false;
                        goto TestDone;
                if ( (searchBits & SRCHFS_MATCHFILES) == 0 ) {  /* If we are NOT searching files */
                        matched = false;
                        goto TestDone;
@@ -483,7 +714,7 @@ CheckCriteria(      ExtendedVCB *vcb,
                                matched = (FastRelString(key->hfs.nodeName, (u_char*)searchInfo1->name) == 0);
                }
 
                                matched = (FastRelString(key->hfs.nodeName, (u_char*)searchInfo1->name) == 0);
                }
 
-#if 1 // Installer workaround
+#if 1 // Installer workaround (2940423)
                if ( lookForDup ) {
                        HFSCatalogNodeID parentID;
                        if (isHFSPlus)
                if ( lookForDup ) {
                        HFSCatalogNodeID parentID;
                        if (isHFSPlus)
@@ -496,15 +727,55 @@ CheckCriteria(    ExtendedVCB *vcb,
                                matched = false;
                }
 #endif // Installer workaround
                                matched = false;
                }
 #endif // Installer workaround
-               
+
                if ( matched == false || (searchBits & ~SRCHFS_MATCHPARTIALNAMES) == 0 )
                        goto TestDone;  /* no match, or nothing more to compare */
 
                atleastone = true;
        }
                if ( matched == false || (searchBits & ~SRCHFS_MATCHPARTIALNAMES) == 0 )
                        goto TestDone;  /* no match, or nothing more to compare */
 
                atleastone = true;
        }
+
+       /* Convert catalog record into cat_attr format. */
+       cat_convertattr(VCBTOHFS(vcb), rec, &c_attr, &datafork, &rsrcfork);
+       
+       if (searchBits & SRCHFS_SKIPINVISIBLE) {
+           int flags;
+           
+           switch (rec->recordType) {
+               case kHFSFolderRecord:
+               case kHFSPlusFolderRecord: {
+                   struct FndrDirInfo *finder_info;
+                   
+                   finder_info = (struct FndrDirInfo *)&c_attr.ca_finderinfo[0];
+                   flags = SWAP_BE16(finder_info->frFlags);
+                   break;
+               }
+                       
+               case kHFSFileRecord:
+               case kHFSPlusFileRecord: {
+                   struct FndrFileInfo *finder_info;
+                   
+                   finder_info = (struct FndrFileInfo *)&c_attr.ca_finderinfo[0];
+                   flags = SWAP_BE16(finder_info->fdFlags);
+                   break;
+               }
+
+               default: {
+                   flags = kIsInvisible;
+                   break;
+               }
+           }
+                   
+           if (flags & kIsInvisible) {
+               matched = false;
+               goto TestDone;
+           }
+       }
        
        
+                   
+
        /* Now that we have a record worth searching, see if it matches the search attributes */
        /* Now that we have a record worth searching, see if it matches the search attributes */
-       if (cnp->cnd_type == kCatalogFileNode) {
+       if (rec->recordType == kHFSFileRecord ||
+           rec->recordType == kHFSPlusFileRecord) {
                if ((attrList->fileattr & ~ATTR_FILE_VALIDMASK) != 0) { /* attr we do know about  */
                        matched = false;
                        goto TestDone;
                if ((attrList->fileattr & ~ATTR_FILE_VALIDMASK) != 0) { /* attr we do know about  */
                        matched = false;
                        goto TestDone;
@@ -515,7 +786,7 @@ CheckCriteria(      ExtendedVCB *vcb,
                /* File logical length (data fork) */
                if ( searchAttributes & ATTR_FILE_DATALENGTH ) {
                        matched = CompareWideRange(
                /* File logical length (data fork) */
                if ( searchAttributes & ATTR_FILE_DATALENGTH ) {
                        matched = CompareWideRange(
-                           cnp->cnd_datafork.logicalSize,
+                           datafork.cf_size,
                            searchInfo1->f.dataLogicalLength,
                            searchInfo2->f.dataLogicalLength);
                        if (matched == false) goto TestDone;
                            searchInfo1->f.dataLogicalLength,
                            searchInfo2->f.dataLogicalLength);
                        if (matched == false) goto TestDone;
@@ -525,7 +796,7 @@ CheckCriteria(      ExtendedVCB *vcb,
                /* File physical length (data fork) */
                if ( searchAttributes & ATTR_FILE_DATAALLOCSIZE ) {
                        matched = CompareWideRange(
                /* File physical length (data fork) */
                if ( searchAttributes & ATTR_FILE_DATAALLOCSIZE ) {
                        matched = CompareWideRange(
-                           cnp->cnd_datafork.totalBlocks * vcb->blockSize,
+                           (u_int64_t)datafork.cf_blocks * (u_int64_t)vcb->blockSize,
                            searchInfo1->f.dataPhysicalLength,
                            searchInfo2->f.dataPhysicalLength);
                        if (matched == false) goto TestDone;
                            searchInfo1->f.dataPhysicalLength,
                            searchInfo2->f.dataPhysicalLength);
                        if (matched == false) goto TestDone;
@@ -535,7 +806,7 @@ CheckCriteria(      ExtendedVCB *vcb,
                /* File logical length (resource fork) */
                if ( searchAttributes & ATTR_FILE_RSRCLENGTH ) {
                        matched = CompareWideRange(
                /* File logical length (resource fork) */
                if ( searchAttributes & ATTR_FILE_RSRCLENGTH ) {
                        matched = CompareWideRange(
-                           cnp->cnd_rsrcfork.logicalSize,
+                           rsrcfork.cf_size,
                            searchInfo1->f.resourceLogicalLength,
                            searchInfo2->f.resourceLogicalLength);
                        if (matched == false) goto TestDone;
                            searchInfo1->f.resourceLogicalLength,
                            searchInfo2->f.resourceLogicalLength);
                        if (matched == false) goto TestDone;
@@ -545,7 +816,7 @@ CheckCriteria(      ExtendedVCB *vcb,
                /* File physical length (resource fork) */
                if ( searchAttributes & ATTR_FILE_RSRCALLOCSIZE ) {
                        matched = CompareWideRange(
                /* File physical length (resource fork) */
                if ( searchAttributes & ATTR_FILE_RSRCALLOCSIZE ) {
                        matched = CompareWideRange(
-                           cnp->cnd_rsrcfork.totalBlocks * vcb->blockSize,
+                           (u_int64_t)rsrcfork.cf_blocks * (u_int64_t)vcb->blockSize,
                            searchInfo1->f.resourcePhysicalLength,
                            searchInfo2->f.resourcePhysicalLength);
                        if (matched == false) goto TestDone;
                            searchInfo1->f.resourcePhysicalLength,
                            searchInfo2->f.resourcePhysicalLength);
                        if (matched == false) goto TestDone;
@@ -553,13 +824,14 @@ CheckCriteria(    ExtendedVCB *vcb,
                        }
                }
                else {
                        }
                }
                else {
-                       atleastone = true;              /* to match SRCHFS_MATCHDIRS */
+                       atleastone = true;      /* to match SRCHFS_MATCHFILES */
                }
        }
        /*
         * Check the directory attributes
         */
                }
        }
        /*
         * Check the directory attributes
         */
-       else if (cnp->cnd_type == kCatalogFolderNode) {
+       else if (rec->recordType == kHFSFolderRecord ||
+                rec->recordType == kHFSPlusFolderRecord) {
                if ((attrList->dirattr & ~ATTR_DIR_VALIDMASK) != 0) {   /* attr we do know about  */
                        matched = false;
                        goto TestDone;
                if ((attrList->dirattr & ~ATTR_DIR_VALIDMASK) != 0) {   /* attr we do know about  */
                        matched = false;
                        goto TestDone;
@@ -569,7 +841,9 @@ CheckCriteria(      ExtendedVCB *vcb,
                
                /* Directory valence */
                if ( searchAttributes & ATTR_DIR_ENTRYCOUNT ) {
                
                /* Directory valence */
                if ( searchAttributes & ATTR_DIR_ENTRYCOUNT ) {
-                       matched = CompareRange(cnp->cnd_valence, searchInfo1->d.numFiles, searchInfo2->d.numFiles );
+                       matched = CompareRange(c_attr.ca_entries,
+                                       searchInfo1->d.numFiles,
+                                       searchInfo2->d.numFiles );
                        if (matched == false) goto TestDone;
                                atleastone = true;
                        }
                        if (matched == false) goto TestDone;
                                atleastone = true;
                        }
@@ -584,10 +858,11 @@ CheckCriteria(    ExtendedVCB *vcb,
         */
        searchAttributes = attrList->commonattr;
        if ( (searchAttributes & ATTR_CMN_VALIDMASK) != 0 ) {
         */
        searchAttributes = attrList->commonattr;
        if ( (searchAttributes & ATTR_CMN_VALIDMASK) != 0 ) {
-
                /* node ID */
                if ( searchAttributes & ATTR_CMN_OBJID ) {
                /* node ID */
                if ( searchAttributes & ATTR_CMN_OBJID ) {
-                       matched = CompareRange( cnp->cnd_nodeID, searchInfo1->nodeID, searchInfo2->nodeID );
+                       matched = CompareRange(c_attr.ca_fileid,
+                                       searchInfo1->nodeID,
+                                       searchInfo2->nodeID );
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
@@ -601,7 +876,8 @@ CheckCriteria(      ExtendedVCB *vcb,
                        else
                                parentID = key->hfs.parentID;
                                
                        else
                                parentID = key->hfs.parentID;
                                
-                       matched = CompareRange( parentID, searchInfo1->parentDirID, searchInfo2->parentDirID );
+                       matched = CompareRange(parentID, searchInfo1->parentDirID,
+                                       searchInfo2->parentDirID );
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
@@ -609,72 +885,88 @@ CheckCriteria(    ExtendedVCB *vcb,
                /* Finder Info & Extended Finder Info where extFinderInfo is last 32 bytes */
                if ( searchAttributes & ATTR_CMN_FNDRINFO ) {
                        UInt32 *thisValue;
                /* Finder Info & Extended Finder Info where extFinderInfo is last 32 bytes */
                if ( searchAttributes & ATTR_CMN_FNDRINFO ) {
                        UInt32 *thisValue;
-                       thisValue = (UInt32 *) &cnp->cnd_finderInfo;
+                       thisValue = (UInt32 *) &c_attr.ca_finderinfo;
 
                        /* 
                         * Note: ioFlFndrInfo and ioDrUsrWds have the same offset in search info, so
                         * no need to test the object type here.
                         */
 
                        /* 
                         * Note: ioFlFndrInfo and ioDrUsrWds have the same offset in search info, so
                         * no need to test the object type here.
                         */
-                       matched = CompareMasked( thisValue, (UInt32 *) &searchInfo1->finderInfo,
-                               (UInt32 *) &searchInfo2->finderInfo, 8 ); /* 8 * UInt32 */
+                       matched = CompareMasked(thisValue,
+                                       (UInt32 *)&searchInfo1->finderInfo,
+                                       (UInt32 *) &searchInfo2->finderInfo, 8);
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
 
                /* Create date */
                if ( searchAttributes & ATTR_CMN_CRTIME ) {
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
 
                /* Create date */
                if ( searchAttributes & ATTR_CMN_CRTIME ) {
-                       matched = CompareRange(to_bsd_time(cnp->cnd_createDate),
-                           searchInfo1->creationDate.tv_sec,  searchInfo2->creationDate.tv_sec );
+                       matched = CompareRange(c_attr.ca_itime,
+                                       searchInfo1->creationDate.tv_sec,
+                                       searchInfo2->creationDate.tv_sec);
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
        
                /* Mod date */
                if ( searchAttributes & ATTR_CMN_MODTIME ) {
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
        
                /* Mod date */
                if ( searchAttributes & ATTR_CMN_MODTIME ) {
-                       matched = CompareRange(to_bsd_time(cnp->cnd_contentModDate),
-                           searchInfo1->modificationDate.tv_sec, searchInfo2->modificationDate.tv_sec );
+                       matched = CompareRange(c_attr.ca_mtime,
+                                       searchInfo1->modificationDate.tv_sec,
+                                       searchInfo2->modificationDate.tv_sec);
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
        
                /* Change Time */
                if ( searchAttributes & ATTR_CMN_CHGTIME ) {
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
        
                /* Change Time */
                if ( searchAttributes & ATTR_CMN_CHGTIME ) {
-                       matched = CompareRange(to_bsd_time(cnp->cnd_attributeModDate),
-                           searchInfo1->changeDate.tv_sec, searchInfo2->changeDate.tv_sec );
+                       matched = CompareRange(c_attr.ca_ctime,
+                                       searchInfo1->changeDate.tv_sec,
+                                       searchInfo2->changeDate.tv_sec);
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
        
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
        
+               /* Access date */
+               if ( searchAttributes & ATTR_CMN_ACCTIME ) {
+                       matched = CompareRange(c_attr.ca_atime,
+                                       searchInfo1->accessDate.tv_sec,
+                                       searchInfo2->accessDate.tv_sec);
+                       if (matched == false) goto TestDone;
+                       atleastone = true;
+               }
+
                /* Backup date */
                if ( searchAttributes & ATTR_CMN_BKUPTIME ) {
                /* Backup date */
                if ( searchAttributes & ATTR_CMN_BKUPTIME ) {
-                       matched = CompareRange(to_bsd_time(cnp->cnd_backupDate),
-                           searchInfo1->lastBackupDate.tv_sec, searchInfo2->lastBackupDate.tv_sec );
+                       matched = CompareRange(c_attr.ca_btime,
+                                       searchInfo1->lastBackupDate.tv_sec,
+                                       searchInfo2->lastBackupDate.tv_sec);
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
        
                /* User ID */
                if ( searchAttributes & ATTR_CMN_OWNERID ) {
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
        
                /* User ID */
                if ( searchAttributes & ATTR_CMN_OWNERID ) {
-                       matched = CompareRange( cnp->cnd_ownerID, searchInfo1->uid, searchInfo2->uid );
+                       matched = CompareRange(c_attr.ca_uid,
+                                       searchInfo1->uid, searchInfo2->uid);
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
 
                /* Group ID */
                if ( searchAttributes & ATTR_CMN_GRPID ) {
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
 
                /* Group ID */
                if ( searchAttributes & ATTR_CMN_GRPID ) {
-                       matched = CompareRange( cnp->cnd_groupID, searchInfo1->gid, searchInfo2->gid );
+                       matched = CompareRange(c_attr.ca_gid,
+                                       searchInfo1->gid, searchInfo2->gid);
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
 
                /* mode */
                if ( searchAttributes & ATTR_CMN_ACCESSMASK ) {
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
 
                /* mode */
                if ( searchAttributes & ATTR_CMN_ACCESSMASK ) {
-                       matched = CompareRange( (u_long)cnp->cnd_mode, 
-                               (u_long)searchInfo1->mask, (u_long)searchInfo2->mask );
+                       matched = CompareRange((uint32_t)c_attr.ca_mode, 
+                                       (uint32_t)searchInfo1->mask,
+                                       (uint32_t)searchInfo2->mask);
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
                        if (matched == false) goto TestDone;
                        atleastone = true;
                }
-
        }
 
        /* If we got here w/o matching any, then set to false */
        }
 
        /* If we got here w/o matching any, then set to false */
@@ -697,103 +989,64 @@ TestDone:
  * Adds another record to the packed array for output
  */
 static int
  * Adds another record to the packed array for output
  */
 static int
-InsertMatch( struct vnode *root_vp, struct uio *a_uio, CatalogNodeData *cnp,
-               CatalogKey *key, struct attrlist *returnAttrList, void *attributesBuffer,
-               void *variableBuffer, u_long bufferSize, u_long * nummatches )
+InsertMatch(struct hfsmount *hfsmp, uio_t a_uio, CatalogRecord *rec,
+            CatalogKey *key, struct attrlist *returnAttrList,
+            void *attributesBuffer, void *variableBuffer, u_long * nummatches)
 {
        int err;
        void *rovingAttributesBuffer;
        void *rovingVariableBuffer;
 {
        int err;
        void *rovingAttributesBuffer;
        void *rovingVariableBuffer;
-       struct hfsCatalogInfo catalogInfo;
        u_long packedBufferSize;
        u_long packedBufferSize;
-       ExtendedVCB *vcb = VTOVCB(root_vp);
-       Boolean isHFSPlus = vcb->vcbSigWord == kHFSPlusSigWord;
-       u_long privateDir = VTOHFS(root_vp)->hfs_private_metadata_dir;
-
+       u_long privateDir = hfsmp->hfs_privdir_desc.cd_cnid;
+       struct attrblock attrblk;
+       struct cat_desc c_desc;
+       struct cat_attr c_attr;
+       struct cat_fork datafork;
+       struct cat_fork rsrcfork;
+
+       bzero(&c_desc, sizeof(c_desc));
+       bzero(&c_attr, sizeof(c_attr));
        rovingAttributesBuffer = (char*)attributesBuffer + sizeof(u_long); /* Reserve space for length field */
        rovingVariableBuffer = variableBuffer;
        rovingAttributesBuffer = (char*)attributesBuffer + sizeof(u_long); /* Reserve space for length field */
        rovingVariableBuffer = variableBuffer;
-       
-       INIT_CATALOGDATA(&catalogInfo.nodeData, 0);
-       catalogInfo.nodeData.cnd_iNodeNumCopy = 0;
 
 
-       /* The packing call below expects a struct hfsCatalogInfo */
-       bcopy(cnp, &catalogInfo.nodeData, (cnp->cnd_type == kCatalogFileNode) ?
-             sizeof(HFSPlusCatalogFile) : sizeof(HFSPlusCatalogFolder));
+       /* Convert catalog record into cat_attr format. */
+       cat_convertattr(hfsmp, rec, &c_attr, &datafork, &rsrcfork);
 
 
-       catalogInfo.nodeData.cnm_parID = isHFSPlus ? key->hfsPlus.parentID : key->hfs.parentID;
+       /* hide our private meta data directory */
+       if ((privateDir != 0) && (c_attr.ca_fileid == privateDir)) {
+               err = 0;
+               goto exit;
+       }
 
 
-       /* hide open files that have been deleted */
-       if ((privateDir != 0) && (catalogInfo.nodeData.cnm_parID == privateDir))
-               return (0);
+       /* Hide the private journal files */
+       if (hfsmp->jnl &&
+           ((c_attr.ca_fileid == hfsmp->hfs_jnlfileid) ||
+            (c_attr.ca_fileid == hfsmp->hfs_jnlinfoblkid))) {
+               err = 0;
+               goto exit;
+       }
 
 
-       /* hide our private meta data directory */
-       if ((privateDir != 0) && (catalogInfo.nodeData.cnd_nodeID == privateDir))
-               return (0);
-
-       if ( returnAttrList->commonattr & ATTR_CMN_NAME ) {
-               size_t utf8len = 0;
-
-               catalogInfo.nodeData.cnm_nameptr = catalogInfo.nodeData.cnm_namespace;
-
-               /* Return result in UTF-8 */
-               if ( isHFSPlus ) {
-                       err = utf8_encodestr(key->hfsPlus.nodeName.unicode,
-                                       key->hfsPlus.nodeName.length * sizeof(UniChar),
-                                       catalogInfo.nodeData.cnm_namespace,
-                                       &utf8len,
-                                       MAXHFSVNODELEN + 1, ':', 0);
-                       if (err == ENAMETOOLONG) {
-                               utf8len = utf8_encodelen(key->hfsPlus.nodeName.unicode,
-                                               key->hfsPlus.nodeName.length * sizeof(UniChar), ':', 0);
-                               MALLOC(catalogInfo.nodeData.cnm_nameptr, char *, utf8len+1, M_TEMP, M_WAITOK);
-                               catalogInfo.nodeData.cnm_flags |= kCatNameIsAllocated;
-                               err = utf8_encodestr(key->hfsPlus.nodeName.unicode,
-                                               key->hfsPlus.nodeName.length * sizeof(UniChar),
-                                               catalogInfo.nodeData.cnm_nameptr,
-                                               &utf8len,
-                                               utf8len + 1, ':', 0);
-                       }
-                } else {
-                       err = hfs_to_utf8(vcb, 
-                                       key->hfs.nodeName,
-                                       MAXHFSVNODELEN + 1,
-                                       (ByteCount*) &utf8len, 
-                                       catalogInfo.nodeData.cnm_namespace);
-                       if (err == ENAMETOOLONG) {
-                               MALLOC(catalogInfo.nodeData.cnm_nameptr, char *, utf8len+1, M_TEMP, M_WAITOK);
-                               catalogInfo.nodeData.cnm_flags |= kCatNameIsAllocated;
-                               err = hfs_to_utf8(vcb, 
-                                               key->hfs.nodeName, 
-                                               utf8len + 1, 
-                                               (ByteCount*) &utf8len, 
-                                               catalogInfo.nodeData.cnm_nameptr);
-                       } else if (err) {
-                               /*
-                                * When an HFS name cannot be encoded with the current
-                                * volume encoding we use MacRoman as a fallback.
-                                */
-                               err = mac_roman_to_utf8(key->hfs.nodeName, MAXHFSVNODELEN + 1,
-                                                       (ByteCount*) &utf8len,
-                                                        catalogInfo.nodeData.cnm_namespace);
-                       }
-               }
-               catalogInfo.nodeData.cnm_length = utf8len;
-               if (err && (catalogInfo.nodeData.cnm_flags & kCatNameIsAllocated))
-               {
-                       DisposePtr(catalogInfo.nodeData.cnm_nameptr);
-                       catalogInfo.nodeData.cnm_flags &= ~kCatNameIsAllocated;
-                        catalogInfo.nodeData.cnm_nameptr = catalogInfo.nodeData.cnm_namespace;
-                        catalogInfo.nodeData.cnm_namespace[0] = 0;
-               }
+       if (returnAttrList->commonattr & ATTR_CMN_NAME) {
+               cat_convertkey(hfsmp, key, rec, &c_desc);
+       } else {
+               c_desc.cd_cnid = c_attr.ca_fileid;
+               if (hfsmp->hfs_flags & HFS_STANDARD)
+                       c_desc.cd_parentcnid = key->hfs.parentID;
+               else
+                       c_desc.cd_parentcnid = key->hfsPlus.parentID;
        }
 
        }
 
-       PackCatalogInfoAttributeBlock( returnAttrList,root_vp, &catalogInfo, &rovingAttributesBuffer, &rovingVariableBuffer );
+       attrblk.ab_attrlist = returnAttrList;
+       attrblk.ab_attrbufpp = &rovingAttributesBuffer;
+       attrblk.ab_varbufpp = &rovingVariableBuffer;
+       attrblk.ab_flags = 0;
+       attrblk.ab_blocksize = 0;
 
 
-       CLEAN_CATALOGDATA(&catalogInfo.nodeData);
+       hfs_packattrblk(&attrblk, hfsmp, NULL, &c_desc, &c_attr, &datafork, &rsrcfork, current_proc());
 
        packedBufferSize = (char*)rovingVariableBuffer - (char*)attributesBuffer;
 
 
        packedBufferSize = (char*)rovingVariableBuffer - (char*)attributesBuffer;
 
-       if ( packedBufferSize > a_uio->uio_resid )
+       if ( packedBufferSize > uio_resid(a_uio) )
                return( errSearchBufferFull );
 
        (* nummatches)++;
                return( errSearchBufferFull );
 
        (* nummatches)++;
@@ -801,24 +1054,29 @@ InsertMatch( struct vnode *root_vp, struct uio *a_uio, CatalogNodeData *cnp,
        *((u_long *)attributesBuffer) = packedBufferSize;       /* Store length of fixed + var block */
        
        err = uiomove( (caddr_t)attributesBuffer, packedBufferSize, a_uio );    /* XXX should be packedBufferSize */
        *((u_long *)attributesBuffer) = packedBufferSize;       /* Store length of fixed + var block */
        
        err = uiomove( (caddr_t)attributesBuffer, packedBufferSize, a_uio );    /* XXX should be packedBufferSize */
+exit:
+       cat_releasedesc(&c_desc);
        
        return( err );
 }
 
 
 static int
        
        return( err );
 }
 
 
 static int
-UnpackSearchAttributeBlock( struct vnode *vp, struct attrlist  *alist, searchinfospec_t *searchInfo, void *attributeBuffer )
+UnpackSearchAttributeBlock( struct hfsmount *hfsmp, struct attrlist    *alist, searchinfospec_t *searchInfo, void *attributeBuffer )
 {
        attrgroup_t             a;
        u_long                  bufferSize;
 {
        attrgroup_t             a;
        u_long                  bufferSize;
+       boolean_t       is_64_bit;
 
     DBG_ASSERT(searchInfo != NULL);
 
     DBG_ASSERT(searchInfo != NULL);
+    
+    is_64_bit = proc_is64bit(current_proc());
 
 
-       bufferSize = *((u_long *)attributeBuffer);
+    bufferSize = *((uint32_t *)attributeBuffer);
        if (bufferSize == 0)
                return (EINVAL);        /* XXX -DJB is a buffer size of zero ever valid for searchfs? */
 
        if (bufferSize == 0)
                return (EINVAL);        /* XXX -DJB is a buffer size of zero ever valid for searchfs? */
 
-       ++((u_long *)attributeBuffer);  /* advance past the size */
+    ++((uint32_t *)attributeBuffer);   /* advance past the size */
        
        /* 
         * UnPack common attributes
        
        /* 
         * UnPack common attributes
@@ -826,39 +1084,41 @@ UnpackSearchAttributeBlock( struct vnode *vp, struct attrlist    *alist, searchinfo
        a = alist->commonattr;
        if ( a != 0 ) {
                if ( a & ATTR_CMN_NAME ) {
        a = alist->commonattr;
        if ( a != 0 ) {
                if ( a & ATTR_CMN_NAME ) {
-                       char *s = (char*) attributeBuffer + ((attrreference_t *) attributeBuffer)->attr_dataoffset;
-                       size_t len = ((attrreference_t *) attributeBuffer)->attr_length;
+                       char *s;
+                       u_int32_t len;
+
+            s = (char*) attributeBuffer + ((attrreference_t *) attributeBuffer)->attr_dataoffset;
+            len = ((attrreference_t *) attributeBuffer)->attr_length;
 
                        if (len > sizeof(searchInfo->name))
                                return (EINVAL);
 
 
                        if (len > sizeof(searchInfo->name))
                                return (EINVAL);
 
-                       if (VTOVCB(vp)->vcbSigWord == kHFSPlusSigWord) {
-                               size_t ucslen;
-                               /* Convert name to Unicode to match HFS Plus B-Tree names */
+                       if (hfsmp->hfs_flags & HFS_STANDARD) {
+                               /* Convert name to pascal string to match HFS B-Tree names */
 
                                if (len > 0) {
 
                                if (len > 0) {
-                                       if (utf8_decodestr(s, len-1, (UniChar*)searchInfo->name, &ucslen,
-                                           sizeof(searchInfo->name), ':', UTF_DECOMPOSED))
+                                       if (utf8_to_hfs(HFSTOVCB(hfsmp), len-1, s, (u_char*)searchInfo->name) != 0)
                                                return (EINVAL);
 
                                                return (EINVAL);
 
-                                       searchInfo->nameLength = ucslen / sizeof(UniChar);
+                                       searchInfo->nameLength = searchInfo->name[0];
                                } else {
                                } else {
-                                       searchInfo->nameLength = 0;
+                                       searchInfo->name[0] = searchInfo->nameLength = 0;
                                }
                                }
-                               ++((attrreference_t *)attributeBuffer);
-
+                ++((attrreference_t *)attributeBuffer);
                        } else {
                        } else {
-                               /* Convert name to pascal string to match HFS B-Tree names */
+                               size_t ucslen;
+                               /* Convert name to Unicode to match HFS Plus B-Tree names */
 
                                if (len > 0) {
 
                                if (len > 0) {
-                                       if (utf8_to_hfs(VTOVCB(vp), len-1, s, (u_char*)searchInfo->name) != 0)
+                                       if (utf8_decodestr(s, len-1, (UniChar*)searchInfo->name, &ucslen,
+                                           sizeof(searchInfo->name), ':', UTF_DECOMPOSED))
                                                return (EINVAL);
 
                                                return (EINVAL);
 
-                                       searchInfo->nameLength = searchInfo->name[0];
+                                       searchInfo->nameLength = ucslen / sizeof(UniChar);
                                } else {
                                } else {
-                                       searchInfo->name[0] = searchInfo->nameLength = 0;
+                                       searchInfo->nameLength = 0;
                                }
                                }
-                               ++((attrreference_t *)attributeBuffer);
+                ++((attrreference_t *)attributeBuffer);
                        }
                }
                if ( a & ATTR_CMN_OBJID ) {
                        }
                }
                if ( a & ATTR_CMN_OBJID ) {
@@ -870,28 +1130,73 @@ UnpackSearchAttributeBlock( struct vnode *vp, struct attrlist    *alist, searchinfo
                        ++((fsobj_id_t *)attributeBuffer);
                }
                if ( a & ATTR_CMN_CRTIME ) {
                        ++((fsobj_id_t *)attributeBuffer);
                }
                if ( a & ATTR_CMN_CRTIME ) {
-                       searchInfo->creationDate = *((struct timespec *)attributeBuffer);
-                       ++((struct timespec *)attributeBuffer);
+            if (is_64_bit) {
+                struct user_timespec tmp;
+                tmp = *((struct user_timespec *)attributeBuffer);
+                searchInfo->creationDate.tv_sec = (time_t)tmp.tv_sec;
+                searchInfo->creationDate.tv_nsec = tmp.tv_nsec;
+                ++((struct user_timespec *)attributeBuffer);
+            }
+            else {
+                searchInfo->creationDate = *((struct timespec *)attributeBuffer);
+                ++((struct timespec *)attributeBuffer);
+            }
                }
                if ( a & ATTR_CMN_MODTIME ) {
                }
                if ( a & ATTR_CMN_MODTIME ) {
-                       searchInfo->modificationDate = *((struct timespec *)attributeBuffer);
-                       ++((struct timespec *)attributeBuffer);
+            if (is_64_bit) {
+                struct user_timespec tmp;
+                tmp = *((struct user_timespec *)attributeBuffer);
+                searchInfo->modificationDate.tv_sec = (time_t)tmp.tv_sec;
+                searchInfo->modificationDate.tv_nsec = tmp.tv_nsec;
+                ++((struct user_timespec *)attributeBuffer);
+            }
+            else {
+                searchInfo->modificationDate = *((struct timespec *)attributeBuffer);
+                ++((struct timespec *)attributeBuffer);
+            }
                }
                if ( a & ATTR_CMN_CHGTIME ) {
                }
                if ( a & ATTR_CMN_CHGTIME ) {
-                       searchInfo->changeDate = *((struct timespec *)attributeBuffer);
-                       ++((struct timespec *)attributeBuffer);
+            if (is_64_bit) {
+                struct user_timespec tmp;
+                tmp = *((struct user_timespec *)attributeBuffer);
+                searchInfo->changeDate.tv_sec = (time_t)tmp.tv_sec;
+                searchInfo->changeDate.tv_nsec = tmp.tv_nsec;
+                ++((struct user_timespec *)attributeBuffer);
+            }
+            else {
+                searchInfo->changeDate = *((struct timespec *)attributeBuffer);
+                ++((struct timespec *)attributeBuffer);
+            }
+               }
+               if ( a & ATTR_CMN_ACCTIME ) {
+            if (is_64_bit) {
+                struct user_timespec tmp;
+                tmp = *((struct user_timespec *)attributeBuffer);
+                searchInfo->accessDate.tv_sec = (time_t)tmp.tv_sec;
+                searchInfo->accessDate.tv_nsec = tmp.tv_nsec;
+                ++((struct user_timespec *)attributeBuffer);
+            }
+            else {
+                searchInfo->accessDate = *((struct timespec *)attributeBuffer);
+                ++((struct timespec *)attributeBuffer);
+            }
                }
                if ( a & ATTR_CMN_BKUPTIME ) {
                }
                if ( a & ATTR_CMN_BKUPTIME ) {
-                       searchInfo->lastBackupDate = *((struct timespec *)attributeBuffer);
-                       ++((struct timespec *)attributeBuffer);
+            if (is_64_bit) {
+                struct user_timespec tmp;
+                tmp = *((struct user_timespec *)attributeBuffer);
+                searchInfo->lastBackupDate.tv_sec = (time_t)tmp.tv_sec;
+                searchInfo->lastBackupDate.tv_nsec = tmp.tv_nsec;
+                ++((struct user_timespec *)attributeBuffer);
+            }
+            else {
+                searchInfo->lastBackupDate = *((struct timespec *)attributeBuffer);
+                ++((struct timespec *)attributeBuffer);
+            }
                }
                if ( a & ATTR_CMN_FNDRINFO ) {
                }
                if ( a & ATTR_CMN_FNDRINFO ) {
-                  bcopy( attributeBuffer, searchInfo->finderInfo, sizeof(u_long) * 8 );
-                  (u_long *)attributeBuffer += 8;
-               }
-               if ( a & ATTR_CMN_BKUPTIME ) {
-                       searchInfo->lastBackupDate = *((struct timespec *)attributeBuffer);
-                       ++((struct timespec *)attributeBuffer);
+                       bcopy( attributeBuffer, searchInfo->finderInfo, sizeof(searchInfo->finderInfo) );
+                       (uint8_t *)attributeBuffer += 32;
                }
                if ( a & ATTR_CMN_OWNERID ) {
                        searchInfo->uid = *((uid_t *)attributeBuffer);
                }
                if ( a & ATTR_CMN_OWNERID ) {
                        searchInfo->uid = *((uid_t *)attributeBuffer);
@@ -910,8 +1215,8 @@ UnpackSearchAttributeBlock( struct vnode *vp, struct attrlist      *alist, searchinfo
        a = alist->dirattr;
        if ( a != 0 ) {
                if ( a & ATTR_DIR_ENTRYCOUNT ) {
        a = alist->dirattr;
        if ( a != 0 ) {
                if ( a & ATTR_DIR_ENTRYCOUNT ) {
-                       searchInfo->d.numFiles = *((u_long *)attributeBuffer);
-                       ++((u_long *)attributeBuffer);
+                       searchInfo->d.numFiles = *((u_int32_t *)attributeBuffer);
+                       ++((u_int32_t *)attributeBuffer);
                }
        }
 
                }
        }
 
@@ -939,6 +1244,7 @@ UnpackSearchAttributeBlock( struct vnode *vp, struct attrlist      *alist, searchinfo
 }
 
 
 }
 
 
+#if 1 // Installer workaround (2940423)
 /* this routine was added as part of the work around where some installers would fail */
 /* because they incorrectly assumed search results were in some kind of order.  */
 /* This routine is used to indentify the problematic target.  At this point we */
 /* this routine was added as part of the work around where some installers would fail */
 /* because they incorrectly assumed search results were in some kind of order.  */
 /* This routine is used to indentify the problematic target.  At this point we */
@@ -972,5 +1278,5 @@ static Boolean IsTargetName( searchinfospec_t * searchInfoPtr, Boolean isHFSPlus
        return( false );
        
 } /* IsTargetName */
        return( false );
        
 } /* IsTargetName */
-
+#endif // Installer workaround
 
 
mirror of XNU