static void _device_info( string_t p,const char * device ) { char * path ; if( device == NULL ){ StringMultipleAppend( p,"\n device: \t","Nil","\n loop: \t","Nil",NULL ) ; }else if( StringPrefixEqual( device,"/dev/loop" ) ){ path = zuluCryptLoopDeviceAddress_1( device ) ; if( path != NULL ){ StringMultipleAppend( p,"\n device: \t",device,"\n loop: \t",path,NULL ) ; StringFree( path ) ; }else{ StringMultipleAppend( p,"\n device: \t",device,"\n loop: \tNil",NULL ) ; } }else{ /* * zuluCryptResolvePath() is defined in resolve_path.c */ path = zuluCryptResolvePath( device ) ; StringMultipleAppend( p,"\n device: \t",path,"\n loop: \tNil",NULL ) ; StringFree( path ) ; } }
static string_t _resolve_path_2( const vInfo * e ) { /* * zuluCryptResolvePath_2() is defined in resolve_paths.c */ string_t st = zuluCryptResolvePath_2( e->device ) ; StringMultipleAppend( st," ",e->mountPoint," ",e->fileSystem," ",e->mountOptions,NULL ) ; return st ; }
static string_t _create_mount_point_1( const char * device,uid_t uid,string_t path,int need_privileges ) { string_t st ; char * loop_path = NULL ; if( StringPrefixEqual( device,"/dev/loop" ) ){ /* * zuluCryptLoopDeviceAddress_1() is defined in ../lib/create_loop_device.c */ device = loop_path = zuluCryptLoopDeviceAddress_1( device ) ; } StringMultipleAppend( path,device + StringLastIndexOfChar_1( device,'/' ) + 1,NULL ) ; st = _create_path( uid,path,need_privileges ) ; StringFree( loop_path ) ; return st ; }
static void _get_file_system_options_from_config_file( const char * device,string_t st ) { char * f ; const char * e ; StringListIterator it ; StringListIterator end ; string_t xt = StringGetFromFile( "/etc/zuluCrypt/fs_options" ) ; stringList_t stl = StringListStringSplit( xt,'\n' ) ; stringList_t stz ; StringDelete( &xt ) ; f = _get_uuid_from_device( device ) ; StringListGetIterators( stl,&it,&end ) ; while( it != end ){ e = StringRemoveString( *it,"\"" ) ; it++ ; if( StringPrefixMatch( e,"UUID=",5 ) ){ if( StringPrefixEqual( e + 5,f ) ){ stz = StringListSplit( e,' ' ) ; e = StringListContentAtSecondPlace( stz ) ; StringMultipleAppend( st,",",e,NULL ) ; StringListDelete( &stz ) ; break ; } } } StringListDelete( &stl ) ; StringFree( f ) ; }
static string_t _get_crypto_info_from_tcplay( const char * mapper ) { int key_size ; int ro ; int64_t offset ; tc_api_task task ; char buff[ SIZE ] ; char * buffer = buff ; const char * z ; string_t p = StringVoid ; string_t q ; if( tc_api_initialize() ){ if( tc_api_task_initialize( &task,"info_mapped" ) ){ p = String( mapper ) ; mapper = mapper + StringLastIndexOfChar_1( mapper,'/' ) + 1 ; tc_api_task_set( task,"map_name",mapper ) ; tc_api_task_do( task ) ; tc_api_task_info_get( task,"status",sizeof( buff ),buff ) ; StringMultipleAppend( p," is ",buff,".",NULL ) ; if( StringAtLeastOneMatch_1( buff,"active","active and is in use",NULL ) ){ tc_api_task_info_get( task,"type",sizeof( buff ),buff ) ; q = String( buff ) ; StringMultipleAppend( p," \n type: \t",StringToLowerCase( q ),NULL ) ; StringDelete( &q ) ; tc_api_task_info_get( task,"cipher",sizeof( buff ),buff ) ; /* * zuluCryptConvertCipher() is defined in create_tcrypt.c */ StringMultipleAppend( p,"\n cipher:\t",zuluCryptConvertCipher( buff ),"-xts-plain64",NULL ) ; tc_api_task_info_get( task,"key_bits",sizeof( key_size ),&key_size ) ; z = StringIntToString_1( buffer,SIZE,key_size ) ; StringMultipleAppend( p,"\n keysize:\t",z," bits",NULL ) ; tc_api_task_info_get( task,"iv_offset",sizeof( offset ),&offset ) ; z = StringIntToString_1( buffer,SIZE,offset / 512 ) ; StringMultipleAppend( p,"\n offset:\t",z," sectors",NULL ) ; zuluCryptFormatSize( offset,buffer,SIZE ) ; StringMultipleAppend( p," / ",buffer,NULL ) ; tc_api_task_info_get( task,"device",sizeof( buff ),buff ) ; _device_info( p,buff ) ; tc_api_task_info_get( task,"mode",sizeof( ro ),&ro ) ; if( ro ){ StringAppend( p,"\n mode: \tread only" ) ; }else{ StringAppend( p,"\n mode: \tread and write" ) ; } StringAppend( p,"\n active slots:\tNil" ) ; } tc_api_task_uninit( task ) ; } tc_api_uninit() ; } return p ; }
static string_t _get_crypto_info_from_cryptsetup( const char * mapper ) { char buff[ SIZE ] ; char * buffer = buff ; const char * z ; const char * type ; uint64_t e ; string_t q ; string_t p ; int k ; int i = 0 ; int j ; crypt_status_info info ; struct crypt_device * cd ; struct crypt_active_device cad ; if( crypt_init_by_name( &cd,mapper ) != 0 ){ return StringVoid ; } p = String( mapper ) ; info = crypt_status( cd,mapper ) ; switch( info ){ case CRYPT_INACTIVE : StringAppend( p," is inactive.\n" ) ; break ; case CRYPT_INVALID : StringAppend( p," is invalid.\n" ) ; break ; case CRYPT_ACTIVE : StringAppend( p," is active.\n" ) ; break ; case CRYPT_BUSY : StringAppend( p," is active and is in use.\n" ) ; break ; default : StringAppend( p," is invalid.\n" ) ; } if( info == CRYPT_ACTIVE || info == CRYPT_BUSY ){ StringAppend( p," type: \t" ) ; type = crypt_get_type( cd ) ; if( type != NULL ){ q = String( type ) ; StringAppend( p,StringToLowerCase( q ) ) ; StringDelete( &q ) ; }else{ q = _get_type_from_udev_1( mapper ) ; StringAppendString( p,q ) ; StringDelete( &q ) ; } z = crypt_get_cipher( cd ) ; if( z != NULL ){ StringMultipleAppend( p,"\n cipher:\t",z,"-",NULL ) ; }else{ StringAppend( p,"\n cipher:\tNil-" ) ; } z = crypt_get_cipher_mode( cd ) ; if( z != NULL ){ StringAppend( p,z ) ; }else{ StringAppend( p,"Nil" ) ; } z = StringIntToString_1( buffer,SIZE,8 * crypt_get_volume_key_size( cd ) ) ; StringMultipleAppend( p,"\n keysize:\t",z," bits",NULL ) ; e = crypt_get_data_offset( cd ) ; z = StringIntToString_1( buffer,SIZE,e ) ; StringMultipleAppend( p,"\n offset:\t",z," sectors",NULL ) ; zuluCryptFormatSize( e * 512,buffer,SIZE ) ; StringMultipleAppend( p," / ",buffer,NULL ) ; _device_info( p,crypt_get_device_name( cd ) ) ; crypt_get_active_device( NULL,mapper,&cad ) ; if( cad.flags == 1 ){ StringAppend( p,"\n mode: \tread only" ) ; }else{ StringAppend( p,"\n mode: \tread and write" ) ; } k = crypt_keyslot_max( crypt_get_type( cd ) ) ; if( k > 0 ){ i = 0 ; for( j = 0 ; j < k ; j++ ){ switch( crypt_keyslot_status( cd,j ) ){ case CRYPT_SLOT_ACTIVE_LAST : i++ ; break ; case CRYPT_SLOT_ACTIVE : i++ ; break ; default : ; } } StringMultipleAppend( p,"\n active slots:\t",StringIntToString_1( buffer,SIZE,i ),NULL ) ; StringMultipleAppend( p," / ",StringIntToString_1( buffer,SIZE,k ),NULL ) ; }else{ StringAppend( p,"\n active slots:\tNil" ) ; } } crypt_free( cd ) ; return p ; }
void zuluCryptFileSystemProperties( string_t p,const char * mapper,const char * m_point ) { const char * e ; blkid_probe blkid ; struct statvfs vfs ; u_int64_t total ; u_int64_t used ; u_int64_t unused ; u_int64_t block_size ; char buff[ SIZE ] ; char * buffer = buff ; string_t q ; ssize_t index ; struct stat statstr ; blkid = blkid_new_probe_from_filename( mapper ) ; if( blkid == NULL ){ return ; } blkid_do_probe( blkid ) ; if( blkid_probe_lookup_value( blkid,"TYPE",&e,NULL ) == 0 ){ StringMultipleAppend( p,"\n file system:\t",e,NULL ) ; }else{ StringAppend( p,"\n file system:\tNil" ) ; } blkid_free_probe( blkid ) ; if( statvfs( m_point,&vfs ) != 0 ){ return ; } block_size = vfs.f_frsize ; total = block_size * vfs.f_blocks ; unused = block_size * vfs.f_bavail ; used = total - unused ; zuluCryptFormatSize( total,buffer,SIZE ) ; StringMultipleAppend( p,"\n total space:\t",buffer,NULL ) ; zuluCryptFormatSize( used,buffer,SIZE ) ; StringMultipleAppend( p,"\n used space:\t",buffer,NULL ) ; zuluCryptFormatSize( unused,buffer,SIZE ) ; StringMultipleAppend( p,"\n free space:\t",buffer,NULL ) ; if( used == total ){ StringAppend( p,"\n used%: \t100%\n" ) ; }else if( used == 0 ){ StringAppend( p,"\n used%: \t0%\n" ) ; }else{ snprintf( buff,SIZE,"%.2f%%",100 * ( ( float ) used / ( float ) total ) ) ; StringMultipleAppend( p,"\n used%: \t",buff,"\n",NULL ) ; } buffer = zuluCryptGetUUIDFromMapper( mapper ) ; StringAppend( p,buffer ) ; StringFree( buffer ) ; StringMultipleAppend( p,"\n mount point1:\t",m_point,NULL ) ; q = String( m_point ) ; index = StringLastIndexOfChar( q,'/' ) ; if( index == -1 ){ StringAppend( p,"\n mount point2:\tNil" ) ; }else{ StringRemoveLeft( q,index ) ; e = StringPrepend( q,"/run/media/public" ) ; if( stat( e,&statstr ) == 0 ){ StringMultipleAppend( p,"\n mount point2:\t",e,NULL ) ; }else{ StringAppend( p,"\n mount point2:\tNil" ) ; } } StringDelete( &q ) ; }
int zuluCryptOpenVolume( const char * dev,const char * mapper, const char * m_point,uid_t id,unsigned long m_opts, const char * fs_opts,const char * pass,size_t pass_size ) { int h ; string_t p = StringVoid ; string_t q = StringVoid ; int lmode ; int fd ; const char * mode ; const char * mapper_1 ; /* * zuluCryptPathIsNotValid() is defined in is_path_valid.c */ if( zuluCryptPathIsNotValid( dev ) ){ return 3 ; } /* * zuluCryptMapperPrefix() is defined in create_mapper_name.c */ p = String( zuluCryptMapperPrefix() ) ; mapper_1 = StringMultipleAppend( p,"/",mapper,END ) ; /* * zuluCryptPathIsValid() is defined in is_path_valid.c */ if( zuluCryptPathIsValid( mapper_1 ) ){ return zuluExit( 2,p ) ; } if( m_opts & MS_RDONLY ){ lmode = O_RDONLY ; mode = "ro" ; }else{ lmode = O_RDWR ; mode = "rw" ; } if( StringPrefixMatch( dev,"/dev/",5 ) ){ h = _open_mapper( dev,mapper,mode,pass,pass_size ) ; }else{ /* * zuluCryptAttachLoopDeviceToFile() is defined in create_loop_device.c */ if( zuluCryptAttachLoopDeviceToFile( dev,lmode,&fd,&q ) ){ dev = StringContent( q ) ; h = _open_mapper( dev,mapper,mode,pass,pass_size ) ; close( fd ) ; StringDelete( &q ) ; }else{ h = 1 ; } } switch( h ){ case 1 : return zuluExit( 4,p ) ; case 2 : return zuluExit( 8,p ) ; case 3 : return zuluExit( 3,p ) ; } if( m_point != NULL ){ /* * zuluCryptMountVolume() is defined in mount_volume.c */ h = zuluCryptMountVolume( mapper_1,m_point,m_opts,fs_opts,id ) ; if( h != 0 ){ /* * zuluCryptCloseMapper() is defined in close_mapper.c */ if( zuluCryptCloseMapper( mapper_1 ) != 0 ){ h = 15 ; } } } return zuluExit( h,p ) ; }
static string_t set_mount_options( m_struct * mst ) { /* * zuluCryptGetMountOptionsFromFstab() is defined in parse_fstab.c */ string_t opt = zuluCryptGetMountOptionsFromFstab( mst->device,MOUNTOPTIONS,mst->uid ) ; int fsFamily = fs_family( mst->fs ) ; const char * f[] = { "nouser","users","user","defaults","noauto","auto","nodev","dev", "noexec","exec","nosuid","suid","bind","mandlock","move","noatime","nodiratime","remount","silent", "synchronous",NULL } ; const char ** z = f ; const char * e ; if( opt == StringVoid ){ opt = String( "" ) ; StringAppend( opt,mst->fs_flags ) ; }else{ if( StringContains( opt,"ro" ) ){ mst->m_flags |= MS_RDONLY ; } StringMultipleAppend( opt,",",mst->fs_flags,END ) ; } _get_file_system_options_from_config_file( mst->device,opt ) ; if( fsFamily == 1 ){ if( !StringContains( opt,"dmask=" ) ){ StringAppend( opt,",dmask=0000" ) ; } if( !StringContains( opt,"umask=" ) ){ StringAppend( opt,",umask=0000" ) ; } if( !StringContains( opt,"uid=" ) ){ StringAppend( opt,",uid=" ) ; StringAppendInt( opt,mst->uid ) ; } if( !StringContains( opt,"gid=" ) ){ StringAppend( opt,",gid=" ) ; StringAppendInt( opt,mst->uid ) ; } if( !StringContains( opt,"fmask=" ) ){ StringAppend( opt,",fmask=0111" ) ; } if( StringsAreEqual( mst->fs,"vfat" ) ){ if( !StringContains( opt,"flush" ) ){ StringAppend( opt,",flush" ) ; } if( !StringContains( opt,"shortname=" ) ){ StringAppend( opt,",shortname=mixed" ) ; } } }else if( fsFamily == 2 ){ if( !StringContains( opt,"uid=" ) ){ StringAppend( opt,",uid=" ) ; StringAppendInt( opt,mst->uid ) ; } if( !StringContains( opt,"gid=" ) ){ StringAppend( opt,",gid=" ) ; StringAppendInt( opt,mst->uid ) ; } }else if( fsFamily == 3 ){ mst->m_flags |= MS_RDONLY ; }else{ /* * ext file systems and raiserfs among others go here * we dont set any options for them. */ ; } /* * remove mount options to leave only file system options */ while( 1 ){ e = *z ; z++ ; if( e == NULL ){ break ; }else{ StringRemoveString( opt,e ) ; } } /* * remove below two now because we are going to add them below,reason for removing them * and readding them is because we want to make sure they are at the beginning of the string */ StringRemoveString( opt,"ro" ) ; StringRemoveString( opt,"rw" ) ; if( mst->m_flags & MS_RDONLY ){ StringPrepend( opt,"ro," ) ; }else{ StringPrepend( opt,"rw," ) ; } mst->opts = _remove_duplicates( opt ) ; return opt; }
int zuluCryptEXEOpenVolume( const struct_opts * opts,const char * mapping_name,uid_t uid ) { int share = opts->share ; int open_mount = opts->open_mount ; const char * device = opts->device ; const char * mount_point = opts->mount_point ; const char * m_opts = opts->m_opts ; const char * source = opts->key_source ; const char * pass = opts->key ; const char * plugin_path = opts->plugin_path ; const char * fs_opts = opts->fs_opts ; const char * offset = opts->offset ; const char * const * tcrypt_keyfiles = opts->tcrypt_multiple_keyfiles ; /* * Below is a form of memory management.All strings are collected in a stringlist object to easily delete them * when the function returns.This allows for the function to have multiple exit points without risks of leaking * memory from manually examining each exit point to make sure all strings are deleted or go with multiple goto * code deleting blocks to take into account different exit points. */ stringList_t stl ; string_t * stringArray = StringListArray( &stl,6 ) ; string_t * passphrase = &stringArray[ 0 ] ; string_t * m_name = &stringArray[ 1 ] ; string_t * data = &stringArray[ 2 ] ; string_t * m_point = &stringArray[ 3 ] ; string_t * mapper = &stringArray[ 4 ] ; string_t * mapper_path = &stringArray[ 5 ] ; const char * key = NULL ; const char * mapper_name ; const char * e ; size_t key_len = 0 ; int st = 0 ; stringList_t stz ; tvcrypt v_info ; unsigned long m_flags ; int tcrypt_keyfile = 0 ; const char * uuid ; char * device_path ; /* * open_struct_t is declared in ../lib/include.h */ open_struct_t volume ; struct stat statstr ; /* * zuluCryptVolumeIsInSystemVolumeList() is defined in volumes.c */ if( zuluCryptVolumeIsInSystemVolumeList( device ) ){ /* * check permissions only if volume is explicity mentioned as system. * This is an exception to avoid some udev bad behaviors on udev enabled build */ if( !zuluCryptUserIsAMemberOfAGroup( uid,"zulucrypt" ) ){ return zuluExit( 22,device,mount_point,stl ) ; } } if( m_opts == NULL ){ m_opts = "rw" ; } /* * zuluCryptMountFlagsAreNotCorrect() is defined in ./mount_flags.c */ if( zuluCryptMountFlagsAreNotCorrect( m_opts,uid,&m_flags ) ){ return zuluExit( 5,device,mount_point,stl ) ; } if( StringHasComponent( m_opts,"rw" ) ){ /* * zuluCryptSecurityDeviceIsWritable() is defined in path_access.c */ st = zuluCryptCanOpenPathForWriting( device,uid ) ; }else{ /* * zuluCryptSecurityDeviceIsReadable() is defined in path_access.c */ st = zuluCryptCanOpenPathForReading( device,uid ) ; } /* * 1-permissions denied * 2-invalid path * 3-shenanigans * 4-common error */ switch( st ){ case 0 : break ; case 1 : return zuluExit( 6,device,mount_point,stl ) ; case 2 : return zuluExit( 6,device,mount_point,stl ) ; case 3 : return zuluExit( 6,device,mount_point,stl ) ; case 4 : return zuluExit( 6,device,mount_point,stl ) ; default: return zuluExit( 6,device,mount_point,stl ) ; } if( open_mount ){ /* * zuluCryptCreateMountPoint() is defined in create_mount_point.c */ *m_point = zuluCryptCreateMountPoint( device,mount_point,m_opts,uid ) ; mount_point = StringContent( *m_point ) ; if( mount_point == NULL ){ return zuluExit( 9,device,mount_point,stl ) ; } }else{ if( uid != 0 ){ return zuluExit( 7,device,mount_point,stl ) ; } if( mount_point != NULL ){ return zuluExit( 8,device,mount_point,stl ) ; } } if( share ){ /* * zuluCryptBindSharedMountPointPathTaken() is defined in bind.c */ if( zuluCryptBindSharedMountPointPathTaken( *m_point ) ){ return zuluExit_1( 10,opts,device,mount_point,stl ) ; } } /* * zuluCryptCreateMapperName() is defined in ../lib/create_mapper_name.c */ *m_name = zuluCryptCreateMapperName( device,mapping_name,uid,ZULUCRYPTshortMapperPath ) ; *mapper = StringCopy( *m_name ) ; mapper_name = StringContent( *m_name ) ; *mapper_path = String( zuluCryptMapperPrefix() ) ; e = StringMultipleAppend( *mapper_path,"/",mapper_name,NULL ) ; if( stat( e,&statstr ) == 0 ){ return zuluExit_1( 11,opts,device,mount_point,stl ) ; } if( plugin_path != NULL ){ /* * zuluCryptUUIDFromPath() is defined in path_access.c */ uuid = zuluCryptUUIDFromPath( device ) ; device_path = _device_path( device ) ; /* * zuluCryptPluginManagerGetKeyFromModule is defined in ../pluginManager/zuluCryptPluginManager.c */ *passphrase = zuluCryptPluginManagerGetKeyFromModule( device_path,plugin_path,uuid,uid,opts,&st ) ; StringFree( device_path ) ; StringFree( uuid ) ; if( st != 0 || *passphrase == StringVoid ){ return zuluExit_1( 12,opts,device,mount_point,stl ) ; } key_len = StringLength( *passphrase ) ; key = StringContent( *passphrase ) ; zuluCryptSecurityLockMemory_1( *passphrase ) ; }else if( source == NULL && tcrypt_keyfiles[ 0 ] == NULL ){ printf( gettext( "Enter passphrase: " ) ) ; /* * ZULUCRYPT_KEY_MAX_SIZE is set in ../constants.h */ switch( StringSilentlyGetFromTerminal_1( passphrase,ZULUCRYPT_KEY_MAX_SIZE ) ){ case 1 : return zuluExit_1( 13,opts,device,mount_point,stl ) ; case 2 : return zuluExit_1( 14,opts,device,mount_point,stl ) ; } printf( "\n" ) ; key = StringContent( *passphrase ) ; key_len = StringLength( *passphrase ) ; zuluCryptSecurityLockMemory_1( *passphrase ) ; }else{ if( source == NULL || pass == NULL ){ if( tcrypt_keyfiles == NULL ){ return zuluExit_1( 15,opts,device,mount_point,stl ) ; } } if( StringsAreEqual( source,"-p" ) ){ key = pass ; key_len = StringSize( pass ) ; }else if( StringsAreEqual( source,"-f" ) ){ if( StringHasNoComponent( pass,"/.zuluCrypt-socket" ) ){ tcrypt_keyfile = 1 ; } /* * function is defined at "path_access.c" */ switch( zuluCryptGetPassFromFile( pass,uid,data ) ){ case 1 : return zuluExit_1( 16,opts,device,mount_point,stl ) ; case 2 : return zuluExit_1( 17,opts,device,mount_point,stl ) ; case 4 : return zuluExit_1( 18,opts,device,mount_point,stl ) ; case 5 : return zuluExit_1( 19,opts,device,mount_point,stl ) ; } key = StringContent( *data ) ; key_len = StringLength( *data ) ; zuluCryptSecurityLockMemory_1( *data ) ; } } memset( &volume,'\0',sizeof( open_struct_t ) ) ; if( key != NULL ){ volume.key = key ; volume.key_len = key_len ; }else{ volume.key = "" ; volume.key_len = 0 ; } volume.device = device ; volume.offset = offset ; volume.mapper_name = mapper_name ; volume.m_point = mount_point ; volume.fs_opts = fs_opts ; volume.uid = uid ; volume.m_opts = m_opts ; volume.m_flags = m_flags ; /* * zuluCryptTrueCryptVeraCryptVolumeInfo() is defined in this source file. */ zuluCryptTrueCryptVeraCryptVolumeInfo( opts->type,&v_info ) ; volume.iteration_count = v_info.iteration_count ; volume.veraCrypt_volume = StringAtLeastOneMatch( v_info.type,"vcrypt","veracrypt","vera",NULL ) ; StringDelete( &v_info.type ) ; plugin_path = plugin_path + StringLastIndexOfChar_1( plugin_path,'/' ) + 1 ; volume.luks_detached_header = StringHasComponent( plugin_path,"luks" ) ; volume.general_detached_header = StringHasComponent( plugin_path,"generic_header" ) ; if( tcrypt_keyfile ){ volume.key_source = TCRYPT_KEYFILE ; } if( tcrypt_keyfiles[ 0 ] != NULL ){ /* * Here, we take a list of keyfiles supplied by the user and then copy them to a safe * location at "/run/zuluCrypt" and then we pass these safe copies to cryptsetup. * * The idea is not to let cryptsetup, a privileged process handle user managed files. */ stz = zuluCryptCreateKeyFiles( tcrypt_keyfiles,0 ) ; volume.tcrypt_keyfiles_count = StringListSize( stz ) ; volume.tcrypt_keyfiles = StringListStringArray_0( stz ) ; st = _open_volume( &volume ) ; zuluCryptDeleteKeyFiles( stz ) ; StringFree( volume.tcrypt_keyfiles ) ; StringListDelete( &stz ) ; }else{ st = _open_volume( &volume ) ; } /* * below two return values comes from ../lib/mount_volume.c */ if( st == -1 ){ st = 20 ; } if( st == 12 ){ st = 21 ; } if( st == 8 || st == 3 ){ st = 3 ; } device = StringMultiplePrepend( *mapper,"/",zuluCryptMapperPrefix(),NULL ) ; if( st == 0 && share ){ /* * user wish to share the mount point bind the mount point to a publicly accessed path at /run/media/public/ */ /* * zuluCryptBindMountVolume() is defined in ../zuluCrypt-cli/bin/bind.c */ zuluCryptBindMountVolume( device,*m_point,m_flags ) ; } /* * zuluCryptCheckInvalidKey() is defined in check_invalid_key.c */ zuluCryptCheckInvalidKey( opts->device ) ; return zuluExit_1( st,opts,device,mount_point,stl ) ; }