static void _get_result( arguments * args )
{
string_t st ;
int fd ;
const char * device = args->opts->device ;
if( StringPrefixEqual( device,"/dev/" ) ){
_get_result_0( device,args ) ;
}else{
/*
* zuluCryptAttachLoopDeviceToFile() is defined in create_loop_device.c
*/
if( zuluCryptAttachLoopDeviceToFile( device,args->opts->open_mode,&fd,&st ) ){
_get_result_0( StringContent( st ),args ) ;
StringDelete( &st ) ;
close( fd ) ;
}else{
_get_error( args ) ;
}
}
}
int zuluCryptOpenPlain_1( const open_struct_t * opt )
{
int mode ;
string_t st ;
int fd ;
int r ;
if( StringPrefixEqual( opt->device,"/dev/" ) ){
return _open_plain( opt->device,opt ) ;
}else{
if( StringHasComponent( opt->m_opts,"ro" ) ){
mode = O_RDONLY ;
}else{
mode = O_RDWR ;
}
/*
* zuluCryptAttachLoopDeviceToFile() is defined in ./create_loop.c
*/
if( zuluCryptAttachLoopDeviceToFile( opt->device,mode,&fd,&st ) ){
r = _open_plain( StringContent( st ),opt ) ;
StringDelete( &st ) ;
close( fd ) ;
return r ;
}else{
return 2 ;
}
}
}
int zuluCryptOpenPlain( const char * device,const char * mapper,const char * mode,const char * pass,size_t pass_size )
{
int lmode ;
string_t st ;
int fd ;
int r ;
if( StringPrefixMatch( device,"/dev/",5 ) ){
return _open_plain( device,mapper,mode,pass,pass_size ) ;
}else{
if( StringHasComponent( mode,"ro" ) ){
lmode = O_RDONLY ;
}else{
lmode = O_RDWR ;
}
/*
* zuluCryptAttachLoopDeviceToFile() is defined in ./create_loop.c
*/
if( zuluCryptAttachLoopDeviceToFile( device,lmode,&fd,&st ) ){
r = _open_plain( device,mapper,mode,pass,pass_size ) ;
StringDelete( &st ) ;
close( fd ) ;
return r ;
}else{
return 2 ;
}
}
}
int zuluCryptCreateTCrypt( const char * device,const char * file_system,const char * rng,
const char * key,size_t key_len,int key_source,
u_int64_t hidden_volume_size,
const char * file_system_h,const char * key_h,size_t key_len_h,int key_source_h )
{
int fd ;
string_t q = StringVoid ;
int r ;
if( StringPrefixEqual( device,"/dev/" ) ){
r = _create_tcrypt_volume( device,file_system,rng,key,key_len,key_source,
hidden_volume_size,file_system_h,key_h,key_len_h,key_source_h ) ;
}else{
/*
* zuluCryptAttachLoopDeviceToFile() is defined in create_loop_device.c
*/
if( zuluCryptAttachLoopDeviceToFile( device,O_RDWR,&fd,&q ) ){
device = StringContent( q ) ;
r = _create_tcrypt_volume( device,file_system,rng,key,key_len,key_source,
hidden_volume_size,file_system_h,key_h,key_len_h,key_source_h ) ;
close( fd ) ;
StringDelete( &q ) ;
}else{
r = 3 ;
}
}
return r ;
}
int zuluCryptAddKey( const char * device,const char * existingkey,size_t existingkey_size,const char * newkey,size_t newkey_size )
{
string_t st ;
int fd ;
int r ;
if( StringPrefixEqual( device,"/dev/" ) ){
return _add_key( device,existingkey,existingkey_size,newkey,newkey_size ) ;
}else{
/*
* zuluCryptAttachLoopDeviceToFile() is defined in ./create_loop.c
*/
if( zuluCryptAttachLoopDeviceToFile( device,O_RDWR,&fd,&st ) ){
r = _add_key( StringContent( st ),existingkey,existingkey_size,newkey,newkey_size ) ;
StringDelete( &st ) ;
close( fd ) ;
return r ;
}else{
return 1 ;
}
}
}
int zuluCryptCreateVolume( const char * dev,const char * fs,const char * type,const char * pass,size_t pass_size,const char * rng )
{
string_t st ;
int fd ;
int r ;
if( StringPrefixMatch( dev,"/dev/",5 ) ){
return _create_volume( dev,fs,type,pass,pass_size,rng ) ;
}else{
/*
* zuluCryptAttachLoopDeviceToFile() is defined in ./create_loop.c
*/
if( zuluCryptAttachLoopDeviceToFile( dev,O_RDWR,&fd,&st ) ){
r = _create_volume( StringContent( st ),fs,type,pass,pass_size,rng ) ;
StringDelete( &st ) ;
close( fd ) ;
return r ;
}else{
return 3 ;
}
}
}
int zuluCryptRemoveKey( const char * device ,const char * pass,size_t pass_size )
{
string_t st ;
int fd ;
int r ;
if( StringPrefixEqual( device,"/dev/" ) ){
return _remove_key( device,pass,pass_size ) ;
}else{
/*
* zuluCryptAttachLoopDeviceToFile() is defined in ./create_loop.c
*/
if( zuluCryptAttachLoopDeviceToFile( device,O_RDWR,&fd,&st ) ){
r = _remove_key( StringContent( st ),pass,pass_size ) ;
StringDelete( &st ) ;
close( fd ) ;
return r ;
}else{
return 2 ;
}
}
}
char * zuluCryptEmptySlots( const char * device )
{
string_t st ;
int fd ;
char * r ;
if( StringPrefixEqual( device,"/dev/" ) ){
return _empty_slots( device ) ;
}else{
/*
* zuluCryptAttachLoopDeviceToFile() is defined in ./create_loop.c
*/
if( zuluCryptAttachLoopDeviceToFile( device,O_RDONLY,&fd,&st ) ){
r = _empty_slots( StringContent( st ) ) ;
StringDelete( &st ) ;
close( fd ) ;
return r ;
}else{
return NULL ;
}
}
}
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 ) ;
}
int zuluCryptMountVolume( const char * path,const char * m_point,unsigned long mount_opts,const char * fs_opts,uid_t uid )
{
int h ;
string_t opts = StringVoid ;
string_t fs = StringVoid ;
string_t loop = StringVoid ;
int fd = -1 ;
m_struct mst ;
mst.device = path ;
mst.m_point = m_point ;
mst.uid = uid ;
mst.m_flags = mount_opts ;
/*
* zuluCryptGetFileSystemFromDevice() is defined in this source file
*/
fs = zuluCryptGetFileSystemFromDevice( path ) ;
if( fs == StringVoid ){
/*
* failed to read file system,probably because the volume does have any or
* a plain volume was opened with a wrong key
*/
return zuluExit( 4,fd,opts,fs,loop ) ;
}
if( StringStartsWith( fs,"crypto" ) ){
/*
* we cant mount an encrypted volume, exiting
*/
return zuluExit( 4,fd,opts,fs,loop ) ;
}
/*
* zuluCryptMountHasNotAllowedFileSystemOptions() is defined in ./mount_fs_options.c
*/
if( zuluCryptMountHasNotAllowedFileSystemOptions( uid,fs_opts,fs ) ){
return zuluExit( -1,fd,opts,fs,loop ) ;
}
mst.fs_flags = fs_opts ;
mst.fs = StringContent( fs ) ;
opts = set_mount_options( &mst ) ;
if( StringPrefixNotEqual( path,"/dev/" ) ){
/*
* zuluCryptAttachLoopDeviceToFile() is defined in ./create_loop_device.c
*/
if( zuluCryptAttachLoopDeviceToFile( mst.device,O_RDWR,&fd,&loop ) ){
mst.device = StringContent( loop ) ;
}else{
return zuluExit( -1,fd,opts,fs,loop ) ;
}
}
if( zuluCryptFileSystemIsFUSEbased( path ) ){
/*
* These file systems dont see to work with mount() command for some reason.
* Them being FUSE based could be a reason.
*/
switch( mount_FUSEfs( &mst ) ){
case 0 : return zuluExit( 0,fd,opts,fs,loop ) ;
case 16 : return zuluExit( 12,fd,opts,fs,loop ) ;
default : return zuluExit( 1,fd,opts,fs,loop ) ;
}
}else{
h = mount_volume( &mst ) ;
}
return zuluExit( h,fd,opts,fs,loop ) ;
}
