Boolean APSetKey(CFStringRef key)
{
hash = CFSTR("");
blacklist = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
// Create a new key
rsaKey = RSA_new();
// Public exponent is always 3
BN_hex2bn(&rsaKey->e, "3");
CFMutableStringRef mutableKey = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, key);
if (!mutableKey)
return FALSE;
CFIndex maximumCStringLength = CFStringGetMaximumSizeForEncoding(CFStringGetLength(mutableKey), kCFStringEncodingMacRoman) + 1;
char *keyCStringBuffer = malloc(maximumCStringLength);
// Determine if we have a hex or decimal key
CFStringLowercase(mutableKey, NULL);
if (CFStringHasPrefix(mutableKey, CFSTR("0x"))) {
CFStringTrim(mutableKey, CFSTR("0x"));
CFStringGetCString(mutableKey, keyCStringBuffer, maximumCStringLength, kCFStringEncodingMacRoman);
BN_hex2bn(&rsaKey->n, keyCStringBuffer);
}
else {
CFStringGetCString(mutableKey, keyCStringBuffer, maximumCStringLength, kCFStringEncodingMacRoman);
BN_dec2bn(&rsaKey->n, keyCStringBuffer);
}
CFRelease(mutableKey);
free(keyCStringBuffer);
return TRUE;
}
static CFDictionaryRef __DAMountMapCreate2( CFAllocatorRef allocator, struct vsdb * vs )
{
CFStringRef idAsString;
CFMutableDictionaryRef map = NULL;
idAsString = CFStringCreateWithCString( kCFAllocatorDefault, vs->vs_spec, kCFStringEncodingUTF8 );
if ( idAsString )
{
CFTypeRef id;
id = _DAFileSystemCreateUUIDFromString( kCFAllocatorDefault, idAsString );
if ( id )
{
map = CFDictionaryCreateMutable( kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks );
if ( map )
{
CFMutableStringRef options;
options = CFStringCreateMutable( kCFAllocatorDefault, 0 );
if ( options )
{
if ( ( vs->vs_ops & VSDB_PERM ) )
{
CFStringAppend( options, CFSTR( "owners" ) );
CFStringAppend( options, CFSTR( "," ) );
}
else
{
CFStringAppend( options, CFSTR( "noowners" ) );
CFStringAppend( options, CFSTR( "," ) );
}
if ( CFStringGetLength( options ) )
{
CFStringTrim( options, CFSTR( "," ) );
CFDictionarySetValue( map, kDAMountMapMountOptionsKey, options );
}
CFRelease( options );
}
CFDictionarySetValue( map, kDAMountMapProbeIDKey, id );
}
CFRelease( id );
}
CFRelease( idAsString );
}
return map;
}
static void __DAFileSystemProbeCallbackStage1( int status, CFDataRef output, void * parameter )
{
/*
* Process the probe command's completion.
*/
__DAFileSystemProbeContext * context = parameter;
if ( status == FSUR_RECOGNIZED )
{
/*
* Obtain the volume name.
*/
if ( output )
{
CFStringRef string;
string = CFStringCreateFromExternalRepresentation( kCFAllocatorDefault, output, kCFStringEncodingUTF8 );
if ( string )
{
if ( CFStringGetLength( string ) )
{
context->volumeName = CFStringCreateMutableCopy( kCFAllocatorDefault, 0, string );
if ( context->volumeName )
{
CFStringTrim( ( CFMutableStringRef ) context->volumeName, CFSTR( "\n" ) );
}
}
CFRelease( string );
}
}
/*
* Execute the "get UUID" command.
*/
DACommandExecute( context->probeCommand,
kDACommandExecuteOptionCaptureOutput,
___UID_ROOT,
___GID_WHEEL,
__DAFileSystemProbeCallbackStage2,
context,
CFSTR( "-k" ),
context->deviceName,
NULL );
}
else
{
__DAFileSystemProbeCallback( status, context, NULL );
}
}
/* ------------------------------------------------------------------------------------------------------
getCleanedHeaderValue: read FITS header and return striped CFStringRef value.
------------------------------------------------------------------------------------------------------ */
CFStringRef getCleanedHeaderValue(const char* filename, char* keyword) {
char *headerValue = NULL;
headerValue = qfits_query_hdr((const char*)filename, keyword);
// printf("For keyword %s, headerValue is: %s\n", keyword, headerValue);
if (headerValue != NULL) {
CFStringRef cfvalue = CFStringCreateWithCString(kCFAllocatorDefault, headerValue, kCFStringEncodingUTF8);
CFIndex length = CFStringGetLength(cfvalue);
CFMutableStringRef cfmvalue = CFStringCreateMutable(kCFAllocatorDefault, length);
CFStringAppend(cfmvalue, cfvalue);
CFRelease(cfvalue);
CFStringTrim(cfmvalue, CFSTR("'"));
CFStringTrimWhitespace(cfmvalue);
return cfmvalue;
} else {
return NULL;
}
}
CFStringRef
_SC_trimDomain(CFStringRef domain)
{
CFIndex length;
if (!isA_CFString(domain)) {
return NULL;
}
// remove any leading/trailing dots
length = CFStringGetLength(domain);
if ((length > 0) &&
(CFStringFindWithOptions(domain,
CFSTR("."),
CFRangeMake(0, 1),
kCFCompareAnchored,
NULL) ||
CFStringFindWithOptions(domain,
CFSTR("."),
CFRangeMake(0, length),
kCFCompareAnchored|kCFCompareBackwards,
NULL))) {
CFMutableStringRef trimmed;
trimmed = CFStringCreateMutableCopy(NULL, 0, domain);
CFStringTrim(trimmed, CFSTR("."));
domain = (CFStringRef)trimmed;
length = CFStringGetLength(domain);
} else {
CFRetain(domain);
}
if (length == 0) {
CFRelease(domain);
domain = NULL;
}
return domain;
}
/*
* We need to separate the share name and any path component from the URL.
* URL "smb://*****:*****@server" no share name or path.
* URL "smb://*****:*****@server/"no share name or path.
* URL "smb://*****:*****@server/share" just a share name.
* URL "smb://*****:*****@server/share/path" share name and path.
*
* The Share name and Path name will not begin with a slash.
* smb://server/ntfs share = ntfs path = NULL
* smb://ntfs/dir1/dir2 share = ntfs path = dir1/dir2
* smb://server/OPEN%2fSPACE/dir1 share = OPEN%2fSPACE path = dir1
*/
static int GetShareAndPathFromURL(CFURLRef url, CFStringRef *out_share, CFStringRef *out_path)
{
Boolean isAbsolute;
CFArrayRef userArray = NULL;
CFMutableArrayRef userArrayM = NULL;
CFStringRef share = CFURLCopyStrictPath(url, &isAbsolute);
CFStringRef path = NULL;
*out_share = NULL;
*out_path = NULL;
/* We have an empty share treat it like no share */
if (share && (CFStringGetLength(share) == 0)) {
CFRelease(share);
share = NULL;
}
/* Since there is no share name we have nothing left to do. */
if (!share)
return 0;
userArray = CFStringCreateArrayBySeparatingStrings(NULL, share, CFSTR("/"));
if (userArray && (CFArrayGetCount(userArray) > 1))
userArrayM = CFArrayCreateMutableCopy(NULL, CFArrayGetCount(userArray), userArray);
if (userArray)
CFRelease(userArray);
if (userArrayM) {
CFMutableStringRef newshare; /* Just in case something goes wrong */
newshare = CFStringCreateMutableCopy(NULL, 0, (CFStringRef)CFArrayGetValueAtIndex(userArrayM, 0));
if (newshare) {
CFStringTrim(newshare, CFSTR("/")); /* Remove any trailing slashes */
CreateStringByReplacingPercentEscapesUTF8((CFStringRef *) &newshare, CFSTR("/"));
}
CFArrayRemoveValueAtIndex(userArrayM, 0);
/* Now remove any trailing slashes */
path = CFStringCreateByCombiningStrings(NULL, userArrayM, CFSTR("/"));
if (path && (CFStringGetLength(path) == 0)) {
CFRelease(path); /* Empty path remove it */
path = NULL;
}
if (path) {
CFMutableStringRef newpath = CFStringCreateMutableCopy(NULL, 0, path);
if (newpath) {
CFStringTrim(newpath, CFSTR("/")); /* Remove any trailing slashes */
CFRelease(path);
path = newpath;
}
}
if (path) {
CreateStringByReplacingPercentEscapesUTF8(&path, CFSTR("/"));
LogCFString(path, "Path", __FUNCTION__, __LINE__);
}
CFRelease(userArrayM);
/* Something went wrong use the original value */
if (newshare) {
CFRelease(share);
share = newshare;
}
} else
CreateStringByReplacingPercentEscapesUTF8(&share, CFSTR("/"));
/*
* The above routines will not un-precent escape out slashes. We only allow for the cases
* where the share name is a single slash. Slashes are treated as delemiters in the path name.
* So if the share name has a single 0x2f then make it a slash. This means you can't have
* a share name whos name is 0x2f, not likley to happen.
*/
if (share && ( kCFCompareEqualTo == CFStringCompare (share, CFSTR("0x2f"), kCFCompareCaseInsensitive) )) {
CFRelease(share);
share = CFStringCreateCopy(NULL, CFSTR("/"));
}
if (share && (CFStringGetLength(share) >= SMB_MAXSHARENAMELEN)) {
CFRelease(share);
if (path)
CFRelease(path);
return ENAMETOOLONG;
}
*out_share = share;
*out_path = path;
return 0;
}
static CFDictionaryRef __DAMountMapCreate1( CFAllocatorRef allocator, struct fstab * fs )
{
CFMutableDictionaryRef map = NULL;
if ( strcmp( fs->fs_type, FSTAB_SW ) )
{
char * idAsCString = fs->fs_spec;
strsep( &idAsCString, "=" );
if ( idAsCString )
{
CFStringRef idAsString;
idAsString = CFStringCreateWithCString( kCFAllocatorDefault, idAsCString, kCFStringEncodingUTF8 );
if ( idAsString )
{
CFTypeRef id = NULL;
if ( strcmp( fs->fs_spec, "UUID" ) == 0 )
{
id = ___CFUUIDCreateFromString( kCFAllocatorDefault, idAsString );
}
else if ( strcmp( fs->fs_spec, "LABEL" ) == 0 )
{
id = CFRetain( idAsString );
}
else if ( strcmp( fs->fs_spec, "DEVICE" ) == 0 )
{
id = ___CFDictionaryCreateFromXMLString( kCFAllocatorDefault, idAsString );
}
if ( id )
{
map = CFDictionaryCreateMutable( kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks );
if ( map )
{
CFMutableStringRef options;
options = CFStringCreateMutable( kCFAllocatorDefault, 0 );
if ( options )
{
char * argument = NULL;
char * arguments = fs->fs_mntops;
CFBooleanRef automatic = NULL;
while ( ( argument = strsep( &arguments, "," ) ) )
{
if ( strcmp( argument, "auto" ) == 0 )
{
automatic = kCFBooleanTrue;
}
else if ( strcmp( argument, "noauto" ) == 0 )
{
automatic = kCFBooleanFalse;
}
else
{
CFStringAppendCString( options, argument, kCFStringEncodingUTF8 );
CFStringAppendCString( options, ",", kCFStringEncodingUTF8 );
}
}
if ( automatic )
{
CFDictionarySetValue( map, kDAMountMapMountAutomaticKey, automatic );
}
if ( CFStringGetLength( options ) )
{
CFStringTrim( options, CFSTR( "," ) );
CFDictionarySetValue( map, kDAMountMapMountOptionsKey, options );
}
CFRelease( options );
}
if ( strcmp( fs->fs_file, "none" ) )
{
CFURLRef path;
path = CFURLCreateFromFileSystemRepresentation( kCFAllocatorDefault, ( void * ) fs->fs_file, strlen( fs->fs_file ), TRUE );
if ( path )
{
CFDictionarySetValue( map, kDAMountMapMountPathKey, path );
CFRelease( path );
}
}
if ( strcmp( fs->fs_vfstype, "auto" ) )
{
CFStringRef kind;
kind = CFStringCreateWithCString( kCFAllocatorDefault, fs->fs_vfstype, kCFStringEncodingUTF8 );
if ( kind )
{
CFDictionarySetValue( map, kDAMountMapProbeKindKey, kind );
CFRelease( kind );
}
}
CFDictionarySetValue( map, kDAMountMapProbeIDKey, id );
}
CFRelease( id );
}
CFRelease( idAsString );
}
}
}
return map;
}
void DAMountWithArguments( DADiskRef disk, CFURLRef mountpoint, DAMountCallback callback, void * callbackContext, ... )
{
/*
* Mount the specified volume. A status of 0 indicates success. All arguments in
* the argument list shall be of type CFStringRef. The argument list must be NULL
* terminated.
*/
CFStringRef argument = NULL;
va_list arguments;
CFBooleanRef automatic = kCFBooleanTrue;
CFBooleanRef check = NULL;
__DAMountCallbackContext * context = NULL;
CFIndex count = 0;
DAFileSystemRef filesystem = DADiskGetFileSystem( disk );
Boolean force = FALSE;
CFIndex index = 0;
CFDictionaryRef map = NULL;
CFMutableStringRef options = NULL;
int status = 0;
DALogDebugHeader( "%s -> %s", gDAProcessNameID, gDAProcessNameID );
/*
* Initialize our minimal state.
*/
if ( mountpoint )
{
CFRetain( mountpoint );
}
/*
* Prepare the mount context.
*/
context = malloc( sizeof( __DAMountCallbackContext ) );
if ( context == NULL )
{
status = ENOMEM;
goto DAMountWithArgumentsErr;
}
/*
* Prepare the mount options.
*/
options = CFStringCreateMutable( kCFAllocatorDefault, 0 );
if ( options == NULL )
{
status = ENOMEM;
goto DAMountWithArgumentsErr;
}
va_start( arguments, callbackContext );
while ( ( argument = va_arg( arguments, CFStringRef ) ) )
{
if ( CFEqual( argument, kDAFileSystemMountArgumentForce ) )
{
force = TRUE;
}
else if ( CFEqual( argument, CFSTR( "automatic" ) ) )
{
automatic = NULL;
check = kCFBooleanTrue;
}
else
{
CFStringAppend( options, argument );
CFStringAppend( options, CFSTR( "," ) );
}
}
va_end( arguments );
CFStringTrim( options, CFSTR( "," ) );
///w:start
context->automatic = ( automatic == NULL ) ? TRUE : FALSE;
///w:stop
/*
* Determine whether the volume is to be updated.
*/
if ( DAMountContainsArgument( options, kDAFileSystemMountArgumentUpdate ) )
{
if ( mountpoint )
{
status = EINVAL;
goto DAMountWithArgumentsErr;
}
mountpoint = DADiskGetDescription( disk, kDADiskDescriptionVolumePathKey );
if ( mountpoint == NULL )
{
status = EINVAL;
goto DAMountWithArgumentsErr;
}
CFRetain( mountpoint );
}
/*
* Scan the mount map list.
*/
count = CFArrayGetCount( gDAMountMapList1 );
for ( index = 0; index < count; index++ )
{
map = CFArrayGetValueAtIndex( gDAMountMapList1, index );
if ( map )
{
CFTypeRef id;
CFStringRef kind;
id = CFDictionaryGetValue( map, kDAMountMapProbeIDKey );
kind = CFDictionaryGetValue( map, kDAMountMapProbeKindKey );
if ( kind )
{
/*
* Determine whether the volume kind matches.
*/
if ( CFEqual( kind, DAFileSystemGetKind( filesystem ) ) == FALSE )
{
continue;
}
}
if ( CFGetTypeID( id ) == CFUUIDGetTypeID( ) )
{
/*
* Determine whether the volume UUID matches.
*/
if ( DADiskCompareDescription( disk, kDADiskDescriptionVolumeUUIDKey, id ) == kCFCompareEqualTo )
{
break;
}
}
else if ( CFGetTypeID( id ) == CFStringGetTypeID( ) )
{
/*
* Determine whether the volume name matches.
*/
if ( DADiskCompareDescription( disk, kDADiskDescriptionVolumeNameKey, id ) == kCFCompareEqualTo )
{
break;
}
}
else if ( CFGetTypeID( id ) == CFDictionaryGetTypeID( ) )
{
boolean_t match = FALSE;
/*
* Determine whether the device description matches.
*/
IOServiceMatchPropertyTable( DADiskGetIOMedia( disk ), id, &match );
if ( match )
{
break;
}
}
}
}
/*
* Process the map.
*/
if ( index < count )
{
CFStringRef string;
/*
* Determine whether the volume is to be mounted.
*/
if ( automatic == NULL )
{
automatic = CFDictionaryGetValue( map, kDAMountMapMountAutomaticKey );
if ( automatic == kCFBooleanTrue )
{
DADiskSetState( disk, _kDADiskStateMountAutomatic, TRUE );
DADiskSetState( disk, _kDADiskStateMountAutomaticNoDefer, TRUE );
}
}
/*
* Prepare the mount options.
*/
string = CFDictionaryGetValue( map, kDAMountMapMountOptionsKey );
if ( string )
{
CFStringInsert( options, 0, CFSTR( "," ) );
CFStringInsert( options, 0, string );
}
/*
* Prepare the mount point.
*/
if ( mountpoint == NULL )
{
mountpoint = CFDictionaryGetValue( map, kDAMountMapMountPathKey );
if ( mountpoint )
{
CFRetain( mountpoint );
}
}
}
/*
* Scan the mount map list.
*/
count = CFArrayGetCount( gDAMountMapList2 );
for ( index = 0; index < count; index++ )
{
map = CFArrayGetValueAtIndex( gDAMountMapList2, index );
if ( map )
{
CFTypeRef id;
id = CFDictionaryGetValue( map, kDAMountMapProbeIDKey );
/*
* Determine whether the volume UUID matches.
*/
if ( DADiskCompareDescription( disk, kDADiskDescriptionVolumeUUIDKey, id ) == kCFCompareEqualTo )
{
break;
}
}
}
/*
* Process the map.
*/
if ( index < count )
{
CFStringRef string;
/*
* Prepare the mount options.
*/
string = CFDictionaryGetValue( map, kDAMountMapMountOptionsKey );
if ( string )
{
CFStringInsert( options, 0, CFSTR( "," ) );
CFStringInsert( options, 0, string );
}
}
/*
* Determine whether the volume is to be mounted.
*/
if ( automatic == NULL )
{
if ( DADiskGetState( disk, _kDADiskStateMountAutomatic ) )
{
if ( DADiskGetState( disk, _kDADiskStateMountAutomaticNoDefer ) )
{
automatic = kCFBooleanTrue;
}
}
else
{
automatic = kCFBooleanFalse;
}
if ( automatic == NULL )
{
if ( gDAConsoleUserList == NULL )
{
if ( DAMountGetPreference( disk, kDAMountPreferenceDefer ) )
{
automatic = kCFBooleanFalse;
}
}
}
}
if ( automatic == kCFBooleanFalse )
{
status = ECANCELED;
goto DAMountWithArgumentsErr;
}
/*
* Prepare the mount options.
*/
if ( DADiskGetDescription( disk, kDADiskDescriptionMediaWritableKey ) == kCFBooleanFalse )
{
CFStringInsert( options, 0, CFSTR( "," ) );
CFStringInsert( options, 0, kDAFileSystemMountArgumentNoWrite );
}
if ( DAMountGetPreference( disk, kDAMountPreferenceTrust ) == FALSE )
{
CFStringInsert( options, 0, CFSTR( "," ) );
CFStringInsert( options, 0, kDAFileSystemMountArgumentNoSetUserID );
CFStringInsert( options, 0, CFSTR( "," ) );
CFStringInsert( options, 0, kDAFileSystemMountArgumentNoOwnership );
CFStringInsert( options, 0, CFSTR( "," ) );
CFStringInsert( options, 0, kDAFileSystemMountArgumentNoDevice );
}
///w:start
if ( CFEqual( DAFileSystemGetKind( filesystem ), CFSTR( "hfs" ) ) )
{
___CFStringInsertFormat( options, 0, CFSTR( "-m=%o," ), 0755 );
if ( DADiskGetUserGID( disk ) )
{
___CFStringInsertFormat( options, 0, CFSTR( "-g=%d," ), DADiskGetUserGID( disk ) );
}
else
{
___CFStringInsertFormat( options, 0, CFSTR( "-g=%d," ), ___GID_UNKNOWN );
}
if ( DADiskGetUserUID( disk ) )
{
___CFStringInsertFormat( options, 0, CFSTR( "-u=%d," ), DADiskGetUserUID( disk ) );
}
else
{
___CFStringInsertFormat( options, 0, CFSTR( "-u=%d," ), ___UID_UNKNOWN );
}
}
///w:stop
CFStringTrim( options, CFSTR( "," ) );
/*
* Determine whether the volume is to be repaired.
*/
if ( check == NULL )
{
if ( DAMountContainsArgument( options, kDAFileSystemMountArgumentNoWrite ) )
{
check = kCFBooleanFalse;
}
else
{
check = kCFBooleanTrue;
}
}
if ( check == kCFBooleanFalse )
{
if ( DADiskGetState( disk, kDADiskStateRequireRepair ) )
{
if ( force == FALSE )
{
status = ___EDIRTY;
goto DAMountWithArgumentsErr;
}
}
}
if ( check == kCFBooleanTrue )
{
if ( DADiskGetState( disk, kDADiskStateRequireRepair ) == FALSE )
{
check = kCFBooleanFalse;
}
}
/*
* Repair the volume.
*/
CFRetain( disk );
context->assertionID = kIOPMNullAssertionID;
context->callback = callback;
context->callbackContext = callbackContext;
context->disk = disk;
context->force = force;
context->mountpoint = mountpoint;
context->options = options;
if ( check == kCFBooleanTrue )
{
DALogDebug( " repaired disk, id = %@, ongoing.", disk );
IOPMAssertionCreateWithDescription( kIOPMAssertionTypePreventUserIdleSystemSleep,
CFSTR( _kDADaemonName ),
NULL,
NULL,
NULL,
0,
NULL,
&context->assertionID );
DAFileSystemRepair( DADiskGetFileSystem( disk ),
DADiskGetDevice( disk ),
__DAMountWithArgumentsCallbackStage1,
context );
}
else
{
__DAMountWithArgumentsCallbackStage1( ECANCELED, context );
}
DAMountWithArgumentsErr:
if ( status )
{
if ( context )
{
free( context );
}
if ( mountpoint )
{
CFRelease( mountpoint );
}
if ( options )
{
CFRelease( options );
}
if ( callback )
{
( callback )( status, NULL, callbackContext );
}
}
}
void DAFileSystemMountWithArguments( DAFileSystemRef filesystem,
CFURLRef device,
CFURLRef mountpoint,
uid_t userUID,
gid_t userGID,
DAFileSystemCallback callback,
void * callbackContext,
... )
{
/*
* Mount the specified volume. A status of 0 indicates success. All arguments in
* the argument list shall be of type CFStringRef. The argument list must be NULL
* terminated.
*/
CFStringRef argument = NULL;
va_list arguments;
CFURLRef command = NULL;
__DAFileSystemContext * context = NULL;
CFStringRef devicePath = NULL;
CFStringRef mountpointPath = NULL;
CFMutableStringRef options = NULL;
int status = 0;
/*
* Prepare to mount the volume.
*/
command = CFURLCreateWithFileSystemPath( kCFAllocatorDefault, CFSTR( "/sbin/mount" ), kCFURLPOSIXPathStyle, FALSE );
if ( command == NULL ) { status = ENOTSUP; goto DAFileSystemMountErr; }
context = malloc( sizeof( __DAFileSystemContext ) );
if ( context == NULL ) { status = ENOMEM; goto DAFileSystemMountErr; }
devicePath = CFURLCopyFileSystemPath( device, kCFURLPOSIXPathStyle );
if ( devicePath == NULL ) { status = EINVAL; goto DAFileSystemMountErr; }
mountpointPath = CFURLCopyFileSystemPath( mountpoint, kCFURLPOSIXPathStyle );
if ( mountpointPath == NULL ) { status = EINVAL; goto DAFileSystemMountErr; }
options = CFStringCreateMutable( kCFAllocatorDefault, 0 );
if ( options == NULL ) { status = ENOMEM; goto DAFileSystemMountErr; }
/*
* Prepare the mount options.
*/
va_start( arguments, callbackContext );
while ( ( argument = va_arg( arguments, CFStringRef ) ) )
{
CFStringAppend( options, argument );
CFStringAppend( options, CFSTR( "," ) );
}
va_end( arguments );
CFStringTrim( options, CFSTR( "," ) );
/*
* Execute the mount command.
*/
context->callback = callback;
context->callbackContext = callbackContext;
if ( CFStringGetLength( options ) )
{
DACommandExecute( command,
kDACommandExecuteOptionDefault,
userUID,
userGID,
__DAFileSystemCallback,
context,
CFSTR( "-t" ),
DAFileSystemGetKind( filesystem ),
CFSTR( "-o" ),
options,
devicePath,
mountpointPath,
NULL );
}
else
{
DACommandExecute( command,
kDACommandExecuteOptionDefault,
userUID,
userGID,
__DAFileSystemCallback,
context,
CFSTR( "-t" ),
DAFileSystemGetKind( filesystem ),
devicePath,
mountpointPath,
NULL );
}
DAFileSystemMountErr:
if ( command ) CFRelease( command );
if ( devicePath ) CFRelease( devicePath );
if ( mountpointPath ) CFRelease( mountpointPath );
if ( options ) CFRelease( options );
if ( status )
{
if ( context ) free( context );
if ( callback )
{
( callback )( status, callbackContext );
}
}
}
