Mercurial > projects > dstep

comparison dstep/coreservices/carboncore/Files.d @ 11:07194b026fa4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added bindings to a couple of frameworks, new license + some other things
author Jacob Carlborg <doob@me.com>
date Sat, 01 Aug 2009 15:03:28 +0200
parents
children
comparison
equal deleted inserted replaced
10:27e00625790b 11:07194b026fa4
1 /**
2 * Copyright: Copyright (c) 2009 Jacob Carlborg.
3 * Authors: Jacob Carlborg
4 * Version: Initial created: Jul 21, 2009
5 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0)
6 */
7 module dstep.coreservices.carboncore.Files;
8
9 //import dstep.AvailabilityMacros;
10 import dstep.coreservices.carboncore.Finder;
11 import dstep.coreservices.carboncore.MacTypes;
12 import dstep.coreservices.carboncore.MixedMode;
13 import dstep.coreservices.carboncore.OSUtils;
14 import dstep.coreservices.carboncore.TextCommon;
15 import dstep.coreservices.carboncore.UTCUtils;
16 import dstep.corefoundation.CFBase;
17 import dstep.corefoundation.CFDictionary;
18 import dstep.corefoundation.CFRunLoop;
19 import dstep.corefoundation.CFURL;
20 import dstep.corefoundation.CFUUID;
21 import dstep.diskarbitration.DADisk;
22 import dstep.objc.bridge.TypeEncoding;
23 import dstep.internal.Types;
24 /*import dstep.sys.acl;
25 import dstep.sys.fcntl;
26 import dstep.sys.types;*/
27
28
29 struct __FSFileOperation;
30 struct __FSFileSecurity;
31 struct OpaqueFSIterator;
32 struct OpaqueFNSubscriptionRef;
33 struct OpaqueFSVolumeOperation;
34 struct _acl;
35
36 alias _acl* acl_t;
37 alias int pid_t;
38 alias HFSUniStr255* ConstHFSUniStr255Param;
39 alias short FSVolumeRefNum;
40 alias int FSIORefNum;
41 alias FSRef* FSRefPtr;
42 alias __FSFileSecurity* FSFileSecurityRef;
43 alias FSSpec* FSSpecPtr;
44 alias FSSpecPtr* FSSpecHandle;
45 alias FSSpecPtr FSSpecArrayPtr;
46 alias FSSpec* ConstFSSpecPtr;
47 alias void* ParmBlkPtr;
48 alias IOCompletionProcPtr IOCompletionUPP;
49 alias uint FSCatalogInfoBitmap;
50 alias FSCatalogInfo* FSCatalogInfoPtr;
51 alias FSRefParam* FSRefParamPtr;
52 alias FSRefForkIOParam* FSRefForkIOParamPtr;
53 alias OpaqueFSIterator* FSIterator;
54 alias uint FSIteratorFlags;
55 alias FSSearchParams* FSSearchParamsPtr;
56 alias FSCatalogBulkParam* FSCatalogBulkParamPtr;
57 alias ushort FSAllocationFlags;
58 alias FSForkIOParam* FSForkIOParamPtr;
59 alias FSForkInfo* FSForkInfoPtr;
60 alias FSForkCBInfoParam* FSForkCBInfoParamPtr;
61 alias FSRangeLockParam* FSRangeLockParamPtr;
62 alias uint FSVolumeInfoBitmap;
63 alias FSVolumeInfo* FSVolumeInfoPtr;
64 alias FSVolumeInfoParam* FSVolumeInfoParamPtr;
65 alias uint VolumeType;
66 alias VolMountInfoHeader* VolMountInfoPtr;
67 alias VolumeMountInfoHeader* VolumeMountInfoHeaderPtr;
68 alias AFPVolMountInfo* AFPVolMountInfoPtr;
69 alias AFPXVolMountInfo* AFPXVolMountInfoPtr;
70 alias uint FNMessage;
71 alias OpaqueFNSubscriptionRef* FNSubscriptionRef;
72 alias FNSubscriptionProcPtr FNSubscriptionUPP;
73 alias uint FSMountStatus;
74 alias uint FSEjectStatus;
75 alias uint FSUnmountStatus;
76 alias OpaqueFSVolumeOperation* FSVolumeOperation;
77 alias FSVolumeMountProcPtr FSVolumeMountUPP;
78 alias FSVolumeUnmountProcPtr FSVolumeUnmountUPP;
79 alias FSVolumeEjectProcPtr FSVolumeEjectUPP;
80 alias __FSFileOperation* FSFileOperationRef;
81 alias uint FSFileOperationStage;
82
83 extern (C)
84 {
85 alias void function (ParmBlkPtr) IOCompletionProcPtr;
86 alias void function (FSFileOperationRef, FSRef*, uint, int, CFDictionaryRef, void*) FSFileOperationStatusProcPtr;
87 alias void function (uint, uint, void*, FNSubscriptionRef) FNSubscriptionProcPtr;
88 alias void function (FSFileOperationRef, char*, uint, int, CFDictionaryRef, void*) FSPathFileOperationStatusProcPtr;
89 alias void function (FSVolumeOperation, void*, int, short, int) FSVolumeUnmountProcPtr;
90 alias void function (FSVolumeOperation, void*, int, short, int) FSVolumeEjectProcPtr;
91 alias void function (FSVolumeOperation, void*, int, short) FSVolumeMountProcPtr;
92 }
93
94 extern (C)
95 {
96 extern
97 {
98 const CFStringRef kFSOperationTotalBytesKey;
99 const CFStringRef kFSOperationBytesCompleteKey;
100 const CFStringRef kFSOperationBytesRemainingKey;
101 const CFStringRef kFSOperationTotalObjectsKey;
102 const CFStringRef kFSOperationObjectsCompleteKey;
103 const CFStringRef kFSOperationObjectsRemainingKey;
104 const CFStringRef kFSOperationTotalUserVisibleObjectsKey;
105 const CFStringRef kFSOperationUserVisibleObjectsCompleteKey;
106 const CFStringRef kFSOperationUserVisibleObjectsRemainingKey;
107 const CFStringRef kFSOperationThroughputKey;
108 }
109 }
110
111 // This is needed otherwise the enums will fail compiling with gdc
112 version (GNU)
113 {
114 private
115 {
116 const __AppleShareMediaType = getOSType!("afpm");
117
118 }
119 }
120
121 enum
122 {
123 fsCurPerm = 0x00,
124 fsRdPerm = 0x01,
125 fsWrPerm = 0x02,
126 fsRdWrPerm = 0x03,
127 fsRdWrShPerm = 0x04
128 }
129
130 enum
131 {
132 fsRdAccessPerm = 0x01,
133 fsWrAccessPerm = 0x02,
134 fsRdDenyPerm = 0x10,
135 fsWrDenyPerm = 0x20
136 }
137
138 enum
139 {
140 fsRtParID = 1,
141 fsRtDirID = 2
142 }
143
144 enum
145 {
146 fsAtMark = 0,
147 fsFromStart = 1,
148 fsFromLEOF = 2,
149 fsFromMark = 3
150 }
151
152 enum
153 {
154 kFSAllowConcurrentAsyncIOBit = 3,
155 kFSAllowConcurrentAsyncIOMask = 0x0008,
156 kFSPleaseCacheBit = 4,
157 kFSPleaseCacheMask = 0x0010,
158 kFSNoCacheBit = 5,
159 kFSNoCacheMask = 0x0020,
160 kFSRdVerifyBit = 6,
161 kFSRdVerifyMask = 0x0040,
162 kFSForceReadBit = 6,
163 kFSForceReadMask = 0x0040,
164 kFSNewLineBit = 7,
165 kFSNewLineMask = 0x0080,
166 kFSNewLineCharMask = 0xFF00
167 }
168
169 enum
170 {
171 fsSBPartialName = 0x01,
172 fsSBFullName = 0x02,
173 fsSBFlAttrib = 0x04,
174 fsSBFlFndrInfo = 0x08,
175 fsSBFlLgLen = 0x20,
176 fsSBFlPyLen = 0x40,
177 fsSBFlRLgLen = 0x80,
178 fsSBFlRPyLen = 0x0100,
179 fsSBFlCrDat = 0x0200,
180 fsSBFlMdDat = 0x0400,
181 fsSBFlBkDat = 0x0800,
182 fsSBFlXFndrInfo = 0x1000,
183 fsSBFlParID = 0x2000,
184 fsSBNegate = 0x4000,
185 fsSBDrUsrWds = 0x08,
186 fsSBDrNmFls = 0x10,
187 fsSBDrCrDat = 0x0200,
188 fsSBDrMdDat = 0x0400,
189 fsSBDrBkDat = 0x0800,
190 fsSBDrFndrInfo = 0x1000,
191 fsSBDrParID = 0x2000,
192 fsSBNodeID = 0x8000,
193 fsSBAttributeModDate = 0x00010000,
194 fsSBAccessDate = 0x00020000,
195 fsSBPermissions = 0x00040000,
196 fsSBSkipPackageContents = 0x00080000,
197 fsSBSkipHiddenItems = 0x00100000,
198 fsSBUserID = 0x00200000,
199 fsSBGroupID = 0x00400000
200 }
201
202 enum
203 {
204 fsSBPartialNameBit = 0,
205 fsSBFullNameBit = 1,
206 fsSBFlAttribBit = 2,
207 fsSBFlFndrInfoBit = 3,
208 fsSBFlLgLenBit = 5,
209 fsSBFlPyLenBit = 6,
210 fsSBFlRLgLenBit = 7,
211 fsSBFlRPyLenBit = 8,
212 fsSBFlCrDatBit = 9,
213 fsSBFlMdDatBit = 10,
214 fsSBFlBkDatBit = 11,
215 fsSBFlXFndrInfoBit = 12,
216 fsSBFlParIDBit = 13,
217 fsSBNegateBit = 14,
218 fsSBDrUsrWdsBit = 3,
219 fsSBDrNmFlsBit = 4,
220 fsSBDrCrDatBit = 9,
221 fsSBDrMdDatBit = 10,
222 fsSBDrBkDatBit = 11,
223 fsSBDrFndrInfoBit = 12,
224 fsSBDrParIDBit = 13,
225 fsSBNodeIDBit = 15,
226 fsSBAttributeModDateBit = 16,
227 fsSBAccessDateBit = 17,
228 fsSBPermissionsBit = 18,
229 fsSBSkipPackageContentsBit = 19,
230 fsSBSkipHiddenItemsBit = 20,
231 fsSBUserIDBit = 21,
232 fsSBGroupIDBit = 22
233 }
234
235 enum
236 {
237 bLimitFCBs = 31,
238 bLocalWList = 30,
239 bNoMiniFndr = 29,
240 bNoVNEdit = 28,
241 bNoLclSync = 27,
242 bTrshOffLine = 26,
243 bNoSwitchTo = 25,
244 bNoDeskItems = 20,
245 bNoBootBlks = 19,
246 bAccessCntl = 18,
247 bNoSysDir = 17,
248 bHasExtFSVol = 16,
249 bHasOpenDeny = 15,
250 bHasCopyFile = 14,
251 bHasMoveRename = 13,
252 bHasDesktopMgr = 12,
253 bHasShortName = 11,
254 bHasFolderLock = 10,
255 bHasPersonalAccessPrivileges = 9,
256 bHasUserGroupList = 8,
257 bHasCatSearch = 7,
258 bHasFileIDs = 6,
259 bHasBTreeMgr = 5,
260 bHasBlankAccessPrivileges = 4,
261 bSupportsAsyncRequests = 3,
262 bSupportsTrashVolumeCache = 2
263 }
264
265 enum
266 {
267 bHasDirectIO = 1
268 }
269
270 enum
271 {
272 bIsEjectable = 0,
273 bSupportsHFSPlusAPIs = 1,
274 bSupportsFSCatalogSearch = 2,
275 bSupportsFSExchangeObjects = 3,
276 bSupports2TBFiles = 4,
277 bSupportsLongNames = 5,
278 bSupportsMultiScriptNames = 6,
279 bSupportsNamedForks = 7,
280 bSupportsSubtreeIterators = 8,
281 bL2PCanMapFileBlocks = 9,
282 bParentModDateChanges = 10,
283 bAncestorModDateChanges = 11,
284 bSupportsSymbolicLinks = 13,
285 bIsAutoMounted = 14,
286 bAllowCDiDataHandler = 17,
287 bSupportsExclusiveLocks = 18,
288 bSupportsJournaling = 19,
289 bNoVolumeSizes = 20,
290 bIsOnInternalBus = 21,
291 bIsCaseSensitive = 22,
292 bIsCasePreserving = 23,
293 bDoNotDisplay = 24,
294 bIsRemovable = 25,
295 bNoRootTimes = 26,
296 bIsOnExternalBus = 27,
297 bSupportsExtendedFileSecurity = 28
298 }
299
300 enum
301 {
302 kWidePosOffsetBit = 8,
303 kUseWidePositioning = (1 << kWidePosOffsetBit),
304 kMaximumBlocksIn4GB = 0x007FFFFF
305 }
306
307 enum
308 {
309 fsUnixPriv = 1
310 }
311
312 enum
313 {
314 kNoUserAuthentication = 1,
315 kPassword = 2,
316 kEncryptPassword = 3,
317 kTwoWayEncryptPassword = 6
318 }
319
320 enum
321 {
322 knoUser = 0,
323 kadministratorUser = 1
324 }
325
326 enum
327 {
328 knoGroup = 0
329 }
330
331 enum
332 {
333 kFSInvalidVolumeRefNum = 0
334 }
335
336 enum
337 {
338 kFSCatInfoNone = 0x00000000,
339 kFSCatInfoTextEncoding = 0x00000001,
340 kFSCatInfoNodeFlags = 0x00000002,
341 kFSCatInfoVolume = 0x00000004,
342 kFSCatInfoParentDirID = 0x00000008,
343 kFSCatInfoNodeID = 0x00000010,
344 kFSCatInfoCreateDate = 0x00000020,
345 kFSCatInfoContentMod = 0x00000040,
346 kFSCatInfoAttrMod = 0x00000080,
347 kFSCatInfoAccessDate = 0x00000100,
348 kFSCatInfoBackupDate = 0x00000200,
349 kFSCatInfoPermissions = 0x00000400,
350 kFSCatInfoFinderInfo = 0x00000800,
351 kFSCatInfoFinderXInfo = 0x00001000,
352 kFSCatInfoValence = 0x00002000,
353 kFSCatInfoDataSizes = 0x00004000,
354 kFSCatInfoRsrcSizes = 0x00008000,
355 kFSCatInfoSharingFlags = 0x00010000,
356 kFSCatInfoUserPrivs = 0x00020000,
357 kFSCatInfoUserAccess = 0x00080000,
358 kFSCatInfoSetOwnership = 0x00100000,
359 kFSCatInfoFSFileSecurityRef = 0x00400000,
360 kFSCatInfoAllDates = 0x000003E0,
361 kFSCatInfoGettableInfo = 0x0003FFFF,
362 kFSCatInfoSettableInfo = 0x00001FE3,
363 kFSCatInfoReserved = cast(c_long)0xFFFC0000
364 }
365
366 enum
367 {
368 kFSNodeLockedBit = 0,
369 kFSNodeLockedMask = 0x0001,
370 kFSNodeResOpenBit = 2,
371 kFSNodeResOpenMask = 0x0004,
372 kFSNodeDataOpenBit = 3,
373 kFSNodeDataOpenMask = 0x0008,
374 kFSNodeIsDirectoryBit = 4,
375 kFSNodeIsDirectoryMask = 0x0010,
376 kFSNodeCopyProtectBit = 6,
377 kFSNodeCopyProtectMask = 0x0040,
378 kFSNodeForkOpenBit = 7,
379 kFSNodeForkOpenMask = 0x0080,
380 kFSNodeHardLinkBit = 8,
381 kFSNodeHardLinkMask = 0x00000100
382 }
383
384 enum
385 {
386 kFSNodeInSharedBit = 2,
387 kFSNodeInSharedMask = 0x0004,
388 kFSNodeIsMountedBit = 3,
389 kFSNodeIsMountedMask = 0x0008,
390 kFSNodeIsSharePointBit = 5,
391 kFSNodeIsSharePointMask = 0x0020
392 }
393
394 enum
395 {
396 kFSIterateFlat = 0,
397 kFSIterateSubtree = 1,
398 kFSIterateDelete = 2,
399 kFSIterateReserved = cast(c_long)0xFFFFFFFC
400 }
401
402 enum
403 {
404 kFSAllocDefaultFlags = 0x0000,
405 kFSAllocAllOrNothingMask = 0x0001,
406 kFSAllocContiguousMask = 0x0002,
407 kFSAllocNoRoundUpMask = 0x0004,
408 kFSAllocReservedMask = 0xFFF8
409 }
410
411 enum
412 {
413 kFSVolInfoNone = 0x0000,
414 kFSVolInfoCreateDate = 0x0001,
415 kFSVolInfoModDate = 0x0002,
416 kFSVolInfoBackupDate = 0x0004,
417 kFSVolInfoCheckedDate = 0x0008,
418 kFSVolInfoFileCount = 0x0010,
419 kFSVolInfoDirCount = 0x0020,
420 kFSVolInfoSizes = 0x0040,
421 kFSVolInfoBlocks = 0x0080,
422 kFSVolInfoNextAlloc = 0x0100,
423 kFSVolInfoRsrcClump = 0x0200,
424 kFSVolInfoDataClump = 0x0400,
425 kFSVolInfoNextID = 0x0800,
426 kFSVolInfoFinderInfo = 0x1000,
427 kFSVolInfoFlags = 0x2000,
428 kFSVolInfoFSInfo = 0x4000,
429 kFSVolInfoDriveInfo = 0x8000,
430 kFSVolInfoGettableInfo = 0xFFFF,
431 kFSVolInfoSettableInfo = 0x3004
432 }
433
434 enum
435 {
436 kFSVolFlagDefaultVolumeBit = 5,
437 kFSVolFlagDefaultVolumeMask = 0x0020,
438 kFSVolFlagFilesOpenBit = 6,
439 kFSVolFlagFilesOpenMask = 0x0040,
440 kFSVolFlagHardwareLockedBit = 7,
441 kFSVolFlagHardwareLockedMask = 0x0080,
442 kFSVolFlagJournalingActiveBit = 14,
443 kFSVolFlagJournalingActiveMask = 0x4000,
444 kFSVolFlagSoftwareLockedBit = 15,
445 kFSVolFlagSoftwareLockedMask = 0x8000
446 }
447
448 enum
449 {
450 AppleShareMediaType = getOSType!("afpm")
451 }
452
453 enum
454 {
455 volMountNoLoginMsgFlagBit = 0,
456 volMountNoLoginMsgFlagMask = 0x0001,
457 volMountExtendedFlagsBit = 7,
458 volMountExtendedFlagsMask = 0x0080,
459 volMountInteractBit = 15,
460 volMountInteractMask = 0x8000,
461 volMountChangedBit = 14,
462 volMountChangedMask = 0x4000,
463 volMountFSReservedMask = 0x00FF,
464 volMountSysReservedMask = 0xFF00
465 }
466
467 enum
468 {
469 kAFPExtendedFlagsAlternateAddressMask = 1
470 }
471
472 enum
473 {
474 kAFPTagTypeIP = 0x01,
475 kAFPTagTypeIPPort = 0x02,
476 kAFPTagTypeDDP = 0x03,
477 kAFPTagTypeDNS = 0x04
478 }
479
480 enum
481 {
482 kAFPTagLengthIP = 0x06,
483 kAFPTagLengthIPPort = 0x08,
484 kAFPTagLengthDDP = 0x06
485 }
486
487 enum
488 {
489 kLargeIconSize = 256,
490 kLarge4BitIconSize = 512,
491 kLarge8BitIconSize = 1024,
492 kSmallIconSize = 64,
493 kSmall4BitIconSize = 128,
494 kSmall8BitIconSize = 256
495 }
496
497 enum
498 {
499 kFSReplaceObjectDefaultOptions = 0,
500 kFSReplaceObjectReplaceMetadata = 0x01,
501 kFSReplaceObjectSaveOriginalAsABackup = 0x02,
502 kFSReplaceObjectReplacePermissionInfo = 0x04,
503 kFSReplaceObjectPreservePermissionInfo = 0x08,
504 kFSReplaceObjectDoNotCheckObjectWriteAccess = 0x10
505 }
506
507 enum
508 {
509 kFSPathMakeRefDefaultOptions = 0,
510 kFSPathMakeRefDoNotFollowLeafSymlink = 0x01
511 }
512
513 enum
514 {
515 kFNDirectoryModifiedMessage = 1
516 }
517
518 enum
519 {
520 kFNNoImplicitAllSubscription = (1 << 0),
521 kFNNotifyInBackground = (1 << 1)
522 }
523
524 enum
525 {
526 kAsyncMountInProgress = 1,
527 kAsyncMountComplete = 2,
528 kAsyncUnmountInProgress = 3,
529 kAsyncUnmountComplete = 4,
530 kAsyncEjectInProgress = 5,
531 kAsyncEjectComplete = 6
532 }
533
534 enum
535 {
536 kFSMountServerMarkDoNotDisplay = (1 << 0),
537 kFSMountServerMountOnMountDir = (1 << 2)
538 }
539
540 enum
541 {
542 kFSMountServerMountWithoutNotification = (1 << 1)
543 }
544
545 enum
546 {
547 kFSEjectVolumeForceEject = (1 << 0)
548 }
549
550 enum
551 {
552 kFSUnmountVolumeForceUnmount = (1 << 0)
553 }
554
555 enum
556 {
557 kFSFileOperationDefaultOptions = 0,
558 kFSFileOperationOverwrite = 0x01,
559 kFSFileOperationSkipSourcePermissionErrors = 0x02,
560 kFSFileOperationDoNotMoveAcrossVolumes = 0x04,
561 kFSFileOperationSkipPreflight = 0x08
562 }
563
564 enum
565 {
566 kFSOperationStageUndefined = 0,
567 kFSOperationStagePreflighting = 1,
568 kFSOperationStageRunning = 2,
569 kFSOperationStageComplete = 3
570 }
571
572 enum
573 {
574 pleaseCacheBit = 4,
575 pleaseCacheMask = 0x0010,
576 noCacheBit = 5,
577 noCacheMask = 0x0020,
578 rdVerifyBit = 6,
579 rdVerifyMask = 0x0040,
580 rdVerify = 64,
581 forceReadBit = 6,
582 forceReadMask = 0x0040,
583 newLineBit = 7,
584 newLineMask = 0x0080,
585 newLineCharMask = 0xFF00
586 }
587
588 enum
589 {
590 kOwnerID2Name = 1,
591 kGroupID2Name = 2,
592 kOwnerName2ID = 3,
593 kGroupName2ID = 4,
594 kReturnNextUser = 1,
595 kReturnNextGroup = 2,
596 kReturnNextUG = 3
597 }
598
599 enum
600 {
601 kVCBFlagsIdleFlushBit = 3,
602 kVCBFlagsIdleFlushMask = 0x0008,
603 kVCBFlagsHFSPlusAPIsBit = 4,
604 kVCBFlagsHFSPlusAPIsMask = 0x0010,
605 kVCBFlagsHardwareGoneBit = 5,
606 kVCBFlagsHardwareGoneMask = 0x0020,
607 kVCBFlagsVolumeDirtyBit = 15,
608 kVCBFlagsVolumeDirtyMask = 0x8000
609 }
610
611 enum
612 {
613 kioVAtrbDefaultVolumeBit = 5,
614 kioVAtrbDefaultVolumeMask = 0x0020,
615 kioVAtrbFilesOpenBit = 6,
616 kioVAtrbFilesOpenMask = 0x0040,
617 kioVAtrbHardwareLockedBit = 7,
618 kioVAtrbHardwareLockedMask = 0x0080,
619 kioVAtrbSoftwareLockedBit = 15,
620 kioVAtrbSoftwareLockedMask = 0x8000
621 }
622
623 enum
624 {
625 kioFlAttribLockedBit = 0,
626 kioFlAttribLockedMask = 0x01,
627 kioFlAttribResOpenBit = 2,
628 kioFlAttribResOpenMask = 0x04,
629 kioFlAttribDataOpenBit = 3,
630 kioFlAttribDataOpenMask = 0x08,
631 kioFlAttribDirBit = 4,
632 kioFlAttribDirMask = 0x10,
633 ioDirFlg = 4,
634 ioDirMask = 0x10,
635 kioFlAttribCopyProtBit = 6,
636 kioFlAttribCopyProtMask = 0x40,
637 kioFlAttribFileOpenBit = 7,
638 kioFlAttribFileOpenMask = 0x80,
639 kioFlAttribInSharedBit = 2,
640 kioFlAttribInSharedMask = 0x04,
641 kioFlAttribMountedBit = 3,
642 kioFlAttribMountedMask = 0x08,
643 kioFlAttribSharePointBit = 5,
644 kioFlAttribSharePointMask = 0x20
645 }
646
647 enum
648 {
649 kioFCBWriteBit = 8,
650 kioFCBWriteMask = 0x0100,
651 kioFCBResourceBit = 9,
652 kioFCBResourceMask = 0x0200,
653 kioFCBWriteLockedBit = 10,
654 kioFCBWriteLockedMask = 0x0400,
655 kioFCBLargeFileBit = 11,
656 kioFCBLargeFileMask = 0x0800,
657 kioFCBSharedWriteBit = 12,
658 kioFCBSharedWriteMask = 0x1000,
659 kioFCBFileLockedBit = 13,
660 kioFCBFileLockedMask = 0x2000,
661 kioFCBOwnClumpBit = 14,
662 kioFCBOwnClumpMask = 0x4000,
663 kioFCBModifiedBit = 15,
664 kioFCBModifiedMask = 0x8000
665 }
666
667 enum
668 {
669 kioACUserNoSeeFolderBit = 0,
670 kioACUserNoSeeFolderMask = 0x01,
671 kioACUserNoSeeFilesBit = 1,
672 kioACUserNoSeeFilesMask = 0x02,
673 kioACUserNoMakeChangesBit = 2,
674 kioACUserNoMakeChangesMask = 0x04,
675 kioACUserNotOwnerBit = 7,
676 kioACUserNotOwnerMask = 0x80
677 }
678
679 enum
680 {
681 kioACAccessOwnerBit = 31,
682 kioACAccessOwnerMask = cast(c_long)0x80000000,
683 kioACAccessBlankAccessBit = 28,
684 kioACAccessBlankAccessMask = 0x10000000,
685 kioACAccessUserWriteBit = 26,
686 kioACAccessUserWriteMask = 0x04000000,
687 kioACAccessUserReadBit = 25,
688 kioACAccessUserReadMask = 0x02000000,
689 kioACAccessUserSearchBit = 24,
690 kioACAccessUserSearchMask = 0x01000000,
691 kioACAccessEveryoneWriteBit = 18,
692 kioACAccessEveryoneWriteMask = 0x00040000,
693 kioACAccessEveryoneReadBit = 17,
694 kioACAccessEveryoneReadMask = 0x00020000,
695 kioACAccessEveryoneSearchBit = 16,
696 kioACAccessEveryoneSearchMask = 0x00010000,
697 kioACAccessGroupWriteBit = 10,
698 kioACAccessGroupWriteMask = 0x00000400,
699 kioACAccessGroupReadBit = 9,
700 kioACAccessGroupReadMask = 0x00000200,
701 kioACAccessGroupSearchBit = 8,
702 kioACAccessGroupSearchMask = 0x00000100,
703 kioACAccessOwnerWriteBit = 2,
704 kioACAccessOwnerWriteMask = 0x00000004,
705 kioACAccessOwnerReadBit = 1,
706 kioACAccessOwnerReadMask = 0x00000002,
707 kioACAccessOwnerSearchBit = 0,
708 kioACAccessOwnerSearchMask = 0x00000001,
709 kfullPrivileges = 0x00070007,
710 kownerPrivileges = 0x00000007
711 }
712
713 struct HFSUniStr255
714 {
715 ushort length;
716 wchar* unicode;
717 }
718
719
720 struct FSRef
721 {
722 ubyte[80] hidden;
723 }
724
725
726 struct CatPositionRec
727 {
728 int initialize;
729 short[6] priv;
730 }
731
732
733 struct FSSpec
734 {
735 ubyte[70] hidden;
736 }
737
738
739 struct FSPermissionInfo
740 {
741 uint userID;
742 uint groupID;
743 ubyte reserved1;
744 ubyte userAccess;
745 ushort mode;
746 FSFileSecurityRef fileSec;
747 }
748
749
750 struct FSCatalogInfo
751 {
752 ushort nodeFlags;
753 short volume;
754 uint parentDirID;
755 uint nodeID;
756 ubyte sharingFlags;
757 ubyte userPrivileges;
758 ubyte reserved1;
759 ubyte reserved2;
760 UTCDateTime createDate;
761 UTCDateTime contentModDate;
762 UTCDateTime attributeModDate;
763 UTCDateTime accessDate;
764 UTCDateTime backupDate;
765 FSPermissionInfo permissions;
766 char* finderInfo;
767 char* extFinderInfo;
768 ulong dataLogicalSize;
769 ulong dataPhysicalSize;
770 ulong rsrcLogicalSize;
771 ulong rsrcPhysicalSize;
772 uint valence;
773 uint textEncodingHint;
774 }
775
776
777 struct FSRefParam
778 {
779 QElemPtr qLink;
780 short qType;
781 short ioTrap;
782 char* ioCmdAddr;
783 IOCompletionUPP ioCompletion;
784 short ioResult;
785 char* ioNamePtr;
786 short ioVRefNum;
787 short reserved1;
788 ubyte reserved2;
789 ubyte reserved3;
790 FSRef* ref_;
791 uint whichInfo;
792 FSCatalogInfo* catInfo;
793 uint nameLength;
794 wchar* name;
795 uint ioDirID;
796 FSSpecPtr spec;
797 FSRef* parentRef;
798 FSRef* newRef;
799 uint textEncodingHint;
800 HFSUniStr255* outName;
801 }
802
803
804 struct FSRefForkIOParam
805 {
806 QElemPtr qLink;
807 short qType;
808 short ioTrap;
809 char* ioCmdAddr;
810 IOCompletionUPP ioCompletion;
811 short ioResult;
812 FSRef* parentRef;
813 uint nameLength;
814 wchar* name;
815 uint whichInfo;
816 FSCatalogInfo* catInfo;
817 uint forkNameLength;
818 wchar* forkName;
819 byte permissions;
820 ubyte reserved1;
821 short forkRefNum;
822 FSRef* newRef;
823 }
824
825
826 struct FSSearchParams
827 {
828 int searchTime;
829 uint searchBits;
830 uint searchNameLength;
831 wchar* searchName;
832 FSCatalogInfo* searchInfo1;
833 FSCatalogInfo* searchInfo2;
834 }
835
836
837 struct FSCatalogBulkParam
838 {
839 QElemPtr qLink;
840 short qType;
841 short ioTrap;
842 char* ioCmdAddr;
843 IOCompletionUPP ioCompletion;
844 short ioResult;
845 ubyte containerChanged;
846 ubyte reserved;
847 uint iteratorFlags;
848 FSIterator iterator;
849 FSRef* container;
850 uint maximumItems;
851 uint actualItems;
852 uint whichInfo;
853 FSCatalogInfo* catalogInfo;
854 FSRef* refs;
855 FSSpecPtr specs;
856 HFSUniStr255* names;
857 FSSearchParams* searchParams;
858 }
859
860
861 struct FSForkIOParam
862 {
863 QElemPtr qLink;
864 short qType;
865 short ioTrap;
866 char* ioCmdAddr;
867 IOCompletionUPP ioCompletion;
868 short ioResult;
869 void* reserved1;
870 short reserved2;
871 short forkRefNum;
872 ubyte reserved3;
873 byte permissions;
874 FSRef* ref_;
875 char* buffer;
876 uint requestCount;
877 uint actualCount;
878 ushort positionMode;
879 long positionOffset;
880 ushort allocationFlags;
881 ulong allocationAmount;
882 uint forkNameLength;
883 wchar* forkName;
884 CatPositionRec forkIterator;
885 HFSUniStr255* outForkName;
886 }
887
888
889 struct FSForkInfo
890 {
891 byte flags;
892 byte permissions;
893 short volume;
894 uint reserved2;
895 uint nodeID;
896 uint forkID;
897 ulong currentPosition;
898 ulong logicalEOF;
899 ulong physicalEOF;
900 ulong process;
901 }
902
903
904 struct FSForkCBInfoParam
905 {
906 QElemPtr qLink;
907 short qType;
908 short ioTrap;
909 char* ioCmdAddr;
910 IOCompletionUPP ioCompletion;
911 short ioResult;
912 short desiredRefNum;
913 short volumeRefNum;
914 short iterator;
915 short actualRefNum;
916 FSRef* ref_;
917 FSForkInfo* forkInfo;
918 HFSUniStr255* forkName;
919 }
920
921
922 struct FSRangeLockParam
923 {
924 QElemPtr qLink;
925 short qType;
926 short ioTrap;
927 char* ioCmdAddr;
928 IOCompletionUPP ioCompletion;
929 short ioResult;
930 short forkRefNum;
931 ulong requestCount;
932 ushort positionMode;
933 long positionOffset;
934 ulong rangeStart;
935 }
936
937
938 struct FSVolumeInfo
939 {
940 UTCDateTime createDate;
941 UTCDateTime modifyDate;
942 UTCDateTime backupDate;
943 UTCDateTime checkedDate;
944 uint fileCount;
945 uint folderCount;
946 ulong totalBytes;
947 ulong freeBytes;
948 uint blockSize;
949 uint totalBlocks;
950 uint freeBlocks;
951 uint nextAllocation;
952 uint rsrcClumpSize;
953 uint dataClumpSize;
954 uint nextCatalogID;
955 char* finderInfo;
956 ushort flags;
957 ushort filesystemID;
958 ushort signature;
959 ushort driveNumber;
960 short driverRefNum;
961 }
962
963
964 struct FSVolumeInfoParam
965 {
966 QElemPtr qLink;
967 short qType;
968 short ioTrap;
969 char* ioCmdAddr;
970 IOCompletionUPP ioCompletion;
971 short ioResult;
972 char* ioNamePtr;
973 short ioVRefNum;
974 uint volumeIndex;
975 uint whichInfo;
976 FSVolumeInfo* volumeInfo;
977 HFSUniStr255* volumeName;
978 FSRef* ref_;
979 }
980
981
982 struct GetVolParmsInfoBuffer
983 {
984 short vMVersion;
985 int vMAttrib;
986 Handle vMLocalHand;
987 int vMServerAdr;
988 int vMVolumeGrade;
989 short vMForeignPrivID;
990 int vMExtendedAttributes;
991 void* vMDeviceID;
992 uint vMMaxNameLength;
993 }
994
995
996 struct VolMountInfoHeader
997 {
998 short length;
999 uint media;
1000 }
1001
1002
1003 struct VolumeMountInfoHeader
1004 {
1005 short length;
1006 uint media;
1007 short flags;
1008 }
1009
1010
1011 struct AFPVolMountInfo
1012 {
1013 short length;
1014 uint media;
1015 short flags;
1016 byte nbpInterval;
1017 byte nbpCount;
1018 short uamType;
1019 short zoneNameOffset;
1020 short serverNameOffset;
1021 short volNameOffset;
1022 short userNameOffset;
1023 short userPasswordOffset;
1024 short volPasswordOffset;
1025 char* AFPData;
1026 }
1027
1028
1029 struct AFPXVolMountInfo
1030 {
1031 short length;
1032 uint media;
1033 short flags;
1034 byte nbpInterval;
1035 byte nbpCount;
1036 short uamType;
1037 short zoneNameOffset;
1038 short serverNameOffset;
1039 short volNameOffset;
1040 short userNameOffset;
1041 short userPasswordOffset;
1042 short volPasswordOffset;
1043 short extendedFlags;
1044 short uamNameOffset;
1045 short alternateAddressOffset;
1046 char* AFPData;
1047 }
1048
1049
1050 struct AFPTagData
1051 {
1052 ubyte fLength;
1053 ubyte fType;
1054 char* fData;
1055 }
1056
1057
1058 struct AFPAlternateAddress
1059 {
1060 ubyte fVersion;
1061 ubyte fAddressCount;
1062 char* fAddressList;
1063 }
1064
1065
1066 struct FSFileOperationClientContext
1067 {
1068 int version_;
1069 void* info;
1070 CFAllocatorRetainCallBack retain;
1071 CFAllocatorReleaseCallBack release;
1072 CFAllocatorCopyDescriptionCallBack copyDescription;
1073 }
1074
1075 extern (C)
1076 {
1077 IOCompletionUPP NewIOCompletionUPP (IOCompletionProcPtr userRoutine);
1078 void DisposeIOCompletionUPP (IOCompletionUPP userUPP);
1079 void InvokeIOCompletionUPP (ParmBlkPtr paramBlock, IOCompletionUPP userUPP);
1080 short FSMakeFSRefUnicode (FSRef* parentRef, uint nameLength, wchar* name, uint textEncodingHint, FSRef* newRef);
1081 short PBMakeFSRefUnicodeSync (FSRefParam* paramBlock);
1082 void PBMakeFSRefUnicodeAsync (FSRefParam* paramBlock);
1083 short FSCompareFSRefs (FSRef* ref1, FSRef* ref2);
1084 short PBCompareFSRefsSync (FSRefParam* paramBlock);
1085 void PBCompareFSRefsAsync (FSRefParam* paramBlock);
1086 short FSCreateFileUnicode (FSRef* parentRef, uint nameLength, wchar* name, uint whichInfo, FSCatalogInfo* catalogInfo, FSRef* newRef, FSSpecPtr newSpec);
1087 short PBCreateFileUnicodeSync (FSRefParam* paramBlock);
1088 void PBCreateFileUnicodeAsync (FSRefParam* paramBlock);
1089 short FSCreateDirectoryUnicode (FSRef* parentRef, uint nameLength, wchar* name, uint whichInfo, FSCatalogInfo* catalogInfo, FSRef* newRef, FSSpecPtr newSpec, UInt32* newDirID);
1090 short PBCreateDirectoryUnicodeSync (FSRefParam* paramBlock);
1091 void PBCreateDirectoryUnicodeAsync (FSRefParam* paramBlock);
1092 short FSDeleteObject (FSRef* ref_);
1093 short PBDeleteObjectSync (FSRefParam* paramBlock);
1094 void PBDeleteObjectAsync (FSRefParam* paramBlock);
1095 short FSUnlinkObject (FSRef* ref_);
1096 short PBUnlinkObjectSync (FSRefParam* paramBlock);
1097 void PBUnlinkObjectAsync (FSRefParam* paramBlock);
1098 short FSMoveObject (FSRef* ref_, FSRef* destDirectory, FSRef* newRef);
1099 short PBMoveObjectSync (FSRefParam* paramBlock);
1100 void PBMoveObjectAsync (FSRefParam* paramBlock);
1101 short FSExchangeObjects (FSRef* ref_, FSRef* destRef);
1102 short PBExchangeObjectsSync (FSRefParam* paramBlock);
1103 void PBExchangeObjectsAsync (FSRefParam* paramBlock);
1104 int FSReplaceObject (FSRef* originalObject, FSRef* replacementObject, CFStringRef newName, CFStringRef temporaryName, FSRef* temporaryDirectory, uint flags, FSRef* resultObject);
1105 int FSPathReplaceObject (char* originalObjectPath, char* replacementObjectPath, CFStringRef newName, CFStringRef temporaryName, char* temporaryDirectoryPath, uint flags);
1106 int FSGetTemporaryDirectoryForReplaceObject (FSRef* originalObject, FSRef* temporaryDirectory, uint flags);
1107 int FSPathGetTemporaryDirectoryForReplaceObject (char* originalObjectPath, char* temporaryDirectoryPath, uint maxPathSize, uint flags);
1108 short FSRenameUnicode (FSRef* ref_, uint nameLength, wchar* name, uint textEncodingHint, FSRef* newRef);
1109 short PBRenameUnicodeSync (FSRefParam* paramBlock);
1110 void PBRenameUnicodeAsync (FSRefParam* paramBlock);
1111 short FSGetCatalogInfo (FSRef* ref_, uint whichInfo, FSCatalogInfo* catalogInfo, HFSUniStr255* outName, FSSpecPtr fsSpec, FSRef* parentRef);
1112 short PBGetCatalogInfoSync (FSRefParam* paramBlock);
1113 void PBGetCatalogInfoAsync (FSRefParam* paramBlock);
1114 short FSSetCatalogInfo (FSRef* ref_, uint whichInfo, FSCatalogInfo* catalogInfo);
1115 short PBSetCatalogInfoSync (FSRefParam* paramBlock);
1116 void PBSetCatalogInfoAsync (FSRefParam* paramBlock);
1117 short FSOpenIterator (FSRef* container, uint iteratorFlags, FSIterator* iterator);
1118 short PBOpenIteratorSync (FSCatalogBulkParam* paramBlock);
1119 void PBOpenIteratorAsync (FSCatalogBulkParam* paramBlock);
1120 short FSCloseIterator (FSIterator iterator);
1121 short PBCloseIteratorSync (FSCatalogBulkParam* paramBlock);
1122 void PBCloseIteratorAsync (FSCatalogBulkParam* paramBlock);
1123 short FSGetCatalogInfoBulk (FSIterator iterator, uint maximumObjects, ItemCount* actualObjects, char* containerChanged, uint whichInfo, FSCatalogInfo* catalogInfos, FSRef* refs, FSSpecPtr specs, HFSUniStr255* names);
1124 short PBGetCatalogInfoBulkSync (FSCatalogBulkParam* paramBlock);
1125 void PBGetCatalogInfoBulkAsync (FSCatalogBulkParam* paramBlock);
1126 short FSCatalogSearch (FSIterator iterator, FSSearchParams* searchCriteria, uint maximumObjects, ItemCount* actualObjects, char* containerChanged, uint whichInfo, FSCatalogInfo* catalogInfos, FSRef* refs, FSSpecPtr specs, HFSUniStr255* names);
1127 short PBCatalogSearchSync (FSCatalogBulkParam* paramBlock);
1128 void PBCatalogSearchAsync (FSCatalogBulkParam* paramBlock);
1129 int FSCreateFileAndOpenForkUnicode (FSRef* parentRef, uint nameLength, wchar* name, uint whichInfo, FSCatalogInfo* catalogInfo, uint forkNameLength, wchar* forkName, byte permissions, FSIORefNum* forkRefNum, FSRef* newRef);
1130 int PBCreateFileAndOpenForkUnicodeSync (FSRefForkIOParamPtr paramBlock);
1131 void PBCreateFileAndOpenForkUnicodeAsync (FSRefForkIOParamPtr paramBlock);
1132 short FSCreateFork (FSRef* ref_, uint forkNameLength, wchar* forkName);
1133 short PBCreateForkSync (FSForkIOParam* paramBlock);
1134 void PBCreateForkAsync (FSForkIOParam* paramBlock);
1135 short FSDeleteFork (FSRef* ref_, uint forkNameLength, wchar* forkName);
1136 short PBDeleteForkSync (FSForkIOParam* paramBlock);
1137 void PBDeleteForkAsync (FSForkIOParam* paramBlock);
1138 short FSIterateForks (FSRef* ref_, CatPositionRec* forkIterator, HFSUniStr255* forkName, SInt64* forkSize, UInt64* forkPhysicalSize);
1139 short PBIterateForksSync (FSForkIOParam* paramBlock);
1140 void PBIterateForksAsync (FSForkIOParam* paramBlock);
1141 short FSOpenFork (FSRef* ref_, uint forkNameLength, wchar* forkName, byte permissions, FSIORefNum* forkRefNum);
1142 short PBOpenForkSync (FSForkIOParam* paramBlock);
1143 void PBOpenForkAsync (FSForkIOParam* paramBlock);
1144 short FSReadFork (short forkRefNum, ushort positionMode, long positionOffset, uint requestCount, void* buffer, ByteCount* actualCount);
1145 short PBReadForkSync (FSForkIOParam* paramBlock);
1146 void PBReadForkAsync (FSForkIOParam* paramBlock);
1147 short FSWriteFork (short forkRefNum, ushort positionMode, long positionOffset, uint requestCount, void* buffer, ByteCount* actualCount);
1148 short PBWriteForkSync (FSForkIOParam* paramBlock);
1149 void PBWriteForkAsync (FSForkIOParam* paramBlock);
1150 short FSGetForkPosition (short forkRefNum, SInt64* position);
1151 short PBGetForkPositionSync (FSForkIOParam* paramBlock);
1152 void PBGetForkPositionAsync (FSForkIOParam* paramBlock);
1153 short FSSetForkPosition (short forkRefNum, ushort positionMode, long positionOffset);
1154 short PBSetForkPositionSync (FSForkIOParam* paramBlock);
1155 void PBSetForkPositionAsync (FSForkIOParam* paramBlock);
1156 short FSGetForkSize (short forkRefNum, SInt64* forkSize);
1157 short PBGetForkSizeSync (FSForkIOParam* paramBlock);
1158 void PBGetForkSizeAsync (FSForkIOParam* paramBlock);
1159 short FSSetForkSize (short forkRefNum, ushort positionMode, long positionOffset);
1160 short PBSetForkSizeSync (FSForkIOParam* paramBlock);
1161 void PBSetForkSizeAsync (FSForkIOParam* paramBlock);
1162 short FSAllocateFork (short forkRefNum, ushort flags, ushort positionMode, long positionOffset, ulong requestCount, UInt64* actualCount);
1163 short PBAllocateForkSync (FSForkIOParam* paramBlock);
1164 void PBAllocateForkAsync (FSForkIOParam* paramBlock);
1165 short FSFlushFork (short forkRefNum);
1166 short PBFlushForkSync (FSForkIOParam* paramBlock);
1167 void PBFlushForkAsync (FSForkIOParam* paramBlock);
1168 short FSCloseFork (short forkRefNum);
1169 short PBCloseForkSync (FSForkIOParam* paramBlock);
1170 void PBCloseForkAsync (FSForkIOParam* paramBlock);
1171 short FSGetForkCBInfo (short desiredRefNum, short volume, short* iterator, FSIORefNum* actualRefNum, FSForkInfo* forkInfo, FSRef* ref_, HFSUniStr255* outForkName);
1172 short PBGetForkCBInfoSync (FSForkCBInfoParam* paramBlock);
1173 void PBGetForkCBInfoAsync (FSForkCBInfoParam* paramBlock);
1174 int FSLockRange (short forkRefNum, ushort positionMode, long positionOffset, ulong requestCount, UInt64* rangeStart);
1175 int PBXLockRangeSync (FSRangeLockParamPtr paramBlock);
1176 int PBXLockRangeAsync (FSRangeLockParamPtr paramBlock);
1177 int FSUnlockRange (short forkRefNum, ushort positionMode, long positionOffset, ulong requestCount, UInt64* rangeStart);
1178 int PBXUnlockRangeSync (FSRangeLockParamPtr paramBlock);
1179 int PBXUnlockRangeAsync (FSRangeLockParamPtr paramBlock);
1180 short FSGetVolumeInfo (short volume, uint volumeIndex, FSVolumeRefNum* actualVolume, uint whichInfo, FSVolumeInfo* info, HFSUniStr255* volumeName, FSRef* rootDirectory);
1181 short PBGetVolumeInfoSync (FSVolumeInfoParam* paramBlock);
1182 void PBGetVolumeInfoAsync (FSVolumeInfoParam* paramBlock);
1183 short FSSetVolumeInfo (short volume, uint whichInfo, FSVolumeInfo* info);
1184 short PBSetVolumeInfoSync (FSVolumeInfoParam* paramBlock);
1185 void PBSetVolumeInfoAsync (FSVolumeInfoParam* paramBlock);
1186 short FSGetDataForkName (HFSUniStr255* dataForkName);
1187 short FSGetResourceForkName (HFSUniStr255* resourceForkName);
1188 int FSRefMakePath (FSRef* ref_, char* path, uint pathBufferSize);
1189 int FSPathMakeRef (char* path, FSRef* ref_, char* isDirectory);
1190 int FSPathMakeRefWithOptions (char* path, uint options, FSRef* ref_, char* isDirectory);
1191 ubyte FSIsFSRefValid (FSRef* ref_);
1192 int FNNotify (FSRef* ref_, uint message, uint flags);
1193 int FNNotifyByPath (char* path, uint message, uint flags);
1194 int FNNotifyAll (uint message, uint flags);
1195 FNSubscriptionUPP NewFNSubscriptionUPP (FNSubscriptionProcPtr userRoutine);
1196 void DisposeFNSubscriptionUPP (FNSubscriptionUPP userUPP);
1197 void InvokeFNSubscriptionUPP (uint message, uint flags, void* refcon, FNSubscriptionRef subscription, FNSubscriptionUPP userUPP);
1198 int FNSubscribe (FSRef* directoryRef, FNSubscriptionUPP callback, void* refcon, uint flags, FNSubscriptionRef* subscription);
1199 int FNSubscribeByPath (char* directoryPath, FNSubscriptionUPP callback, void* refcon, uint flags, FNSubscriptionRef* subscription);
1200 int FNUnsubscribe (FNSubscriptionRef subscription);
1201 int FNGetDirectoryForSubscription (FNSubscriptionRef subscription, FSRef* ref_);
1202 FSVolumeMountUPP NewFSVolumeMountUPP (FSVolumeMountProcPtr userRoutine);
1203 FSVolumeUnmountUPP NewFSVolumeUnmountUPP (FSVolumeUnmountProcPtr userRoutine);
1204 FSVolumeEjectUPP NewFSVolumeEjectUPP (FSVolumeEjectProcPtr userRoutine);
1205 void DisposeFSVolumeMountUPP (FSVolumeMountUPP userUPP);
1206 void DisposeFSVolumeUnmountUPP (FSVolumeUnmountUPP userUPP);
1207 void DisposeFSVolumeEjectUPP (FSVolumeEjectUPP userUPP);
1208 void InvokeFSVolumeMountUPP (FSVolumeOperation volumeOp, void* clientData, int err, short mountedVolumeRefNum, FSVolumeMountUPP userUPP);
1209 void InvokeFSVolumeUnmountUPP (FSVolumeOperation volumeOp, void* clientData, int err, short volumeRefNum, int dissenter, FSVolumeUnmountUPP userUPP);
1210 void InvokeFSVolumeEjectUPP (FSVolumeOperation volumeOp, void* clientData, int err, short volumeRefNum, int dissenter, FSVolumeEjectUPP userUPP);
1211 int FSCreateVolumeOperation (FSVolumeOperation* volumeOp);
1212 int FSDisposeVolumeOperation (FSVolumeOperation volumeOp);
1213 int FSMountLocalVolumeSync (CFStringRef diskID, CFURLRef mountDir, FSVolumeRefNum* mountedVolumeRefNum, uint flags);
1214 int FSMountLocalVolumeAsync (CFStringRef diskID, CFURLRef mountDir, FSVolumeOperation volumeOp, void* clientData, uint flags, FSVolumeMountUPP callback, CFRunLoopRef runloop, CFStringRef runloopMode);
1215 int FSMountServerVolumeSync (CFURLRef url, CFURLRef mountDir, CFStringRef user, CFStringRef password, FSVolumeRefNum* mountedVolumeRefNum, uint flags);
1216 int FSMountServerVolumeAsync (CFURLRef url, CFURLRef mountDir, CFStringRef user, CFStringRef password, FSVolumeOperation volumeOp, void* clientData, uint flags, FSVolumeMountUPP callback, CFRunLoopRef runloop, CFStringRef runloopMode);
1217 int FSGetAsyncMountStatus (FSVolumeOperation volumeOp, FSMountStatus* status, OSStatus* volumeOpStatus, FSVolumeRefNum* mountedVolumeRefNum, void** clientData);
1218 int FSUnmountVolumeSync (short vRefNum, uint flags, pid_t* dissenter);
1219 int FSUnmountVolumeAsync (short vRefNum, uint flags, FSVolumeOperation volumeOp, void* clientData, FSVolumeUnmountUPP callback, CFRunLoopRef runloop, CFStringRef runloopMode);
1220 int FSGetAsyncUnmountStatus (FSVolumeOperation volumeOp, FSUnmountStatus* status, OSStatus* volumeOpStatus, FSVolumeRefNum* volumeRefNum, pid_t* dissenter, void** clientData);
1221 int FSCancelVolumeOperation (FSVolumeOperation volumeOp);
1222 int FSEjectVolumeSync (short vRefNum, uint flags, pid_t* dissenter);
1223 int FSEjectVolumeAsync (short vRefNum, uint flags, FSVolumeOperation volumeOp, void* clientData, FSVolumeEjectUPP callback, CFRunLoopRef runloop, CFStringRef runloopMode);
1224 int FSGetAsyncEjectStatus (FSVolumeOperation volumeOp, FSEjectStatus* status, OSStatus* volumeOpStatus, FSVolumeRefNum* volumeRefNum, pid_t* dissenter, void** clientData);
1225 int FSCopyDiskIDForVolume (short vRefNum, CFStringRef* diskID);
1226 int FSCopyURLForVolume (short vRefNum, CFURLRef* url);
1227 int FSGetVolumeForDiskID (CFStringRef diskID, FSVolumeRefNum* vRefNum);
1228 int FSCopyDADiskForVolume (short vRefNum, DADiskRef* disk);
1229 int FSGetVolumeForDADisk (DADiskRef disk, FSVolumeRefNum* vRefNum);
1230 int FSCopyObjectSync (FSRef* source, FSRef* destDir, CFStringRef destName, FSRef* target, uint options);
1231 int FSMoveObjectSync (FSRef* source, FSRef* destDir, CFStringRef destName, FSRef* target, uint options);
1232 int FSMoveObjectToTrashSync (FSRef* source, FSRef* target, uint options);
1233 int FSPathCopyObjectSync (char* sourcePath, char* destDirPath, CFStringRef destName, char** targetPath, uint options);
1234 int FSPathMoveObjectSync (char* sourcePath, char* destDirPath, CFStringRef destName, char** targetPath, uint options);
1235 int FSPathMoveObjectToTrashSync (char* sourcePath, char** targetPath, uint options);
1236 uint FSFileOperationGetTypeID ();
1237 FSFileOperationRef FSFileOperationCreate (CFAllocatorRef alloc);
1238 int FSFileOperationScheduleWithRunLoop (FSFileOperationRef fileOp, CFRunLoopRef runLoop, CFStringRef runLoopMode);
1239 int FSFileOperationUnscheduleFromRunLoop (FSFileOperationRef fileOp, CFRunLoopRef runLoop, CFStringRef runLoopMode);
1240 int FSCopyObjectAsync (FSFileOperationRef fileOp, FSRef* source, FSRef* destDir, CFStringRef destName, uint flags, FSFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
1241 int FSMoveObjectAsync (FSFileOperationRef fileOp, FSRef* source, FSRef* destDir, CFStringRef destName, uint flags, FSFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
1242 int FSMoveObjectToTrashAsync (FSFileOperationRef fileOp, FSRef* source, uint flags, FSFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
1243 int FSPathCopyObjectAsync (FSFileOperationRef fileOp, char* sourcePath, char* destDirPath, CFStringRef destName, uint flags, FSPathFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
1244 int FSPathMoveObjectAsync (FSFileOperationRef fileOp, char* sourcePath, char* destDirPath, CFStringRef destName, uint flags, FSPathFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
1245 int FSPathMoveObjectToTrashAsync (FSFileOperationRef fileOp, char* sourcePath, uint flags, FSPathFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
1246 int FSFileOperationCancel (FSFileOperationRef fileOp);
1247 int FSFileOperationCopyStatus (FSFileOperationRef fileOp, FSRef* currentItem, FSFileOperationStage* stage, OSStatus* error, CFDictionaryRef* statusDictionary, void** info);
1248 int FSPathFileOperationCopyStatus (FSFileOperationRef fileOp, char** currentItem, FSFileOperationStage* stage, OSStatus* error, CFDictionaryRef* statusDictionary, void** info);
1249 CFStringRef FSCreateStringFromHFSUniStr (CFAllocatorRef alloc, HFSUniStr255* uniStr);
1250 int FSGetHFSUniStrFromString (CFStringRef theString, HFSUniStr255* uniStr);
1251 uint FSFileSecurityGetTypeID ();
1252 FSFileSecurityRef FSFileSecurityCreate (CFAllocatorRef alloc);
1253 FSFileSecurityRef FSFileSecurityCreateWithFSPermissionInfo (CFAllocatorRef alloc, FSPermissionInfo* permissions);
1254 FSFileSecurityRef FSFileSecurityRefCreateCopy (CFAllocatorRef alloc, FSFileSecurityRef fileSec);
1255 int FSFileSecurityGetOwnerUUID (FSFileSecurityRef fileSec, CFUUIDBytes* owner);
1256 int FSFileSecuritySetOwnerUUID (FSFileSecurityRef fileSec, CFUUIDBytes* owner);
1257 int FSFileSecurityGetGroupUUID (FSFileSecurityRef fileSec, CFUUIDBytes* group);
1258 int FSFileSecuritySetGroupUUID (FSFileSecurityRef fileSec, CFUUIDBytes* group);
1259 int FSFileSecurityCopyAccessControlList (FSFileSecurityRef fileSec, acl_t* accessControlList);
1260 int FSFileSecuritySetAccessControlList (FSFileSecurityRef fileSec, acl_t accessControlList);
1261 int FSFileSecurityGetOwner (FSFileSecurityRef fileSec, UInt32* owner);
1262 int FSFileSecuritySetOwner (FSFileSecurityRef fileSec, uint owner);
1263 int FSFileSecurityGetGroup (FSFileSecurityRef fileSec, UInt32* group);
1264 int FSFileSecuritySetGroup (FSFileSecurityRef fileSec, uint group);
1265 int FSFileSecurityGetMode (FSFileSecurityRef fileSec, UInt16* mode);
1266 int FSFileSecuritySetMode (FSFileSecurityRef fileSec, ushort mode);
1267 int FSGetVolumeParms (short volume, GetVolParmsInfoBuffer* buffer, uint bufferSize);
1268 int FSGetVolumeMountInfoSize (short volume, ByteCount* size);
1269 int FSGetVolumeMountInfo (short volume, char* buffer, uint bufferSize, ByteCount* actualSize);
1270 int FSVolumeMount (char* buffer, FSVolumeRefNum* mountedVolume);
1271 int FSFlushVolume (short vRefNum);
1272 int PBFlushVolumeSync (FSRefParamPtr paramBlock);
1273 int PBFlushVolumeAsync (FSRefParamPtr paramBlock);
1274 int PBFSCopyFileSync (FSRefParamPtr paramBlock);
1275 int PBFSCopyFileAsync (FSRefParamPtr paramBlock);
1276 int FSResolveNodeID (short volume, uint nodeID, FSRefPtr newRef);
1277 int PBFSResolveNodeIDSync (FSRefParamPtr paramBlock);
1278 int PBFSResolveNodeIDAsync (FSRefParamPtr paramBlock);
1279 }