![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_search.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / hfs|
Return to hfs_search.c CVS log | Up to [Apple XNU] / XNU / bsd / hfs |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* @(#)hfs_search.c
23: *
24: * (c) 1997-2000 Apple Computer, Inc. All Rights Reserved
25: *
26: *
27: * MODIFICATION HISTORY:
28: * 04-May-1999 Don Brady Split off from hfs_vnodeops.c.
29: */
30:
31: #include <sys/param.h>
32: #include <sys/systm.h>
33: #include <sys/kernel.h>
34: #include <sys/file.h>
35: #include <sys/buf.h>
36: #include <sys/proc.h>
37: #include <sys/conf.h>
38: #include <mach/machine/vm_types.h>
39: #include <sys/vnode.h>
40: #include <sys/malloc.h>
41: #include <sys/signalvar.h>
42: #include <sys/attr.h>
43:
44: #include "hfs.h"
45: #include "hfs_dbg.h"
46: #include "hfscommon/headers/FileMgrInternal.h"
47: #include "hfscommon/headers/CatalogPrivate.h"
48: #include "hfscommon/headers/HFSUnicodeWrappers.h"
49:
50:
51: /* Private description used in hfs_search */
52: struct SearchState {
53: long searchBits;
54: BTreeIterator btreeIterator;
55: short vRefNum; /* Volume reference of volume being searched */
56: char isHFSPlus; /* True if volume is HFS */
57: char pad1[3]; /* long align the structure */
58: };
59: typedef struct SearchState SearchState;
60:
61:
62: static int UnpackSearchAttributeBlock(struct vnode *vp, struct attrlist *alist, searchinfospec_t *searchInfo, void *attributeBuffer);
63:
64: Boolean CheckCriteria( ExtendedVCB *vcb, const SearchState *searchState, u_long searchBits, struct attrlist *attrList, CatalogRecord *catalogRecord, CatalogKey *key, searchinfospec_t *searchInfo1, searchinfospec_t *searchInfo2 );
65:
66: static int InsertMatch( struct vnode *vp, struct uio *a_uio, CatalogRecord *catalogRecord, CatalogKey *key, struct attrlist *returnAttrList, void *attributesBuffer, void *variableBuffer, u_long bufferSize, u_long * nummatches );
67:
68: static Boolean CompareRange(u_long val, u_long low, u_long high);
69: static Boolean CompareWideRange(u_int64_t val, u_int64_t low, u_int64_t high);
70:
71: static Boolean CompareRange( u_long val, u_long low, u_long high )
72: {
73: return( (val >= low) && (val <= high) );
74: }
75:
76: static Boolean CompareWideRange( u_int64_t val, u_int64_t low, u_int64_t high )
77: {
78: return( (val >= low) && (val <= high) );
79: }
80: //#define CompareRange(val, low, high) ((val >= low) && (val <= high))
81:
82:
83:
84: /************************************************************************/
85: /* Entry for searchfs() */
86: /************************************************************************/
87:
88: #define errSearchBufferFull 101 /* Internal search errors */
89: /*
90: #
91: #% searchfs vp L L L
92: #
93: vop_searchfs {
94: IN struct vnode *vp;
95: IN off_t length;
96: IN int flags;
97: IN struct ucred *cred;
98: IN struct proc *p;
99: };
100: */
101:
102: int
103: hfs_search( ap )
104: struct vop_searchfs_args *ap; /*
105: struct vnodeop_desc *a_desc;
106: struct vnode *a_vp;
107: void *a_searchparams1;
108: void *a_searchparams2;
109: struct attrlist *a_searchattrs;
110: u_long a_maxmatches;
111: struct timeval *a_timelimit;
112: struct attrlist *a_returnattrs;
113: u_long *a_nummatches;
114: u_long a_scriptcode;
115: u_long a_options;
116: struct uio *a_uio;
117: struct searchstate *a_searchstate;
118: */
119: {
120: CatalogRecord catalogRecord;
121: BTreeKey *key;
122: FSBufferDescriptor btRecord;
123: FCB* catalogFCB;
124: SearchState *searchState;
125: searchinfospec_t searchInfo1;
126: searchinfospec_t searchInfo2;
127: void *attributesBuffer;
128: void *variableBuffer;
129: short recordSize;
130: short operation;
131: u_long fixedBlockSize;
132: u_long eachReturnBufferSize;
133: struct proc *p = current_proc();
134: u_long nodesToCheck = 30; /* After we search 30 nodes we must give up time */
135: u_long lastNodeNum = 0XFFFFFFFF;
136: ExtendedVCB *vcb = VTOVCB(ap->a_vp);
137: int err = E_NONE;
138:
139: /* XXX Parameter check a_searchattrs? */
140:
141: *(ap->a_nummatches) = 0;
142:
143: if ( ap->a_options & ~SRCHFS_VALIDOPTIONSMASK )
144: return( EINVAL );
145:
146: if (ap->a_uio->uio_resid <= 0)
147: return (EINVAL);
148:
149: searchState = (SearchState *)ap->a_searchstate;
150:
151: /*
152: * Check if this is the first time we are being called.
153: * If it is, allocate SearchState and we'll move it to the users space on exit
154: */
155: if ( ap->a_options & SRCHFS_START ) {
156: bzero( (caddr_t)searchState, sizeof(SearchState) );
157: searchState->isHFSPlus = ( vcb->vcbSigWord == kHFSPlusSigWord );
158: operation = kBTreeFirstRecord;
159: ap->a_options &= ~SRCHFS_START;
160: } else {
161: operation = kBTreeCurrentRecord;
162: }
163:
164: /* UnPack the search boundries, searchInfo1, searchInfo2 */
165: err = UnpackSearchAttributeBlock( ap->a_vp, ap->a_searchattrs, &searchInfo1, ap->a_searchparams1 );
166: if (err) return err;
167: err = UnpackSearchAttributeBlock( ap->a_vp, ap->a_searchattrs, &searchInfo2, ap->a_searchparams2 );
168: if (err) return err;
169:
170: btRecord.itemCount = 1;
171: btRecord.itemSize = sizeof( catalogRecord );
172: btRecord.bufferAddress = &catalogRecord;
173: catalogFCB = VTOFCB( vcb->catalogRefNum );
174: key = (BTreeKey*) &(searchState->btreeIterator.key);
175: fixedBlockSize = sizeof(u_long) + AttributeBlockSize( ap->a_returnattrs ); /* u_long for length longword */
176: eachReturnBufferSize = fixedBlockSize;
177:
178: if ( ap->a_returnattrs->commonattr & ATTR_CMN_NAME ) /* XXX should be more robust! */
179: eachReturnBufferSize += NAME_MAX + 1;
180:
181: MALLOC( attributesBuffer, void *, eachReturnBufferSize, M_TEMP, M_WAITOK );
182: variableBuffer = (void*)((char*) attributesBuffer + fixedBlockSize);
183:
184: /* Lock catalog b-tree */
185: err = hfs_metafilelocking( VTOHFS(ap->a_vp), kHFSCatalogFileID, LK_SHARED, p );
186: if ( err != E_NONE ) {
187: goto ExitThisRoutine;
188: };
189:
190: /*
191: * Iterate over all the catalog btree records
192: */
193:
194: err = BTIterateRecord( catalogFCB, operation, &(searchState->btreeIterator), &btRecord, &recordSize );
195:
196: while( err == E_NONE ) {
197: if ( CheckCriteria( vcb, searchState, ap->a_options, ap->a_searchattrs, &catalogRecord,
198: (CatalogKey *)key, &searchInfo1, &searchInfo2 ) == true ) {
199: err = InsertMatch(ap->a_vp, ap->a_uio, &catalogRecord, (CatalogKey *)key,
200: ap->a_returnattrs, attributesBuffer, variableBuffer,
201: eachReturnBufferSize, ap->a_nummatches);
202: if ( err != E_NONE )
203: break;
204: }
205:
206: err = BTIterateRecord( catalogFCB, kBTreeNextRecord, &(searchState->btreeIterator), &btRecord, &recordSize );
207:
208: if ( *(ap->a_nummatches) >= ap->a_maxmatches )
209: break;
210:
211: if ( searchState->btreeIterator.hint.nodeNum != lastNodeNum ) {
212: lastNodeNum = searchState->btreeIterator.hint.nodeNum;
213: if ( --nodesToCheck == 0 )
214: break; /* We must leave the kernel to give up time */
215: }
216: }
217:
218: /* Unlock catalog b-tree */
219: (void) hfs_metafilelocking( VTOHFS(ap->a_vp), kHFSCatalogFileID, LK_RELEASE, p );
220:
221:
222: if ( err == E_NONE ) {
223: err = EAGAIN; /* signal to the user to call searchfs again */
224: } else if ( err == errSearchBufferFull ) {
225: if ( *(ap->a_nummatches) > 0 )
226: err = EAGAIN;
227: else
228: err = ENOBUFS;
229: } else if ( err == btNotFound ) {
230: err = E_NONE; /* the entire disk has been searched */
231: }
232:
233: ExitThisRoutine:
234: FREE( attributesBuffer, M_TEMP );
235:
236: return( err );
237: }
238:
239:
240: static Boolean
241: CompareMasked(const UInt32 *thisValue, const UInt32 *compareData,
242: const UInt32 *compareMask, UInt32 count)
243: {
244: Boolean matched;
245: UInt32 i;
246:
247: matched = true; /* Assume it will all match */
248:
249: for (i=0; i<count; i++) {
250: if (((*thisValue++ ^ *compareData++) & *compareMask++) != 0) {
251: matched = false;
252: break;
253: }
254: }
255:
256: return matched;
257: }
258:
259:
260: static Boolean
261: ComparePartialUnicodeName (register ConstUniCharArrayPtr str, register ItemCount s_len,
262: register ConstUniCharArrayPtr find, register ItemCount f_len )
263: {
264: if (f_len == 0 || s_len == 0)
265: return FALSE;
266:
267: do {
268: if (s_len-- < f_len)
269: return FALSE;
270: } while (FastUnicodeCompare(str++, f_len, find, f_len) != 0);
271:
272: return TRUE;
273: }
274:
275:
276: static Boolean
277: ComparePartialPascalName ( register ConstStr31Param str, register ConstStr31Param find )
278: {
279: register u_char s_len = str[0];
280: register u_char f_len = find[0];
281: register u_char *tsp;
282: Str31 tmpstr;
283:
284: if (f_len == 0 || s_len == 0)
285: return FALSE;
286:
287: bcopy(str, tmpstr, s_len + 1);
288: tsp = &tmpstr[0];
289:
290: while (s_len-- >= f_len) {
291: *tsp = f_len;
292:
293: if (FastRelString(tsp++, find) == 0)
294: return TRUE;
295: }
296:
297: return FALSE;
298: }
299:
300:
301: Boolean
302: CheckCriteria( ExtendedVCB *vcb, const SearchState *searchState, u_long searchBits,
303: struct attrlist *attrList, CatalogRecord *catalogRecord, CatalogKey *key,
304: searchinfospec_t *searchInfo1, searchinfospec_t *searchInfo2 )
305: {
306: Boolean matched;
307: CatalogNodeData catData;
308: attrgroup_t searchAttributes;
309:
310: switch ( catalogRecord->recordType ) {
311: case kHFSFolderRecord:
312: case kHFSPlusFolderRecord:
313: if ( (searchBits & SRCHFS_MATCHDIRS) == 0 ) { /* If we are NOT searching folders */
314: matched = false;
315: goto TestDone;
316: }
317: break;
318:
319: case kHFSFileRecord:
320: case kHFSPlusFileRecord:
321: if ( (searchBits & SRCHFS_MATCHFILES) == 0 ) { /* If we are NOT searching files */
322: matched = false;
323: goto TestDone;
324: }
325: break;
326:
327: default: /* Never match a thread record or any other type. */
328: return( false ); /* Not a file or folder record, so can't search it */
329: }
330:
331: /* Change the catalog record data into a single common form */
332: matched = true; /* Assume we got a match */
333: catData.cnd_type = 0; /* mark this record as not in use */
334: CopyCatalogNodeData( vcb, catalogRecord, &catData );
335:
336: /* First, attempt to match the name -- either partial or complete */
337: if ( attrList->commonattr & ATTR_CMN_NAME ) {
338: if ( searchState->isHFSPlus ) {
339: /* Check for partial/full HFS Plus name match */
340:
341: if ( searchBits & SRCHFS_MATCHPARTIALNAMES ) {
342: matched = ComparePartialUnicodeName(key->hfsPlus.nodeName.unicode,
343: key->hfsPlus.nodeName.length,
344: (UniChar*)searchInfo1->name,
345: searchInfo1->nameLength );
346: } else /* full HFS Plus name match */ {
347: matched = (FastUnicodeCompare(key->hfsPlus.nodeName.unicode,
348: key->hfsPlus.nodeName.length,
349: (UniChar*)searchInfo1->name,
350: searchInfo1->nameLength ) == 0);
351: }
352: } else {
353: /* Check for partial/full HFS name match */
354:
355: if ( searchBits & SRCHFS_MATCHPARTIALNAMES )
356: matched = ComparePartialPascalName(key->hfs.nodeName, (u_char*)searchInfo1->name);
357: else /* full HFS name match */
358: matched = (FastRelString(key->hfs.nodeName, (u_char*)searchInfo1->name) == 0);
359: }
360:
361: if ( matched == false || (searchBits & ~SRCHFS_MATCHPARTIALNAMES) == 0 )
362: goto TestDone; /* no match, or nothing more to compare */
363: }
364:
365:
366: /* Now that we have a record worth searching, see if it matches the search attributes */
367: if ( (catData.cnd_type == kCatalogFileNode) && ((attrList->fileattr & ATTR_FILE_VALIDMASK) != 0) )
368: {
369: searchAttributes = attrList->fileattr;
370:
371: /* File logical length (data fork) */
372: if ( searchAttributes & ATTR_FILE_DATALENGTH ) {
373: matched = CompareWideRange(
374: catData.cnd_datafork.logicalSize,
375: searchInfo1->f.dataLogicalLength,
376: searchInfo2->f.dataLogicalLength);
377: if (matched == false) goto TestDone;
378: }
379:
380: /* File physical length (data fork) */
381: if ( searchAttributes & ATTR_FILE_DATAALLOCSIZE ) {
382: matched = CompareWideRange(
383: catData.cnd_datafork.totalBlocks * vcb->blockSize,
384: searchInfo1->f.dataPhysicalLength,
385: searchInfo2->f.dataPhysicalLength);
386: if (matched == false) goto TestDone;
387: }
388:
389: /* File logical length (resource fork) */
390: if ( searchAttributes & ATTR_FILE_RSRCLENGTH ) {
391: matched = CompareWideRange(
392: catData.cnd_rsrcfork.logicalSize,
393: searchInfo1->f.resourceLogicalLength,
394: searchInfo2->f.resourceLogicalLength);
395: if (matched == false) goto TestDone;
396: }
397:
398: /* File physical length (resource fork) */
399: if ( searchAttributes & ATTR_FILE_RSRCALLOCSIZE ) {
400: matched = CompareWideRange(
401: catData.cnd_rsrcfork.totalBlocks * vcb->blockSize,
402: searchInfo1->f.resourcePhysicalLength,
403: searchInfo2->f.resourcePhysicalLength);
404: if (matched == false) goto TestDone;
405: }
406:
407: /* File logical length (resource + data fork) */
408: if ( searchAttributes & ATTR_FILE_TOTALSIZE ) {
409: matched = CompareWideRange(
410: catData.cnd_rsrcfork.logicalSize +
411: catData.cnd_datafork.logicalSize,
412: searchInfo1->f.resourceLogicalLength + searchInfo1->f.dataLogicalLength,
413: searchInfo2->f.resourceLogicalLength + searchInfo2->f.dataLogicalLength);
414: if (matched == false) goto TestDone;
415: }
416:
417: /* File physical length (resource + data fork) */
418: if ( searchAttributes & ATTR_FILE_TOTALSIZE ) {
419: matched = CompareWideRange(
420: (catData.cnd_rsrcfork.totalBlocks +
421: catData.cnd_datafork.totalBlocks) * vcb->blockSize,
422: searchInfo1->f.resourcePhysicalLength + searchInfo1->f.dataPhysicalLength,
423: searchInfo2->f.resourcePhysicalLength + searchInfo2->f.dataPhysicalLength );
424: if (matched == false) goto TestDone;
425: }
426: }
427: /*
428: * Check the directory attributes
429: */
430: else if ( (catData.cnd_type == kCatalogFolderNode) && ((attrList->dirattr & ATTR_DIR_VALIDMASK) != 0) )
431: {
432: searchAttributes = attrList->dirattr;
433:
434: /* Directory valence */
435: if ( searchAttributes & ATTR_DIR_ENTRYCOUNT ) {
436: matched = CompareRange(catData.cnd_valence, searchInfo1->d.numFiles, searchInfo2->d.numFiles );
437: if (matched == false) goto TestDone;
438: }
439: }
440:
441: /*
442: * Check the common attributes
443: */
444: searchAttributes = attrList->commonattr;
445: if ( (searchAttributes & ATTR_CMN_VALIDMASK) != 0 ) {
446:
447: /* Parent ID */
448: if ( searchAttributes & ATTR_CMN_PAROBJID ) {
449: HFSCatalogNodeID parentID;
450:
451: if (searchState->isHFSPlus)
452: parentID = key->hfsPlus.parentID;
453: else
454: parentID = key->hfs.parentID;
455:
456: matched = CompareRange( parentID, searchInfo1->parentDirID, searchInfo2->parentDirID );
457: if (matched == false) goto TestDone;
458: }
459:
460: /* Finder Info & Extended Finder Info where extFinderInfo is last 32 bytes */
461: if ( searchAttributes & ATTR_CMN_FNDRINFO ) {
462: UInt32 *thisValue;
463: thisValue = (UInt32 *) &catData.cnd_finderInfo;
464:
465: /*
466: * Note: ioFlFndrInfo and ioDrUsrWds have the same offset in search info, so
467: * no need to test the object type here.
468: */
469: matched = CompareMasked( thisValue, (UInt32 *) &searchInfo1->finderInfo, (UInt32 *) &searchInfo2->finderInfo, 8 ); /* 8 * UInt32 */
470: if (matched == false) goto TestDone;
471: }
472:
473: /* Create date */
474: if ( searchAttributes & ATTR_CMN_CRTIME ) {
475: matched = CompareRange(to_bsd_time(catData.cnd_createDate),
476: searchInfo1->creationDate.tv_sec, searchInfo2->creationDate.tv_sec );
477: if (matched == false) goto TestDone;
478: }
479:
480: /* Mod date */
481: if ( searchAttributes & ATTR_CMN_MODTIME ) {
482: matched = CompareRange(to_bsd_time(catData.cnd_contentModDate),
483: searchInfo1->modificationDate.tv_sec, searchInfo2->modificationDate.tv_sec );
484: if (matched == false) goto TestDone;
485: }
486:
487: /* Backup date */
488: if ( searchAttributes & ATTR_CMN_BKUPTIME ) {
489: matched = CompareRange(to_bsd_time(catData.cnd_backupDate),
490: searchInfo1->lastBackupDate.tv_sec, searchInfo2->lastBackupDate.tv_sec );
491: if (matched == false) goto TestDone;
492: }
493:
494: }
495:
496:
497: TestDone:
498: /*
499: * Finally, determine whether we need to negate the sense of the match
500: * (i.e. find all objects that DON'T match).
501: */
502: if ( searchBits & SRCHFS_NEGATEPARAMS )
503: matched = !matched;
504:
505: return( matched );
506: }
507:
508:
509: /*
510: * Adds another record to the packed array for output
511: */
512: static int
513: InsertMatch( struct vnode *root_vp, struct uio *a_uio, CatalogRecord *catalogRecord,
514: CatalogKey *key, struct attrlist *returnAttrList, void *attributesBuffer,
515: void *variableBuffer, u_long bufferSize, u_long * nummatches )
516: {
517: int err;
518: void *rovingAttributesBuffer;
519: void *rovingVariableBuffer;
520: struct hfsCatalogInfo catalogInfo;
521: u_long packedBufferSize;
522: ExtendedVCB *vcb = VTOVCB(root_vp);
523: Boolean isHFSPlus = vcb->vcbSigWord == kHFSPlusSigWord;
524: u_long privateDir = VTOHFS(root_vp)->hfs_private_metadata_dir;
525:
526: rovingAttributesBuffer = (char*)attributesBuffer + sizeof(u_long); /* Reserve space for length field */
527: rovingVariableBuffer = variableBuffer;
528:
529: CopyCatalogNodeData( vcb, catalogRecord, &catalogInfo.nodeData );
530:
531: catalogInfo.spec.parID = isHFSPlus ? key->hfsPlus.parentID : key->hfs.parentID;
532:
533: /* hide open files that have been deleted */
534: if (catalogInfo.spec.parID == privateDir)
535: return (0);
536:
537: /* hide our private meta data directory */
538: if (catalogInfo.nodeData.cnd_nodeID == privateDir)
539: return (0);
540:
541: if ( returnAttrList->commonattr & ATTR_CMN_NAME )
542: {
543: ByteCount actualDstLen;
544:
545: /* Return result in UTF-8 */
546: if ( isHFSPlus ) {
547: err = ConvertUnicodeToUTF8( key->hfsPlus.nodeName.length * sizeof(UniChar),
548: key->hfsPlus.nodeName.unicode,
549: sizeof(catalogInfo.spec.name),
550: &actualDstLen,
551: catalogInfo.spec.name);
552: } else {
553: err = hfs_to_utf8(vcb, key->hfs.nodeName,
554: sizeof(catalogInfo.spec.name),
555: &actualDstLen, catalogInfo.spec.name);
556: }
557: }
558:
559: PackCatalogInfoAttributeBlock( returnAttrList,root_vp, &catalogInfo, &rovingAttributesBuffer, &rovingVariableBuffer );
560:
561: packedBufferSize = (char*)rovingVariableBuffer - (char*)attributesBuffer;
562:
563: if ( packedBufferSize > a_uio->uio_resid )
564: return( errSearchBufferFull );
565:
566: (* nummatches)++;
567:
568: *((u_long *)attributesBuffer) = packedBufferSize; /* Store length of fixed + var block */
569:
570: err = uiomove( (caddr_t)attributesBuffer, packedBufferSize, a_uio ); /* XXX should be packedBufferSize */
571:
572: return( err );
573: }
574:
575:
576: static int
577: UnpackSearchAttributeBlock( struct vnode *vp, struct attrlist *alist, searchinfospec_t *searchInfo, void *attributeBuffer )
578: {
579: attrgroup_t a;
580: u_long bufferSize;
581:
582: DBG_ASSERT(searchInfo != NULL);
583:
584: bufferSize = *((u_long *)attributeBuffer);
585: if (bufferSize == 0)
586: return (EINVAL); /* XXX -DJB is a buffer size of zero ever valid for searchfs? */
587:
588: ++((u_long *)attributeBuffer); /* advance past the size */
589:
590: /*
591: * UnPack common attributes
592: */
593: a = alist->commonattr;
594: if ( a != 0 ) {
595: if ( a & ATTR_CMN_NAME ) {
596: char *s = (char*) attributeBuffer + ((attrreference_t *) attributeBuffer)->attr_dataoffset;
597: size_t len = ((attrreference_t *) attributeBuffer)->attr_length;
598:
599: if (len > sizeof(searchInfo->name))
600: return (EINVAL);
601:
602: if (VTOVCB(vp)->vcbSigWord == kHFSPlusSigWord) {
603: ByteCount actualDstLen;
604: /* Convert name to Unicode to match HFS Plus B-Tree names */
605:
606: if (len > 0) {
607: if (ConvertUTF8ToUnicode(len-1, s, sizeof(searchInfo->name),
608: &actualDstLen, (UniChar*)searchInfo->name) != 0)
609: return (EINVAL);
610:
611:
612: searchInfo->nameLength = actualDstLen / sizeof(UniChar);
613: } else {
614: searchInfo->nameLength = 0;
615: }
616: ++((attrreference_t *)attributeBuffer);
617:
618: } else {
619: /* Convert name to pascal string to match HFS B-Tree names */
620:
621: if (len > 0) {
622: if (utf8_to_hfs(VTOVCB(vp), len-1, s, (u_char*)searchInfo->name) != 0)
623: return (EINVAL);
624:
625: searchInfo->nameLength = searchInfo->name[0];
626: } else {
627: searchInfo->name[0] = searchInfo->nameLength = 0;
628: }
629: ++((attrreference_t *)attributeBuffer);
630: }
631: }
632: if ( a & ATTR_CMN_PAROBJID ) {
633: searchInfo->parentDirID = ((fsobj_id_t *) attributeBuffer)->fid_objno; /* ignore fid_generation */
634: ++((fsobj_id_t *)attributeBuffer);
635: }
636: if ( a & ATTR_CMN_CRTIME ) {
637: searchInfo->creationDate = *((struct timespec *)attributeBuffer);
638: ++((struct timespec *)attributeBuffer);
639: }
640: if ( a & ATTR_CMN_MODTIME ) {
641: searchInfo->modificationDate = *((struct timespec *)attributeBuffer);
642: ++((struct timespec *)attributeBuffer);
643: }
644: if ( a & ATTR_CMN_BKUPTIME ) {
645: searchInfo->lastBackupDate = *((struct timespec *)attributeBuffer);
646: ++((struct timespec *)attributeBuffer);
647: }
648: if ( a & ATTR_CMN_FNDRINFO ) {
649: bcopy( attributeBuffer, searchInfo->finderInfo, sizeof(u_long) * 8 );
650: attributeBuffer += (sizeof(u_long) * 8 );
651: }
652: }
653:
654: a = alist->dirattr;
655: if ( a != 0 ) {
656: if ( a & ATTR_DIR_ENTRYCOUNT ) {
657: searchInfo->d.numFiles = *((u_long *)attributeBuffer);
658: ++((u_long *)attributeBuffer);
659: }
660: }
661:
662: a = alist->fileattr;
663: if ( a != 0 ) {
664: if ( a & ATTR_FILE_DATALENGTH ) {
665: searchInfo->f.dataLogicalLength = *((off_t *)attributeBuffer);
666: ++((off_t *)attributeBuffer);
667: }
668: if ( a & ATTR_FILE_DATAALLOCSIZE ) {
669: searchInfo->f.dataPhysicalLength = *((off_t *)attributeBuffer);
670: ++((off_t *)attributeBuffer);
671: }
672: if ( a & ATTR_FILE_RSRCLENGTH ) {
673: searchInfo->f.resourceLogicalLength = *((off_t *)attributeBuffer);
674: ++((off_t *)attributeBuffer);
675: }
676: if ( a & ATTR_FILE_RSRCALLOCSIZE ) {
677: searchInfo->f.resourcePhysicalLength = *((off_t *)attributeBuffer);
678: ++((off_t *)attributeBuffer);
679: }
680: }
681:
682: return (0);
683: }
684:
685:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.