]> git.saurik.com Git - apple/hfs.git/blob - core/hfs_search.c
projects / apple / hfs.git / blob
? search:


45aee7b74204bae2e2a17eb254ba178afc202973
[apple/hfs.git] / core / hfs_search.c
1 /*
2 * Copyright (c) 1997-2015 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 *
28 * @(#)hfs_search.c
29 */
30 /*
31 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
32 * support for mandatory and extensible security protections. This notice
33 * is included in support of clause 2.2 (b) of the Apple Public License,
34 * Version 2.0.
35 */
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/kernel.h>
40 #include <sys/file.h>
41 #include <sys/proc.h>
42 #include <sys/conf.h>
43 #include <mach/machine/vm_types.h>
44 #include <sys/vnode.h>
45 #include <sys/malloc.h>
46 #include <sys/signalvar.h>
47 #include <sys/attr.h>
48 #include <sys/utfconv.h>
49 #include <sys/kauth.h>
50 #include <sys/vm.h>
51
52 #if CONFIG_MACF
53 #include <security/mac_framework.h>
54 #endif
55
56 #include "hfs.h"
57 #include "hfs_dbg.h"
58 #include "hfs_catalog.h"
59 #include "hfs_attrlist.h"
60 #include "hfs_endian.h"
61
62 #include "FileMgrInternal.h"
63 #include "HFSUnicodeWrappers.h"
64 #include "BTreesPrivate.h"
65 #include "BTreeScanner.h"
66 #include "CatalogPrivate.h"
67
68 #if CONFIG_SEARCHFS
69
70 /* Search criterea. */
71 struct directoryInfoSpec
72 {
73 u_int32_t numFiles;
74 };
75
76 struct fileInfoSpec
77 {
78 off_t dataLogicalLength;
79 off_t dataPhysicalLength;
80 off_t resourceLogicalLength;
81 off_t resourcePhysicalLength;
82 };
83
84 struct searchinfospec
85 {
86 u_char name[kHFSPlusMaxFileNameBytes];
87 u_int32_t nameLength;
88 char attributes; // see IM:Files 2-100
89 u_int32_t nodeID;
90 u_int32_t parentDirID;
91 struct timespec creationDate;
92 struct timespec modificationDate;
93 struct timespec changeDate;
94 struct timespec accessDate;
95 struct timespec lastBackupDate;
96 u_int8_t finderInfo[32];
97 uid_t uid;
98 gid_t gid;
99 mode_t mask;
100 struct fileInfoSpec f;
101 struct directoryInfoSpec d;
102 };
103 typedef struct searchinfospec searchinfospec_t;
104
105 static void ResolveHardlink(struct hfsmount *hfsmp, HFSPlusCatalogFile *recp);
106
107
108 static int UnpackSearchAttributeBlock(struct hfsmount *hfsmp, struct attrlist *alist,
109 searchinfospec_t *searchInfo, void *attributeBuffer, int firstblock);
110
111 static int CheckCriteria( ExtendedVCB *vcb,
112 u_long searchBits,
113 struct attrlist *attrList,
114 CatalogRecord *rec,
115 CatalogKey *key,
116 searchinfospec_t *searchInfo1,
117 searchinfospec_t *searchInfo2,
118 struct vfs_context *ctx);
119
120 static int CheckAccess(ExtendedVCB *vcb, u_long searchBits, CatalogKey *key, struct vfs_context *ctx);
121
122 static int InsertMatch(struct hfsmount *hfsmp, uio_t a_uio, CatalogRecord *rec,
123 CatalogKey *key, struct attrlist *returnAttrList,
124 void *attributesBuffer, void *variableBuffer,
125 uint32_t * nummatches );
126
127 static Boolean CompareRange(u_long val, u_long low, u_long high);
128 static Boolean CompareWideRange(u_int64_t val, u_int64_t low, u_int64_t high);
129
130 static Boolean CompareRange( u_long val, u_long low, u_long high )
131 {
132 return( (val >= low) && (val <= high) );
133 }
134
135 static Boolean CompareWideRange( u_int64_t val, u_int64_t low, u_int64_t high )
136 {
137 return( (val >= low) && (val <= high) );
138 }
139 //#define CompareRange(val, low, high) ((val >= low) && (val <= high))
140
141
142 /************************************************************************/
143 /* Entry for searchfs() */
144 /************************************************************************/
145
146 #define errSearchBufferFull 101 /* Internal search errors */
147 /*
148 #
149 #% searchfs vp L L L
150 #
151 vnop_searchfs {
152 IN struct vnode *vp;
153 IN off_t length;
154 IN int flags;
155 IN kauth_cred_t cred;
156 IN struct proc *p;
157 };
158 */
159
160 int
161 hfs_vnop_search(ap)
162 struct vnop_searchfs_args *ap; /*
163 struct vnodeop_desc *a_desc;
164 struct vnode *a_vp;
165 void *a_searchparams1;
166 void *a_searchparams2;
167 struct attrlist *a_searchattrs;
168 u_long a_maxmatches;
169 struct timeval *a_timelimit;
170 struct attrlist *a_returnattrs;
171 u_long *a_nummatches;
172 u_long a_scriptcode;
173 u_long a_options;
174 struct uio *a_uio;
175 struct searchstate *a_searchstate;
176 vfs_context_t a_context;
177 */
178 {
179 ExtendedVCB *vcb = VTOVCB(ap->a_vp);
180 struct hfsmount *hfsmp;
181 FCB * catalogFCB;
182 searchinfospec_t searchInfo1;
183 searchinfospec_t searchInfo2;
184 void *attributesBuffer = NULL;
185 void *variableBuffer;
186 u_int32_t fixedBlockSize;
187 u_int32_t eachReturnBufferSize;
188 struct proc *p = current_proc();
189 int err = E_NONE;
190 int isHFSPlus;
191 CatalogKey * myCurrentKeyPtr;
192 CatalogRecord * myCurrentDataPtr;
193 CatPosition * myCatPositionPtr;
194 BTScanState myBTScanState;
195 user_addr_t user_start = 0;
196 user_size_t user_len = 0;
197 int32_t searchTime;
198 int lockflags;
199 boolean_t timerExpired = FALSE;
200
201 /* XXX Parameter check a_searchattrs? */
202
203 *(ap->a_nummatches) = 0;
204
205 if (ap->a_options & ~SRCHFS_VALIDOPTIONSMASK) {
206 return (EINVAL);
207 }
208
209 /*
210 * Fail requests for attributes that HFS does not support for the
211 * items that match the search criteria. Note that these checks
212 * are for the OUTBOUND attributes to be returned (not search criteria).
213 */
214 if ((ap->a_returnattrs->commonattr & ~HFS_ATTR_CMN_VALID) ||
215 (ap->a_returnattrs->volattr != 0) ||
216 (ap->a_returnattrs->dirattr & ~HFS_ATTR_DIR_VALID) ||
217 (ap->a_returnattrs->fileattr & ~HFS_ATTR_FILE_VALID) ||
218 (ap->a_returnattrs->forkattr != 0)) {
219
220 return (EINVAL);
221 }
222
223 /* SRCHFS_SKIPLINKS requires root access.
224 * This option cannot be used with either
225 * the ATTR_CMN_NAME or ATTR_CMN_PAROBJID
226 * attributes.
227 */
228 if (ap->a_options & SRCHFS_SKIPLINKS) {
229 attrgroup_t attrs;
230
231 attrs = ap->a_searchattrs->commonattr | ap->a_returnattrs->commonattr;
232 if (attrs & (ATTR_CMN_NAME | ATTR_CMN_PAROBJID)) {
233 return (EINVAL);
234 }
235
236 if ((err = vfs_context_suser(ap->a_context))) {
237 return (err);
238 }
239 }
240
241 // If both 32-bit and 64-bit parent ids or file ids are given
242 // then return an error.
243
244 attrgroup_t test_attrs=ap->a_searchattrs->commonattr;
245
246 if (((test_attrs & ATTR_CMN_OBJID) && (test_attrs & ATTR_CMN_FILEID)) ||
247 ((test_attrs & ATTR_CMN_PARENTID) && (test_attrs & ATTR_CMN_PAROBJID))) {
248 return (EINVAL);
249 }
250
251 if (uio_resid(ap->a_uio) <= 0) {
252 return (EINVAL);
253 }
254
255 isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord);
256 hfsmp = VTOHFS(ap->a_vp);
257
258 searchTime = kMaxMicroSecsInKernel;
259 if (ap->a_timelimit->tv_sec == 0 &&
260 ap->a_timelimit->tv_usec > 0 &&
261 ap->a_timelimit->tv_usec < kMaxMicroSecsInKernel) {
262 searchTime = ap->a_timelimit->tv_usec;
263 }
264
265 /* UnPack the search boundries, searchInfo1, searchInfo2 */
266 err = UnpackSearchAttributeBlock(hfsmp, ap->a_searchattrs,
267 &searchInfo1, ap->a_searchparams1, 1);
268 if (err) {
269 return err;
270 }
271 err = UnpackSearchAttributeBlock(hfsmp, ap->a_searchattrs,
272 &searchInfo2, ap->a_searchparams2, 0);
273 if (err) {
274 return err;
275 }
276 //shadow search bits if 64-bit file/parent ids are used
277 if (ap->a_searchattrs->commonattr & ATTR_CMN_FILEID)
278 ap->a_searchattrs->commonattr |= ATTR_CMN_OBJID;
279 if (ap->a_searchattrs->commonattr & ATTR_CMN_PARENTID)
280 ap->a_searchattrs->commonattr |= ATTR_CMN_PAROBJID;
281
282 fixedBlockSize = sizeof(u_int32_t) + hfs_attrblksize(ap->a_returnattrs); /* u_int32_t for length word */
283
284 eachReturnBufferSize = fixedBlockSize;
285
286 if ( ap->a_returnattrs->commonattr & ATTR_CMN_NAME ) /* XXX should be more robust! */
287 eachReturnBufferSize += kHFSPlusMaxFileNameBytes + 1;
288
289 attributesBuffer = hfs_mallocz(eachReturnBufferSize);
290 variableBuffer = (void*)((char*) attributesBuffer + fixedBlockSize);
291
292 // XXXdbg - have to lock the user's buffer so we don't fault
293 // while holding the shared catalog file lock. see the comment
294 // in hfs_readdir() for more details.
295 //
296 if (hfsmp->jnl && uio_isuserspace(ap->a_uio)) {
297 user_start = uio_curriovbase(ap->a_uio);
298 user_len = uio_curriovlen(ap->a_uio);
299
300 if ((err = vslock(user_start, user_len)) != 0) {
301 user_start = 0;
302 goto ExitThisRoutine;
303 }
304 }
305
306 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
307
308 catalogFCB = GetFileControlBlock(vcb->catalogRefNum);
309 myCurrentKeyPtr = NULL;
310 myCurrentDataPtr = NULL;
311 myCatPositionPtr = (CatPosition *)ap->a_searchstate;
312
313 if (ap->a_options & SRCHFS_START) {
314 /* Starting a new search. */
315 /* Make sure the on-disk Catalog file is current */
316 (void) hfs_fsync(vcb->catalogRefNum, MNT_WAIT, 0, p);
317 if (hfsmp->jnl) {
318 hfs_systemfile_unlock(hfsmp, lockflags);
319 hfs_flush(hfsmp, HFS_FLUSH_JOURNAL);
320 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
321 }
322
323 ap->a_options &= ~SRCHFS_START;
324 bzero((caddr_t)myCatPositionPtr, sizeof(*myCatPositionPtr));
325 err = BTScanInitialize(catalogFCB, 0, 0, 0, kCatSearchBufferSize, &myBTScanState);
326 if (err) {
327 hfs_systemfile_unlock(hfsmp, lockflags);
328 goto ExitThisRoutine;
329 }
330 } else {
331 /* Resuming a search. */
332 err = BTScanInitialize(catalogFCB, myCatPositionPtr->nextNode,
333 myCatPositionPtr->nextRecord,
334 myCatPositionPtr->recordsFound,
335 kCatSearchBufferSize,
336 &myBTScanState);
337 /* Make sure Catalog hasn't changed. */
338 if (err == 0
339 && myCatPositionPtr->writeCount != myBTScanState.btcb->writeCount) {
340 myCatPositionPtr->writeCount = myBTScanState.btcb->writeCount;
341 err = EBUSY; /* catChangedErr */
342 }
343 }
344 hfs_systemfile_unlock(hfsmp, lockflags);
345
346 if (err)
347 goto ExitThisRoutine;
348
349 /*
350 * Check all the catalog btree records...
351 * return the attributes for matching items
352 */
353 for (;;) {
354 struct timeval myCurrentTime;
355 struct timeval myElapsedTime;
356
357 err = BTScanNextRecord(&myBTScanState, timerExpired,
358 (void **)&myCurrentKeyPtr, (void **)&myCurrentDataPtr,
359 NULL);
360 if (err)
361 break;
362
363 /* Resolve any hardlinks */
364 if (isHFSPlus && (ap->a_options & SRCHFS_SKIPLINKS) == 0) {
365 ResolveHardlink(vcb, (HFSPlusCatalogFile *)myCurrentDataPtr);
366 }
367 if (CheckCriteria( vcb, ap->a_options, ap->a_searchattrs, myCurrentDataPtr,
368 myCurrentKeyPtr, &searchInfo1, &searchInfo2, ap->a_context )
369 && CheckAccess(vcb, ap->a_options, myCurrentKeyPtr, ap->a_context)) {
370 err = InsertMatch(hfsmp, ap->a_uio, myCurrentDataPtr,
371 myCurrentKeyPtr, ap->a_returnattrs,
372 attributesBuffer, variableBuffer, ap->a_nummatches);
373 if (err) {
374 /*
375 * The last match didn't fit so come back
376 * to this record on the next trip.
377 */
378 --myBTScanState.recordsFound;
379 --myBTScanState.recordNum;
380 break;
381 }
382
383 if (*(ap->a_nummatches) >= ap->a_maxmatches)
384 break;
385 }
386 if (timerExpired == FALSE) {
387 /*
388 * Check our elapsed time and bail if we've hit the max.
389 * The idea here is to throttle the amount of time we
390 * spend in the kernel.
391 */
392 microuptime(&myCurrentTime);
393 timersub(&myCurrentTime, &myBTScanState.startTime, &myElapsedTime);
394 /*
395 * Note: assumes kMaxMicroSecsInKernel is less than 1,000,000
396 */
397 if (myElapsedTime.tv_sec > 0
398 || myElapsedTime.tv_usec >= searchTime) {
399 timerExpired = TRUE;
400 } else if (throttle_io_will_be_throttled(-1, HFSTOVFS(hfsmp)))
401 timerExpired = TRUE;
402 }
403 }
404
405 /* Update catalog position */
406 myCatPositionPtr->writeCount = myBTScanState.btcb->writeCount;
407
408 BTScanTerminate(&myBTScanState, &myCatPositionPtr->nextNode,
409 &myCatPositionPtr->nextRecord,
410 &myCatPositionPtr->recordsFound);
411
412 if ( err == E_NONE ) {
413 err = EAGAIN; /* signal to the user to call searchfs again */
414 } else if ( err == errSearchBufferFull ) {
415 if ( *(ap->a_nummatches) > 0 )
416 err = EAGAIN;
417 else
418 err = ENOBUFS;
419 } else if ( err == btNotFound ) {
420 err = E_NONE; /* the entire disk has been searched */
421 } else if ( err == fsBTTimeOutErr ) {
422 err = EAGAIN;
423 }
424
425 ExitThisRoutine:
426 if (attributesBuffer)
427 hfs_free(attributesBuffer, eachReturnBufferSize);
428
429 if (user_start) {
430 vsunlock(user_start, user_len, TRUE);
431 }
432
433 return (MacToVFSError(err));
434 }
435
436
437 static void
438 ResolveHardlink(struct hfsmount *hfsmp, HFSPlusCatalogFile *recp)
439 {
440 u_int32_t type, creator;
441 int isdirlink = 0;
442 int isfilelink = 0;
443 time_t filecreatedate;
444
445 if (recp->recordType != kHFSPlusFileRecord) {
446 return;
447 }
448 type = SWAP_BE32(recp->userInfo.fdType);
449 creator = SWAP_BE32(recp->userInfo.fdCreator);
450 filecreatedate = to_bsd_time(recp->createDate);
451
452 if ((type == kHardLinkFileType && creator == kHFSPlusCreator) &&
453 (filecreatedate == (time_t)hfsmp->hfs_itime ||
454 filecreatedate == (time_t)hfsmp->hfs_metadata_createdate)) {
455 isfilelink = 1;
456 } else if ((type == kHFSAliasType && creator == kHFSAliasCreator) &&
457 (recp->flags & kHFSHasLinkChainMask) &&
458 (filecreatedate == (time_t)hfsmp->hfs_itime ||
459 filecreatedate == (time_t)hfsmp->hfs_metadata_createdate)) {
460 isdirlink = 1;
461 }
462
463 if (isfilelink || isdirlink) {
464 cnid_t saved_cnid;
465 int lockflags;
466
467 /* Export link's cnid (a unique value) instead of inode's cnid */
468 saved_cnid = recp->fileID;
469 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
470
471 (void) cat_resolvelink(hfsmp, recp->hl_linkReference, isdirlink, recp);
472
473 recp->fileID = saved_cnid;
474 hfs_systemfile_unlock(hfsmp, lockflags);
475 }
476 }
477
478
479 static Boolean
480 CompareMasked(const u_int32_t *thisValue, const u_int32_t *compareData,
481 const u_int32_t *compareMask, u_int32_t count)
482 {
483 Boolean matched;
484 u_int32_t i;
485
486 matched = true; /* Assume it will all match */
487
488 for (i=0; i<count; i++) {
489 if (((*thisValue++ ^ *compareData++) & *compareMask++) != 0) {
490 matched = false;
491 break;
492 }
493 }
494
495 return matched;
496 }
497
498
499 static Boolean
500 ComparePartialUnicodeName (register ConstUniCharArrayPtr str, register ItemCount s_len,
501 register ConstUniCharArrayPtr find, register ItemCount f_len, int caseSensitive )
502 {
503 if (f_len == 0 || s_len == 0) {
504 return FALSE;
505 }
506
507 if (caseSensitive) {
508 do {
509 if (s_len-- < f_len)
510 return FALSE;
511 } while (UnicodeBinaryCompare(str++, f_len, find, f_len) != 0);
512 }
513 else {
514 do {
515 if (s_len-- < f_len)
516 return FALSE;
517 } while (FastUnicodeCompare(str++, f_len, find, f_len) != 0);
518 }
519
520 return TRUE;
521 }
522
523 #if CONFIG_HFS_STD
524 static Boolean
525 ComparePartialPascalName ( register ConstStr31Param str, register ConstStr31Param find )
526 {
527 register u_char s_len = str[0];
528 register u_char f_len = find[0];
529 register u_char *tsp;
530 Str31 tmpstr;
531
532 if (f_len == 0 || s_len == 0)
533 return FALSE;
534
535 bcopy(str, tmpstr, s_len + 1);
536 tsp = &tmpstr[0];
537
538 while (s_len-- >= f_len) {
539 *tsp = f_len;
540
541 if (FastRelString(tsp++, find) == 0)
542 return TRUE;
543 }
544
545 return FALSE;
546 }
547 #endif
548
549
550 /*
551 * Check to see if caller has access rights to this item
552 */
553
554 static int
555 CheckAccess(ExtendedVCB *theVCBPtr, u_long searchBits, CatalogKey *theKeyPtr, struct vfs_context *ctx)
556 {
557 Boolean isHFSPlus;
558 int myErr;
559 int myResult;
560 HFSCatalogNodeID myNodeID;
561 hfsmount_t * hfsmp;
562 struct FndrDirInfo *finfop;
563 struct vnode * vp = NULL;
564
565 myResult = 0; /* default to "no access" */
566
567 if (!vfs_context_suser(ctx)) {
568 myResult = 1; /* allow access */
569 goto ExitThisRoutine; /* root always has access */
570 }
571
572 hfsmp = VCBTOHFS( theVCBPtr );
573 isHFSPlus = ( theVCBPtr->vcbSigWord == kHFSPlusSigWord );
574 if ( isHFSPlus )
575 myNodeID = theKeyPtr->hfsPlus.parentID;
576 #if CONFIG_HFS_STD
577 else
578 myNodeID = theKeyPtr->hfs.parentID;
579 #endif
580
581 while ( myNodeID >= kRootDirID ) {
582 cnode_t * cp;
583
584 /* now go get catalog data for this directory */
585 myErr = hfs_vget(hfsmp, myNodeID, &vp, 0, 0);
586 if ( myErr ) {
587 goto ExitThisRoutine; /* no access */
588 }
589
590 cp = VTOC(vp);
591 finfop = (struct FndrDirInfo *)&cp->c_attr.ca_finderinfo[0];
592
593 if ( searchBits & SRCHFS_SKIPPACKAGES ) {
594 if ( (SWAP_BE16(finfop->frFlags) & kHasBundle)
595 || (cp->c_desc.cd_nameptr != NULL
596 && is_package_name((const char *)cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen)) ) {
597 myResult = 0;
598 goto ExitThisRoutine;
599 }
600 }
601
602 if ( searchBits & SRCHFS_SKIPINAPPROPRIATE ) {
603 if ( cp->c_parentcnid == kRootDirID && cp->c_desc.cd_nameptr != NULL &&
604 vn_searchfs_inappropriate_name((const char *)cp->c_desc.cd_nameptr, cp->c_desc.cd_namelen) ) {
605 myResult = 0;
606 goto ExitThisRoutine;
607 }
608 }
609
610 if ( (searchBits & SRCHFS_SKIPINVISIBLE) &&
611 (SWAP_BE16(finfop->frFlags) & kIsInvisible) ) {
612 myResult = 0;
613 goto ExitThisRoutine;
614 }
615
616 myNodeID = cp->c_parentcnid; /* move up the hierarchy */
617 hfs_unlock(VTOC(vp));
618
619 #if CONFIG_MACF
620 if (vp->v_type == VDIR) {
621 myErr = mac_vnode_check_readdir(ctx, vp);
622 } else {
623 myErr = mac_vnode_check_stat(ctx, NOCRED, vp);
624 }
625 if (myErr) {
626 vnode_put(vp);
627 vp = NULL;
628 goto ExitThisRoutine;
629 }
630 #endif /* MAC */
631
632 if (vnode_vtype(vp) == VDIR) {
633 myErr = vnode_authorize(vp, NULL, (KAUTH_VNODE_SEARCH | KAUTH_VNODE_LIST_DIRECTORY), ctx);
634 } else {
635 myErr = vnode_authorize(vp, NULL, (KAUTH_VNODE_SEARCH), ctx);
636 }
637 vnode_put(vp);
638 vp = NULL;
639 if ( myErr ) {
640 goto ExitThisRoutine; /* no access */
641 }
642 }
643 myResult = 1; /* allow access */
644
645 ExitThisRoutine:
646 if ( vp != NULL ) {
647 hfs_unlock(VTOC(vp));
648 vnode_put(vp);
649 }
650 return ( myResult );
651
652 }
653
654 static int
655 CheckCriteria( ExtendedVCB *vcb,
656 u_long searchBits,
657 struct attrlist *attrList,
658 CatalogRecord *rec,
659 CatalogKey *key,
660 searchinfospec_t *searchInfo1,
661 searchinfospec_t *searchInfo2,
662 struct vfs_context *ctx)
663 {
664 Boolean matched, atleastone;
665 Boolean isHFSPlus;
666 attrgroup_t searchAttributes;
667 struct cat_attr c_attr;
668 struct cat_fork datafork;
669 struct cat_fork rsrcfork;
670 int force_case_sensitivity = proc_is_forcing_hfs_case_sensitivity(vfs_context_proc(ctx));
671
672 bzero(&c_attr, sizeof(c_attr));
673 isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord);
674
675 switch (rec->recordType) {
676
677 #if CONFIG_HFS_STD
678 case kHFSFolderRecord:
679 if ( (searchBits & SRCHFS_MATCHDIRS) == 0 ) { /* If we are NOT searching folders */
680 matched = false;
681 goto TestDone;
682 }
683 break;
684
685 case kHFSFileRecord:
686 if ( (searchBits & SRCHFS_MATCHFILES) == 0 ) { /* If we are NOT searching files */
687 matched = false;
688 goto TestDone;
689 }
690 break;
691 #endif
692
693 case kHFSPlusFolderRecord:
694 if ( (searchBits & SRCHFS_MATCHDIRS) == 0 ) { /* If we are NOT searching folders */
695 matched = false;
696 goto TestDone;
697 }
698 break;
699
700 case kHFSPlusFileRecord:
701 /* Check if hardlink links should be skipped. */
702 if (searchBits & SRCHFS_SKIPLINKS) {
703 cnid_t parid = key->hfsPlus.parentID;
704 HFSPlusCatalogFile *filep = (HFSPlusCatalogFile *)rec;
705
706 if ((SWAP_BE32(filep->userInfo.fdType) == kHardLinkFileType) &&
707 (SWAP_BE32(filep->userInfo.fdCreator) == kHFSPlusCreator)) {
708 return (false); /* skip over file link records */
709 } else if ((parid == vcb->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&
710 (filep->bsdInfo.special.linkCount == 0)) {
711 return (false); /* skip over unlinked files */
712 } else if ((SWAP_BE32(filep->userInfo.fdType) == kHFSAliasType) &&
713 (SWAP_BE32(filep->userInfo.fdCreator) == kHFSAliasCreator) &&
714 (filep->flags & kHFSHasLinkChainMask)) {
715 return (false); /* skip over dir link records */
716 }
717 } else if (key->hfsPlus.parentID == vcb->hfs_private_desc[FILE_HARDLINKS].cd_cnid) {
718 return (false); /* skip over private files */
719 } else if (key->hfsPlus.parentID == vcb->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {
720 return (false); /* skip over private files */
721 }
722
723 if ( (searchBits & SRCHFS_MATCHFILES) == 0 ) { /* If we are NOT searching files */
724 matched = false;
725 goto TestDone;
726 }
727 break;
728
729 default: /* Never match a thread record or any other type. */
730 return( false ); /* Not a file or folder record, so can't search it */
731 }
732
733 matched = true; /* Assume we got a match */
734 atleastone = false; /* Dont insert unless we match at least one criteria */
735
736 /* First, attempt to match the name -- either partial or complete */
737 if ( attrList->commonattr & ATTR_CMN_NAME ) {
738 if (isHFSPlus) {
739 int case_sensitive = 0;
740
741 /*
742 * Longstanding default behavior here is to use a non-case-sensitive
743 * search, even on case-sensitive filesystems.
744 *
745 * We only force case sensitivity if the controlling process has explicitly
746 * asked for it in the proc flags, and only if they are not doing
747 * a partial name match. Consider that if you are doing a partial
748 * name match ("all files that begin with 'image'"), the likelihood is
749 * high that you would want to see all matches, even those that do not
750 * explicitly match the case.
751 */
752 if (force_case_sensitivity) {
753 case_sensitive = 1;
754 }
755
756 /* Check for partial/full HFS Plus name match */
757
758 if ( searchBits & SRCHFS_MATCHPARTIALNAMES ) {
759 /* always use a case-INSENSITIVE search here */
760 matched = ComparePartialUnicodeName(key->hfsPlus.nodeName.unicode,
761 key->hfsPlus.nodeName.length,
762 (UniChar*)searchInfo1->name,
763 searchInfo1->nameLength, 0);
764 }
765 else {
766 /* Full name match. Are we HFSX (case sensitive) or HFS+ ? */
767 if (case_sensitive) {
768 matched = (UnicodeBinaryCompare(key->hfsPlus.nodeName.unicode,
769 key->hfsPlus.nodeName.length,
770 (UniChar*)searchInfo1->name,
771 searchInfo1->nameLength ) == 0);
772 }
773 else {
774 matched = (FastUnicodeCompare(key->hfsPlus.nodeName.unicode,
775 key->hfsPlus.nodeName.length,
776 (UniChar*)searchInfo1->name,
777 searchInfo1->nameLength ) == 0);
778 }
779 }
780 }
781 #if CONFIG_HFS_STD
782 else {
783 /* Check for partial/full HFS name match */
784
785 if ( searchBits & SRCHFS_MATCHPARTIALNAMES )
786 matched = ComparePartialPascalName(key->hfs.nodeName, (u_char*)searchInfo1->name);
787 else /* full HFS name match */
788 matched = (FastRelString(key->hfs.nodeName, (u_char*)searchInfo1->name) == 0);
789 }
790 #endif
791
792 if ( matched == false || (searchBits & ~SRCHFS_MATCHPARTIALNAMES) == 0 )
793 goto TestDone; /* no match, or nothing more to compare */
794
795 atleastone = true;
796 }
797
798 /* Convert catalog record into cat_attr format. */
799 cat_convertattr(VCBTOHFS(vcb), rec, &c_attr, &datafork, &rsrcfork);
800
801 if (searchBits & SRCHFS_SKIPINVISIBLE) {
802 int flags;
803
804 switch (rec->recordType) {
805 #if CONFIG_HFS_STD
806 case kHFSFolderRecord:
807 {
808 struct FndrDirInfo *finder_info;
809
810 finder_info = (struct FndrDirInfo *)&c_attr.ca_finderinfo[0];
811 flags = SWAP_BE16(finder_info->frFlags);
812 break;
813 }
814
815 case kHFSFileRecord:
816 {
817 struct FndrFileInfo *finder_info;
818
819 finder_info = (struct FndrFileInfo *)&c_attr.ca_finderinfo[0];
820 flags = SWAP_BE16(finder_info->fdFlags);
821 break;
822 }
823 #endif
824
825 case kHFSPlusFolderRecord:
826 {
827 struct FndrDirInfo *finder_info;
828
829 finder_info = (struct FndrDirInfo *)&c_attr.ca_finderinfo[0];
830 flags = SWAP_BE16(finder_info->frFlags);
831 break;
832 }
833
834 case kHFSPlusFileRecord:
835 {
836 struct FndrFileInfo *finder_info;
837
838 finder_info = (struct FndrFileInfo *)&c_attr.ca_finderinfo[0];
839 flags = SWAP_BE16(finder_info->fdFlags);
840 break;
841 }
842
843 default:
844 {
845 flags = kIsInvisible;
846 break;
847 }
848 }
849
850 if (flags & kIsInvisible) {
851 matched = false;
852 goto TestDone;
853 }
854 }
855
856
857
858 /* Now that we have a record worth searching, see if it matches the search attributes */
859 #if CONFIG_HFS_STD
860 if (rec->recordType == kHFSFileRecord ||
861 rec->recordType == kHFSPlusFileRecord) {
862 #else
863 if (rec->recordType == kHFSPlusFileRecord) {
864 #endif
865
866 if ((attrList->fileattr & ~ATTR_FILE_VALIDMASK) != 0) { /* attr we do know about */
867 matched = false;
868 goto TestDone;
869 }
870 else if ((attrList->fileattr & ATTR_FILE_VALIDMASK) != 0) {
871 searchAttributes = attrList->fileattr;
872
873 #if HFS_COMPRESSION
874 if ( c_attr.ca_flags & UF_COMPRESSED ) {
875 /* for compressed files, set the data length to the uncompressed data size */
876 if (( searchAttributes & ATTR_FILE_DATALENGTH ) ||
877 ( searchAttributes & ATTR_FILE_DATAALLOCSIZE ) ) {
878 if ( 0 == hfs_uncompressed_size_of_compressed_file(vcb, NULL, c_attr.ca_fileid, &datafork.cf_size, 1) ) { /* 1 == don't take the cnode lock */
879 datafork.cf_blocks = rsrcfork.cf_blocks;
880 }
881 }
882 /* treat compressed files as if their resource fork is empty */
883 if (( searchAttributes & ATTR_FILE_RSRCLENGTH ) ||
884 ( searchAttributes & ATTR_FILE_RSRCALLOCSIZE ) ) {
885 rsrcfork.cf_size = 0;
886 rsrcfork.cf_blocks = 0;
887 }
888 }
889 #endif /* HFS_COMPRESSION */
890
891 /* File logical length (data fork) */
892 if ( searchAttributes & ATTR_FILE_DATALENGTH ) {
893 matched = CompareWideRange(
894 datafork.cf_size,
895 searchInfo1->f.dataLogicalLength,
896 searchInfo2->f.dataLogicalLength);
897 if (matched == false) goto TestDone;
898 atleastone = true;
899 }
900
901 /* File physical length (data fork) */
902 if ( searchAttributes & ATTR_FILE_DATAALLOCSIZE ) {
903 matched = CompareWideRange(
904 (u_int64_t)datafork.cf_blocks * (u_int64_t)vcb->blockSize,
905 searchInfo1->f.dataPhysicalLength,
906 searchInfo2->f.dataPhysicalLength);
907 if (matched == false) goto TestDone;
908 atleastone = true;
909 }
910
911 /* File logical length (resource fork) */
912 if ( searchAttributes & ATTR_FILE_RSRCLENGTH ) {
913 matched = CompareWideRange(
914 rsrcfork.cf_size,
915 searchInfo1->f.resourceLogicalLength,
916 searchInfo2->f.resourceLogicalLength);
917 if (matched == false) goto TestDone;
918 atleastone = true;
919 }
920
921 /* File physical length (resource fork) */
922 if ( searchAttributes & ATTR_FILE_RSRCALLOCSIZE ) {
923 matched = CompareWideRange(
924 (u_int64_t)rsrcfork.cf_blocks * (u_int64_t)vcb->blockSize,
925 searchInfo1->f.resourcePhysicalLength,
926 searchInfo2->f.resourcePhysicalLength);
927 if (matched == false) goto TestDone;
928 atleastone = true;
929 }
930 }
931 else {
932 atleastone = true; /* to match SRCHFS_MATCHFILES */
933 }
934 }
935 /*
936 * Check the directory attributes
937 */
938 #if CONFIG_HFS_STD
939 else if (rec->recordType == kHFSFolderRecord ||
940 rec->recordType == kHFSPlusFolderRecord) {
941 #else
942 else if (rec->recordType == kHFSPlusFolderRecord) {
943 #endif
944 if ((attrList->dirattr & ~ATTR_DIR_VALIDMASK) != 0) { /* attr we do know about */
945 matched = false;
946 goto TestDone;
947 }
948 else if ((attrList->dirattr & ATTR_DIR_VALIDMASK) != 0) {
949 searchAttributes = attrList->dirattr;
950
951 /* Directory valence */
952 if ( searchAttributes & ATTR_DIR_ENTRYCOUNT ) {
953 matched = CompareRange(c_attr.ca_entries,
954 searchInfo1->d.numFiles,
955 searchInfo2->d.numFiles );
956 if (matched == false) goto TestDone;
957 atleastone = true;
958 }
959 }
960 else {
961 atleastone = true; /* to match SRCHFS_MATCHDIRS */
962 }
963 }
964
965 /*
966 * Check the common attributes
967 */
968 searchAttributes = attrList->commonattr;
969 if ( (searchAttributes & ATTR_CMN_VALIDMASK) != 0 ) {
970 /* node ID */
971 if ( searchAttributes & ATTR_CMN_OBJID ) {
972 matched = CompareRange(c_attr.ca_fileid,
973 searchInfo1->nodeID,
974 searchInfo2->nodeID );
975 if (matched == false) goto TestDone;
976 atleastone = true;
977 }
978
979 /* Parent ID */
980 if ( searchAttributes & ATTR_CMN_PAROBJID ) {
981 HFSCatalogNodeID parentID;
982
983 if (isHFSPlus)
984 parentID = key->hfsPlus.parentID;
985 #if CONFIG_HFS_STD
986 else
987 parentID = key->hfs.parentID;
988 #endif
989
990 matched = CompareRange(parentID, searchInfo1->parentDirID,
991 searchInfo2->parentDirID );
992 if (matched == false) goto TestDone;
993 atleastone = true;
994 }
995
996 /* Finder Info & Extended Finder Info where extFinderInfo is last 32 bytes */
997 if ( searchAttributes & ATTR_CMN_FNDRINFO ) {
998 u_int32_t *thisValue;
999 thisValue = (u_int32_t *) &c_attr.ca_finderinfo;
1000
1001 /*
1002 * Note: ioFlFndrInfo and ioDrUsrWds have the same offset in search info, so
1003 * no need to test the object type here.
1004 */
1005 matched = CompareMasked(thisValue,
1006 (u_int32_t *)&searchInfo1->finderInfo,
1007 (u_int32_t *) &searchInfo2->finderInfo, 8);
1008 if (matched == false) goto TestDone;
1009 atleastone = true;
1010 }
1011
1012 /* Create date */
1013 if ( searchAttributes & ATTR_CMN_CRTIME ) {
1014 matched = CompareRange(c_attr.ca_itime,
1015 searchInfo1->creationDate.tv_sec,
1016 searchInfo2->creationDate.tv_sec);
1017 if (matched == false) goto TestDone;
1018 atleastone = true;
1019 }
1020
1021 /* Mod date */
1022 if ( searchAttributes & ATTR_CMN_MODTIME ) {
1023 matched = CompareRange(c_attr.ca_mtime,
1024 searchInfo1->modificationDate.tv_sec,
1025 searchInfo2->modificationDate.tv_sec);
1026 if (matched == false) goto TestDone;
1027 atleastone = true;
1028 }
1029
1030 /* Change Time */
1031 if ( searchAttributes & ATTR_CMN_CHGTIME ) {
1032 matched = CompareRange(c_attr.ca_ctime,
1033 searchInfo1->changeDate.tv_sec,
1034 searchInfo2->changeDate.tv_sec);
1035 if (matched == false) goto TestDone;
1036 atleastone = true;
1037 }
1038
1039 /* Access date */
1040 if ( searchAttributes & ATTR_CMN_ACCTIME ) {
1041 matched = CompareRange(c_attr.ca_atime,
1042 searchInfo1->accessDate.tv_sec,
1043 searchInfo2->accessDate.tv_sec);
1044 if (matched == false) goto TestDone;
1045 atleastone = true;
1046 }
1047
1048 /* Backup date */
1049 if ( searchAttributes & ATTR_CMN_BKUPTIME ) {
1050 matched = CompareRange(c_attr.ca_btime,
1051 searchInfo1->lastBackupDate.tv_sec,
1052 searchInfo2->lastBackupDate.tv_sec);
1053 if (matched == false) goto TestDone;
1054 atleastone = true;
1055 }
1056
1057 /* User ID */
1058 if ( searchAttributes & ATTR_CMN_OWNERID ) {
1059 matched = CompareRange(c_attr.ca_uid,
1060 searchInfo1->uid, searchInfo2->uid);
1061 if (matched == false) goto TestDone;
1062 atleastone = true;
1063 }
1064
1065 /* Group ID */
1066 if ( searchAttributes & ATTR_CMN_GRPID ) {
1067 matched = CompareRange(c_attr.ca_gid,
1068 searchInfo1->gid, searchInfo2->gid);
1069 if (matched == false) goto TestDone;
1070 atleastone = true;
1071 }
1072
1073 /* mode */
1074 if ( searchAttributes & ATTR_CMN_ACCESSMASK ) {
1075 matched = CompareRange((u_int32_t)c_attr.ca_mode,
1076 (u_int32_t)searchInfo1->mask,
1077 (u_int32_t)searchInfo2->mask);
1078 if (matched == false) goto TestDone;
1079 atleastone = true;
1080 }
1081 }
1082
1083 /* If we got here w/o matching any, then set to false */
1084 if (! atleastone)
1085 matched = false;
1086
1087 TestDone:
1088 /*
1089 * Finally, determine whether we need to negate the sense of the match
1090 * (i.e. find all objects that DON'T match).
1091 */
1092 if ( searchBits & SRCHFS_NEGATEPARAMS )
1093 matched = !matched;
1094
1095 return( matched );
1096 }
1097
1098
1099 /*
1100 * Adds another record to the packed array for output
1101 */
1102 static int
1103 InsertMatch(struct hfsmount *hfsmp, uio_t a_uio, CatalogRecord *rec,
1104 CatalogKey *key, struct attrlist *returnAttrList,
1105 void *attributesBuffer, void *variableBuffer, uint32_t * nummatches)
1106 {
1107 int err;
1108 void *rovingAttributesBuffer;
1109 void *rovingVariableBuffer;
1110 long packedBufferSize;
1111 struct attrblock attrblk;
1112 struct cat_desc c_desc;
1113 struct cat_attr c_attr;
1114 struct cat_fork datafork;
1115 struct cat_fork rsrcfork;
1116
1117 bzero(&c_desc, sizeof(c_desc));
1118 bzero(&c_attr, sizeof(c_attr));
1119 rovingAttributesBuffer = (char*)attributesBuffer + sizeof(u_int32_t); /* Reserve space for length field */
1120 rovingVariableBuffer = variableBuffer;
1121
1122 /* Convert catalog record into cat_attr format. */
1123 cat_convertattr(hfsmp, rec, &c_attr, &datafork, &rsrcfork);
1124
1125 /* Hide our private meta data directories */
1126 if (c_attr.ca_fileid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||
1127 c_attr.ca_fileid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {
1128 err = 0;
1129 goto exit;
1130 }
1131
1132 /* Hide the private journal files */
1133 if (hfsmp->jnl &&
1134 ((c_attr.ca_fileid == hfsmp->hfs_jnlfileid) ||
1135 (c_attr.ca_fileid == hfsmp->hfs_jnlinfoblkid))) {
1136 err = 0;
1137 goto exit;
1138 }
1139
1140 if (returnAttrList->commonattr & ATTR_CMN_NAME) {
1141 err = cat_convertkey(hfsmp, key, rec, &c_desc);
1142 if (err) {
1143 /* This means that we probably had a CNID error */
1144 goto exit;
1145 }
1146 } else {
1147 c_desc.cd_cnid = c_attr.ca_fileid;
1148 if ((hfsmp->hfs_flags & HFS_STANDARD) == 0)
1149 c_desc.cd_parentcnid = key->hfsPlus.parentID;
1150 #if CONFIG_HFS_STD
1151 else
1152 c_desc.cd_parentcnid = key->hfs.parentID;
1153 #endif
1154
1155 }
1156
1157 attrblk.ab_attrlist = returnAttrList;
1158 attrblk.ab_attrbufpp = &rovingAttributesBuffer;
1159 attrblk.ab_varbufpp = &rovingVariableBuffer;
1160 attrblk.ab_flags = 0;
1161 attrblk.ab_blocksize = 0;
1162 attrblk.ab_context = vfs_context_current();
1163
1164 hfs_packattrblk(&attrblk, hfsmp, NULL, &c_desc, &c_attr, &datafork, &rsrcfork, vfs_context_current());
1165
1166 packedBufferSize = (char*)rovingVariableBuffer - (char*)attributesBuffer;
1167
1168 if ( packedBufferSize > uio_resid(a_uio) )
1169 return( errSearchBufferFull );
1170
1171 (* nummatches)++;
1172
1173 *((u_int32_t *)attributesBuffer) = packedBufferSize; /* Store length of fixed + var block */
1174
1175 err = uiomove( (caddr_t)attributesBuffer, packedBufferSize, a_uio );
1176 exit:
1177 cat_releasedesc(&c_desc);
1178
1179 return( err );
1180 }
1181
1182
1183 static int
1184 UnpackSearchAttributeBlock( struct hfsmount *hfsmp, struct attrlist *alist,
1185 searchinfospec_t *searchInfo, void *attributeBuffer, int firstblock)
1186 {
1187 attrgroup_t a;
1188 u_int32_t bufferSize;
1189 boolean_t is_64_bit;
1190
1191 hfs_assert(searchInfo != NULL);
1192
1193 is_64_bit = proc_is64bit(current_proc());
1194
1195 bufferSize = *((u_int32_t *)attributeBuffer);
1196 if (bufferSize == 0)
1197 return (EINVAL); /* XXX -DJB is a buffer size of zero ever valid for searchfs? */
1198
1199 attributeBuffer = (u_int32_t *)attributeBuffer + 1; /* advance past the size */
1200
1201 /*
1202 * UnPack common attributes
1203 */
1204 a = alist->commonattr;
1205 if ( a != 0 ) {
1206 if ( a & ATTR_CMN_NAME ) {
1207 if (firstblock) {
1208 /* Only use the attrreference_t for the first searchparams */
1209 char *s;
1210 u_int32_t len;
1211
1212 s = (char*) attributeBuffer + ((attrreference_t *) attributeBuffer)->attr_dataoffset;
1213 len = ((attrreference_t *) attributeBuffer)->attr_length;
1214
1215 if (len > sizeof(searchInfo->name))
1216 return (EINVAL);
1217
1218
1219 if ((hfsmp->hfs_flags & HFS_STANDARD) == 0) {
1220 size_t ucslen;
1221 /* Convert name to Unicode to match HFS Plus B-Tree names */
1222
1223 if (len > 0) {
1224 if (utf8_decodestr((u_int8_t *)s, len-1, (UniChar*)searchInfo->name, &ucslen,
1225 sizeof(searchInfo->name), ':', UTF_DECOMPOSED | UTF_ESCAPE_ILLEGAL))
1226 return (EINVAL);
1227
1228 searchInfo->nameLength = ucslen / sizeof(UniChar);
1229 } else {
1230 searchInfo->nameLength = 0;
1231 }
1232 }
1233 #if CONFIG_HFS_STD
1234 else {
1235 /* Convert name to pascal string to match HFS (Standard) B-Tree names */
1236
1237 if (len > 0) {
1238 if (utf8_to_hfs(HFSTOVCB(hfsmp), len-1, (u_char *)s, (u_char*)searchInfo->name) != 0)
1239 return (EINVAL);
1240
1241 searchInfo->nameLength = searchInfo->name[0];
1242 } else {
1243 searchInfo->name[0] = searchInfo->nameLength = 0;
1244 }
1245 }
1246 #endif
1247 }
1248 attributeBuffer = (attrreference_t*) attributeBuffer +1;
1249 }
1250 if ( a & ATTR_CMN_OBJID ) {
1251 searchInfo->nodeID = ((fsobj_id_t *) attributeBuffer)->fid_objno; /* ignore fid_generation */
1252 attributeBuffer = (fsobj_id_t *)attributeBuffer + 1;
1253 }
1254 if ( a & ATTR_CMN_PAROBJID ) {
1255 searchInfo->parentDirID = ((fsobj_id_t *) attributeBuffer)->fid_objno; /* ignore fid_generation */
1256 attributeBuffer = (fsobj_id_t *)attributeBuffer + 1;
1257 }
1258
1259 if ( a & ATTR_CMN_CRTIME ) {
1260 if (is_64_bit) {
1261 struct user64_timespec tmp;
1262 tmp = *((struct user64_timespec *)attributeBuffer);
1263 searchInfo->creationDate.tv_sec = (time_t)tmp.tv_sec;
1264 searchInfo->creationDate.tv_nsec = tmp.tv_nsec;
1265 attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;
1266 }
1267 else {
1268 struct user32_timespec tmp;
1269 tmp = *((struct user32_timespec *)attributeBuffer);
1270 searchInfo->creationDate.tv_sec = (time_t)tmp.tv_sec;
1271 searchInfo->creationDate.tv_nsec = tmp.tv_nsec;
1272 attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;
1273 }
1274 }
1275 if ( a & ATTR_CMN_MODTIME ) {
1276 if (is_64_bit) {
1277 struct user64_timespec tmp;
1278 tmp = *((struct user64_timespec *)attributeBuffer);
1279 searchInfo->modificationDate.tv_sec = (time_t)tmp.tv_sec;
1280 searchInfo->modificationDate.tv_nsec = tmp.tv_nsec;
1281 attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;
1282 }
1283 else {
1284 struct user32_timespec tmp;
1285 tmp = *((struct user32_timespec *)attributeBuffer);
1286 searchInfo->modificationDate.tv_sec = (time_t)tmp.tv_sec;
1287 searchInfo->modificationDate.tv_nsec = tmp.tv_nsec;
1288 attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;
1289 }
1290 }
1291 if ( a & ATTR_CMN_CHGTIME ) {
1292 if (is_64_bit) {
1293 struct user64_timespec tmp;
1294 tmp = *((struct user64_timespec *)attributeBuffer);
1295 searchInfo->changeDate.tv_sec = (time_t)tmp.tv_sec;
1296 searchInfo->changeDate.tv_nsec = tmp.tv_nsec;
1297 attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;
1298 }
1299 else {
1300 struct user32_timespec tmp;
1301 tmp = *((struct user32_timespec *)attributeBuffer);
1302 searchInfo->changeDate.tv_sec = (time_t)tmp.tv_sec;
1303 searchInfo->changeDate.tv_nsec = tmp.tv_nsec;
1304 attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;
1305 }
1306 }
1307 if ( a & ATTR_CMN_ACCTIME ) {
1308 if (is_64_bit) {
1309 struct user64_timespec tmp;
1310 tmp = *((struct user64_timespec *)attributeBuffer);
1311 searchInfo->accessDate.tv_sec = (time_t)tmp.tv_sec;
1312 searchInfo->accessDate.tv_nsec = tmp.tv_nsec;
1313 attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;
1314 }
1315 else {
1316 struct user32_timespec tmp;
1317 tmp = *((struct user32_timespec *)attributeBuffer);
1318 searchInfo->accessDate.tv_sec = (time_t)tmp.tv_sec;
1319 searchInfo->accessDate.tv_nsec = tmp.tv_nsec;
1320 attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;
1321 }
1322 }
1323 if ( a & ATTR_CMN_BKUPTIME ) {
1324 if (is_64_bit) {
1325 struct user64_timespec tmp;
1326 tmp = *((struct user64_timespec *)attributeBuffer);
1327 searchInfo->lastBackupDate.tv_sec = (time_t)tmp.tv_sec;
1328 searchInfo->lastBackupDate.tv_nsec = tmp.tv_nsec;
1329 attributeBuffer = (struct user64_timespec *)attributeBuffer + 1;
1330 }
1331 else {
1332 struct user32_timespec tmp;
1333 tmp = *((struct user32_timespec *)attributeBuffer);
1334 searchInfo->lastBackupDate.tv_sec = (time_t)tmp.tv_sec;
1335 searchInfo->lastBackupDate.tv_nsec = tmp.tv_nsec;
1336 attributeBuffer = (struct user32_timespec *)attributeBuffer + 1;
1337 }
1338 }
1339 if ( a & ATTR_CMN_FNDRINFO ) {
1340 bcopy( attributeBuffer, searchInfo->finderInfo, sizeof(searchInfo->finderInfo) );
1341 attributeBuffer = (u_int8_t *)attributeBuffer + 32;
1342 }
1343 if ( a & ATTR_CMN_OWNERID ) {
1344 searchInfo->uid = *((uid_t *)attributeBuffer);
1345 attributeBuffer = (uid_t *)attributeBuffer + 1;
1346 }
1347 if ( a & ATTR_CMN_GRPID ) {
1348 searchInfo->gid = *((gid_t *)attributeBuffer);
1349 attributeBuffer = (gid_t *)attributeBuffer + 1;
1350 }
1351 if ( a & ATTR_CMN_ACCESSMASK ) {
1352 searchInfo->mask = *((mode_t *)attributeBuffer);
1353 attributeBuffer = (mode_t *)attributeBuffer + 1;
1354 }
1355 if ( a & ATTR_CMN_FILEID ) {
1356 searchInfo->nodeID = (u_int32_t)*((u_int64_t *) attributeBuffer);
1357 attributeBuffer = (u_int64_t *)attributeBuffer + 1;
1358 }
1359 if ( a & ATTR_CMN_PARENTID ) {
1360 searchInfo->parentDirID = (u_int32_t)*((u_int64_t *) attributeBuffer);
1361 attributeBuffer = (u_int64_t *)attributeBuffer + 1;
1362 }
1363 }
1364
1365 a = alist->dirattr;
1366 if ( a != 0 ) {
1367 if ( a & ATTR_DIR_ENTRYCOUNT ) {
1368 searchInfo->d.numFiles = *((u_int32_t *)attributeBuffer);
1369 attributeBuffer = (u_int32_t *)attributeBuffer + 1;
1370 }
1371 }
1372
1373 a = alist->fileattr;
1374 if ( a != 0 ) {
1375 if ( a & ATTR_FILE_DATALENGTH ) {
1376 searchInfo->f.dataLogicalLength = *((off_t *)attributeBuffer);
1377 attributeBuffer = (off_t *)attributeBuffer + 1;
1378 }
1379 if ( a & ATTR_FILE_DATAALLOCSIZE ) {
1380 searchInfo->f.dataPhysicalLength = *((off_t *)attributeBuffer);
1381 attributeBuffer = (off_t *)attributeBuffer + 1;
1382 }
1383 if ( a & ATTR_FILE_RSRCLENGTH ) {
1384 searchInfo->f.resourceLogicalLength = *((off_t *)attributeBuffer);
1385 attributeBuffer = (off_t *)attributeBuffer + 1;
1386 }
1387 if ( a & ATTR_FILE_RSRCALLOCSIZE ) {
1388 searchInfo->f.resourcePhysicalLength = *((off_t *)attributeBuffer);
1389 attributeBuffer = (off_t *)attributeBuffer + 1;
1390 }
1391 }
1392
1393 return (0);
1394 }
1395 #endif /* CONFIG_SEARCHFS */
mirror of hfs