/*
* Below function copies a file owned and managed by a user to a secured location so that it can be accessed securely.
*/
static int _secure_file_path( const char ** path,const char * source )
{
int fd_source ;
int fd_temp ;
char buffer[ SIZE ] ;
size_t len ;
const char * temp_path ;
struct stat ststr ;
string_t st_path = _create_work_directory() ;
StringAppend( st_path,"0-" ) ;
temp_path = StringAppendInt( st_path,syscall( SYS_gettid ) ) ;
zuluCryptSecurityDropElevatedPrivileges() ;
fd_source = open( source,O_RDONLY ) ;
if( fd_source == -1 ){
StringDelete( &st_path ) ;
return 0 ;
}
fstat( fd_source,&ststr ) ;
if( ststr.st_size >= 3145728 ){
/*
* headers are less than 3MB so we obvious have a wrong file
*/
StringDelete( &st_path ) ;
return 0 ;
}
zuluCryptSecurityGainElevatedPrivileges() ;
fd_temp = open( temp_path,O_WRONLY | O_CREAT,S_IRUSR | S_IWUSR | S_IRGRP |S_IROTH ) ;
if( fd_temp == -1 ){
close( fd_source ) ;
StringDelete( &st_path ) ;
return 0 ;
}
while( 1 ){
len = read( fd_source,buffer,SIZE ) ;
if( len < SIZE ){
write( fd_temp,buffer,len ) ;
break ;
}else{
write( fd_temp,buffer,len ) ;
}
}
close( fd_source ) ;
close( fd_temp ) ;
zuluCryptSecurityDropElevatedPrivileges() ;
*path = StringDeleteHandle( &st_path ) ;
return 1 ;
}
char * zuluCryptGetLoopDeviceAddress( const char * device )
{
char * z = NULL ;
const char * e ;
string_t st = StringVoid ;
string_t xt = StringVoid ;
int i ;
int r ;
z = zuluCryptLoopDeviceAddress_1( device ) ;
if( z == NULL ){
return NULL ;
}else{
st = String( "" ) ;
for( i = 0 ; i < 255 ; i++ ){
StringReplace( st,"/sys/block/loop" ) ;
StringAppendInt( st,i ) ;
xt = StringGetFromVirtualFile( StringAppend( st,"/loop/backing_file" ) ) ;
e = StringRemoveRight( xt,1 ) ;
r = StringsAreEqual( e,z ) ;
StringDelete( &xt ) ;
if( r ){
StringReplace( st,"/dev/loop" ) ;
e = StringAppendInt( st,i ) ;
if( StringsAreNotEqual( device,e ) ){
break ;
}
}else{
StringReset( st ) ;
}
}
StringFree( z ) ;
if( StringIsEmpty( st ) ){
StringDelete( &st ) ;
return NULL ;
}else{
return StringDeleteHandle( &st ) ;
}
}
}
void genResponse(int cid) {
int power = motor[motorA];
string tmpString;
int index = 0;
ubyte linebuff[20];
StringFromChars(tmpString,rxbuffer);
index = StringFind(tmpString, "/");
StringDelete(tmpString, 0, index);
index = StringFind(tmpString, "HTTP");
StringDelete(tmpString, index, strlen(tmpString));
writeDebugStreamLine("Request:%s", tmpString);
nxtDisplayTextLine(2, "Request: ");
nxtDisplayTextLine(3, tmpString);
if (StringFind(tmpString, "MOTA") > 0) {
StringDelete(tmpString, 0, 6);
index = StringFind(tmpString, " ");
if (index > -1)
StringDelete(tmpString, index, strlen(tmpString));
//power = RC_atoix(tmpString);
power = clip(RC_atoix(tmpString), -100, 100);
writeDebugStreamLine("Power:%d", power);
} else {
writeDebugStreamLine("NO POWER: %s", tmpString);
}
sendHeader(cid);
while(nxtHS_Status == HS_SENDING) wait1Msec(5);
wait1Msec(100);
index = 0;
linebuff[0] = 27; // escape;
linebuff[1] = 'S'; // the CID;
linebuff[2] = (ubyte)cid + 48; // the CID;
index = appendToBuff(buffer, index, linebuff, 3);
StringFormat(tmpString, "MotorA=%d", power);
memcpy(linebuff, tmpString, strlen(tmpString));
index = appendToBuff(buffer, index, linebuff, strlen(tmpString));
linebuff[0] = 27; // escape;
linebuff[1] = 'E'; // the CID;
index = appendToBuff(buffer, index, endmarker, 2);
writeRawHS(buffer, index);
motor[motorA] = power;
closeConn(1);
memset(rxbuffer, 0, sizeof(rxbuffer));
wait1Msec(100);
clear_read_buffer();
}
stringList_t zuluCryptGetPartitionFromConfigFile( const char * path )
{
StringListIterator it ;
StringListIterator end ;
stringList_t stl ;
stringList_t stl_1 = StringListVoid ;
string_t st = StringVoid ;
zuluCryptSecurityGainElevatedPrivileges() ;
st = StringGetFromFile( path ) ;
zuluCryptSecurityDropElevatedPrivileges() ;
stl = StringListStringSplit( st,'\n' ) ;
StringDelete( &st ) ;
StringListGetIterators( stl,&it,&end ) ;
while( it != end ){
stl_1 = _eval_path( *it,stl_1 ) ;
it++ ;
}
StringListDelete( &stl ) ;
return stl_1 ;
}
/*
* this function will parse /etc/crypttab to see if it has any entries to be used as system partition.
*
* sample example of the file content this function was build on.
*
* secret /dev/sda15 none
* secret_1 UUID=d2d210b8-0b1f-419f-9172-9d509ea9af0c none
*
*/
stringList_t zuluCryptGetPartitionFromCrypttab( void )
{
stringList_t stl = StringListVoid ;
stringList_t stl_1 = StringListVoid ;
stringList_t stz ;
string_t st ;
StringListIterator it ;
StringListIterator end ;
st = StringGetFromFile( "/etc/crypttab" ) ;
stl = StringListStringSplit( st,'\n' ) ;
StringDelete( &st ) ;
StringListGetIterators( stl,&it,&end ) ;
while( it != end ){
st = *it ;
it++ ;
if( !StringStartsWith( st,"#" ) ){
stz = StringListStringSplit( st,' ' ) ;
st = StringListStringAtSecondPlace( stz ) ;
stl_1 = _eval_path( st,stl_1 ) ;
StringListDelete( &stz ) ;
}
}
StringListDelete( &stl ) ;
return stl_1 ;
}
static char * _zuluCryptResolveDevRoot( void )
{
const char * e ;
char * dev ;
string_t st = StringGetFromVirtualFile( "/proc/cmdline" ) ;
stringList_t stl = StringListStringSplit( st,' ' ) ;
StringDelete( &st ) ;
st = StringListHasSequence_1( stl,"root=/dev/" ) ;
if( st != StringVoid ){
e = StringContent( st ) + 5 ;
dev = zuluCryptResolvePath( e ) ;
}else{
st = StringListHasSequence_1( stl,"root=UUID=" ) ;
if( st != StringVoid ){
/*
* zuluCryptDeviceFromUUID() is defined in ./blkid_evaluate_tag.c
*/
e = StringContent( st ) + 10 ;
dev = zuluCryptDeviceFromUUID( e ) ;
}else{
dev = NULL ;
}
}
StringListDelete( &stl ) ;
return dev ;
}
static int mount_point_prefix_match_0( const char * m_path,uid_t uid,string_t * m_point,int home_prefix )
{
int st ;
/*
* zuluCryptGetUserName() is defined in ../lib/user_home_path.c
*/
string_t uname ;
/*
* below constant are set in ../constants.h
*/
const char * str ;
if( home_prefix ){
uname = zuluCryptGetUserHomePath( uid ) ;
str = StringContent( uname ) ;
}else{
uname = zuluCryptGetUserName( uid ) ;
StringPrepend( uname,"/run/media/private/" ) ;
str = StringAppendChar( uname,'/' ) ;
}
st = StringPrefixEqual( m_path,str ) ;
if( m_point ){
*m_point = uname ;
}else{
StringDelete( &uname ) ;
}
return st ;
}
void getUserControlProgram(string& sFileName)
{
byte nParmToReadByte[2];
int nFileSize;
TFileIOResult nIoResult;
TFileHandle hFileHandle;
sFileName = "";
nParmToReadByte[1] = 0;
hFileHandle = 0;
OpenRead(hFileHandle, nIoResult, kConfigName, nFileSize);
if (nIoResult == ioRsltSuccess)
{
for (int index = 0; index < nFileSize; ++index)
{
ReadByte(hFileHandle, nIoResult, nParmToReadByte[0]);
strcat(sFileName, nParmToReadByte);
}
//
// Delete the ".rxe" file extension
//
int nFileExtPosition;
nFileExtPosition = strlen(sFileName) - 4;
if (nFileExtPosition > 0)
StringDelete(sFileName, nFileExtPosition, 4);
}
Close(hFileHandle, nIoResult);
return;
}
static int _fileSystemIsSupported( const char * fs )
{
string_t st = StringGetFromVirtualFile( "/proc/filesystems" ) ;
stringList_t stl = StringListStringSplit( st,'\n' ) ;
StringListIterator it = StringListBegin( stl ) ;
StringListIterator end = StringListEnd( stl ) ;
string_t xt ;
int r = 0 ;
while( it != end ){
xt = *it ;
it++ ;
if( !StringStartsWith( xt,"nodev" ) ){
if( StringContains( xt,fs ) ){
r = 1 ;
break ;
}
}
}
StringDelete( &st ) ;
StringListDelete( &stl ) ;
return r ;
}
int zuluCryptEXEVolumeInfo( const char * mapper,const char * device,uid_t uid )
{
char * output ;
int xt ;
/*
* ZULUCRYPTlongMapperPath is set in ../constants.h
* zuluCryptCreateMapperName() is defined at ../lib/create_mapper_name.c
*/
string_t p = zuluCryptCreateMapperName( device,mapper,uid,ZULUCRYPTlongMapperPath ) ;
zuluCryptSecurityGainElevatedPrivileges() ;
/*
*zuluCryptVolumeStatus() is defined in ../lib/status.c
*/
output = zuluCryptVolumeStatus( StringContent( p ) ) ;
zuluCryptSecurityDropElevatedPrivileges() ;
if( output != NULL ){
printf( "%s\n",output ) ;
StringFree( output ) ;
xt = 0 ;
}else{
printf( gettext( "ERROR: Could not get volume properties,volume is not open or was opened by a different user\n" ) ) ;
xt = 2 ;
}
StringDelete( &p ) ;
return xt ;
}
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 ;
}
}
}
static int mount_FUSEfs_0( m_struct * mst )
{
int status ;
const char * opts ;
process_t p = Process( ZULUCRYPTmount ) ;
string_t st = set_mount_options( mst ) ;
opts = _mount_options( mst->m_flags,st ) ;
if( StringsAreEqual( mst->fs,"ntfs" ) ){
if( StringHasComponent( opts,"ignore_case" ) ){
ProcessSetArgumentList( p,"-n","-t","lowntfs-3g","-o",opts,mst->device,mst->m_point,ENDLIST ) ;
}else{
ProcessSetArgumentList( p,"-n","-t","ntfs-3g","-o",opts,mst->device,mst->m_point,ENDLIST ) ;
}
}else{
ProcessSetArgumentList( p,"-t",mst->fs,"-o",opts,mst->device,mst->m_point,ENDLIST ) ;
}
ProcessStart( p ) ;
status = ProcessExitStatus( p ) ;
ProcessDelete( &p ) ;
StringDelete( &st ) ;
return status ;
}
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 ) ;
}
}
}
static int open_loop_device_1( string_t * loop_device )
{
string_t st = String( "" ) ;
int i ;
int fd ;
const char * path ;
struct loop_info64 l_info ;
int r = 0 ;
for( i = 0 ; i < 255 ; i++ ){
StringReplace( st,"/dev/loop" ) ;
path = StringAppendInt( st,i ) ;
fd = open( path,O_RDONLY ) ;
if( fd == -1 ){
r = 0 ;
break ;
}
if( ioctl( fd,LOOP_GET_STATUS64,&l_info ) != 0 ){
if( errno == ENXIO) {
*loop_device = StringCopy( st ) ;
close( fd ) ;
r = 1 ;
break ;
}
}
close( fd ) ;
}
StringDelete( &st ) ;
return r ;
}
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 ;
}
char * zuluCryptGetALoopDeviceAssociatedWithAnImageFile( const char * path )
{
int i ;
string_t st = String( "" ) ;
const char * e ;
char * f ;
for( i = 0 ; i < 255 ; i++ ){
StringReplace( st,"/dev/loop" ) ;
e = StringAppendInt( st,i ) ;
f = zuluCryptLoopDeviceAddress_1( e ) ;
if( StringsAreEqual( path,f ) ){
StringFree( f ) ;
return StringDeleteHandle( &st ) ;
}else{
StringFree( f ) ;
}
}
StringDelete( &st ) ;
return NULL ;
}
static int _check_if_device_is_supported( int st,uid_t uid,char ** dev )
{
string_t fs ;
if( st == 0 ){
seteuid( 0 ) ;
/*
* zuluCryptGetFileSystemFromDevice() is defined in mount_volume.c
*/
fs = zuluCryptGetFileSystemFromDevice( *dev ) ;
seteuid( uid ) ;
if( fs != StringVoid ){
if( StringHasAtLeastOneComponent( fs,"member","swap",NULL ) ){
st = 100 ;
}
StringDelete( &fs ) ;
}
}else{
/*
* safely do free( *dev ) followed by *dev = NULL
*/
StringFree_1( dev ) ;
}
return st ;
}
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 ;
}
}
}
static stringList_t _get_mount_entries( const char * device )
{
/*
* zuluCryptGetMountEntry() is defined in mountinfo.c
*/
stringList_t stl = zuluCryptGetMoutedList() ;
StringListIterator it ;
StringListIterator end ;
string_t st = String_1( device," ",NULL ) ;
StringListGetIterators( stl,&it,&end ) ;
while( it != end ){
if( StringStartsWith_1( *it,st ) ){
it++ ;
}else{
StringListRemoveAt_1( stl,it,&end ) ;
}
}
StringDelete( &st ) ;
return stl ;
}
int zuluCryptOpenTcrypt( const char * device,const char * mapper,const char * key,size_t key_len,
int key_source,int volume_type,const char * m_point,
uid_t uid,unsigned long m_flags,const char * fs_opts )
{
open_struct_t opts ;
string_t st ;
int r ;
const char * keyfile ;
memset( &opts,'\0',sizeof( open_struct_t ) ) ;
opts.device = device ;
opts.mapper_name = mapper ;
opts.volume_type = volume_type ;
opts.m_point = m_point ;
opts.uid = uid ;
opts.m_flags = m_flags ;
opts.fs_opts = fs_opts ;
if( m_flags & MS_RDONLY ){
opts.m_opts = "ro" ;
}else{
opts.m_opts = "rw" ;
}
if( key_source == TCRYPT_KEYFILE ){
st = zuluCryptCreateKeyFile( key,key_len,"open_tcrypt-" ) ;
if( st != StringVoid ){
keyfile = StringContent( st ) ;
opts.tcrypt_keyfiles_count = 1 ;
opts.tcrypt_keyfiles = &keyfile ;
r = zuluCryptOpenTcrypt_1( &opts ) ;
/*
* zuluCryptDeleteFile() is defined in open_path_security.c
*/
zuluCryptDeleteFile( keyfile ) ;
StringDelete( &st ) ;
}else{
r = 1 ;
}
}else if( key_source == TCRYPT_KEYFILE_FILE ){
opts.tcrypt_keyfiles_count = 1 ;
opts.tcrypt_keyfiles = &key ;
r = zuluCryptOpenTcrypt_1( &opts ) ;
}else{
opts.key_len = key_len ;
opts.key = key ;
r = zuluCryptOpenTcrypt_1( &opts ) ;
}
return r ;
}
int zuluCryptBindSharedMountPointPathTaken( string_t path )
{
struct stat str ;
ssize_t index = StringLastIndexOfChar( path,'/' ) ;
string_t st = String( "/run/media/public" ) ;
const char * e = StringAppend( st,StringContent( path ) + index ) ;
int r = stat( e,&str ) ;
StringDelete( &st ) ;
return r == 0 ;
}
static int zuluExit_1( int r,struct crypt_device * cd,string_t st )
{
crypt_free( cd ) ;
/*
* zuluCryptDeleteFile_1() is defined in open_path_security.c
*/
zuluCryptDeleteFile_1( st ) ;
StringDelete( &st ) ;
return r ;
}
int zuluCryptModifyTcryptHeader( const info_t * info )
{
tc_api_task task ;
int r = !TC_OK ;
const char * sys_device = NULL ;
string_t st = StringVoid ;
if( tc_api_init( 0 ) == TC_OK ){
task = tc_api_task_init( "modify" ) ;
if( task != 0 ){
if( StringsAreEqual( info->opt,"sys" ) ){
tc_api_task_set( task,"dev",info->device ) ;
st = _root_device( info->device,&sys_device ) ;
tc_api_task_set( task,"sys",sys_device ) ;
}else if( StringsAreEqual( info->opt,"fde" ) ){
st = _root_device( info->device,&sys_device ) ;
tc_api_task_set( task,"dev",sys_device ) ;
tc_api_task_set( task,"fde",TRUE ) ;
}else{
tc_api_task_set( task,"dev",info->device ) ;
}
tc_api_task_set( task,"hidden_size_bytes",( u_int64_t )0 ) ;
/*
* below line may look like one of the following two lines:
* tc_api_task_set( task,"header_from_file","/home/ink/tc.headerbackup" ) ;
* tc_api_task_set( task,"save_header_to_file","/home/ink/tc.headerbackup" ) ;
*/
tc_api_task_set( task,info->header_source,info->tmp_path ) ;
/*
* below line may look like one of the following two lines:
* tc_api_task_set( task,"passphrase","xxx" ) ;
* tc_api_task_set( task,"keyfiles","/home/ink/keyfile" ) ;
*/
tc_api_task_set( task,info->header_key_source,info->header_key ) ;
/*
* below line may look like one of the following two lines:
* tc_api_task_set( task,"new_passphrase","xxx" ) ;
* tc_api_task_set( task,"new_keyfiles","/home/ink/keyfile" ) ;
*/
tc_api_task_set( task,info->header_new_key_source,info->header_key ) ;
if( StringsAreEqual( info->rng,"/dev/urandom" ) ){
tc_api_task_set( task,"weak_keys_and_salt",TRUE ) ;
}else{
tc_api_task_set( task,"weak_keys_and_salt",FALSE ) ;
}
r = tc_api_task_do( task ) ;
tc_api_task_uninit( task ) ;
}
tc_api_uninit() ;
}
StringDelete( &st ) ;
return r ;
}
static string_t _create_path_0( const char * m_point,uid_t uid,string_t path )
{
if( mkdir( m_point,S_IRWXU ) == 0 ){
_chown( m_point,uid,uid ) ;
}else{
StringDelete( &path ) ;
}
return path ;
}
static int _mounted( ssize_t( *function )( stringList_t,const char * ),string_t st )
{
stringList_t stl = zuluCryptGetMoutedList() ;
ssize_t r = function( stl,StringContent( st ) ) ;
StringListDelete( &stl ) ;
StringDelete( &st ) ;
return r != -1 ;
}
/*
* return values:
* 5 - couldnt get key from the socket
* 4 -permission denied
* 1 invalid path
* 2 insufficient memory to open file
* 0 success
*/
int zuluCryptGetPassFromFile( const char * path,uid_t uid,string_t * st )
{
/*
* zuluCryptGetUserHomePath() is defined in ../lib/user_home_path.c
*/
string_t p = zuluCryptGetUserHomePath( uid ) ;
const char * z = StringAppend( p,".zuluCrypt-socket" ) ;
size_t s = StringLength( p ) ;
int m = StringPrefixMatch( path,z,s ) ;
StringDelete( &p ) ;
if( m ){
/*
* zuluCryptPrepareSocketPath() is defined in path_access.c
*/
zuluCryptPrepareSocketPath( uid ) ;
zuluCryptSecurityDropElevatedPrivileges() ;
/*
* path that starts with $HOME/.zuluCrypt-socket is treated not as a path to key file but as path
* to a local socket to get a passphrase
*/
/*
* zuluCryptGetKeyFromSocket() is defined in ../pluginManager/zuluCryptPluginManager.c
*/
zuluCryptGetKeyFromSocket( path,st,uid ) ;
return 0 ;
}else{
zuluCryptSecurityDropElevatedPrivileges() ;
/*
* 8192000 bytes is the default cryptsetup maximum keyfile size
*/
m = StringGetFromFileMemoryLocked( st,path,0,8192000 ) ;
switch( m ){
case 0 : return 0 ;
case 1 : return 4 ;
case 2 : return 2 ;
}
/*
* not supposed to get here
*/
return -1 ;
}
}
static stringList_t _zuluCryptAddLVMVolumes( stringList_t stl )
{
struct dirent * entry ;
string_t st ;
string_t xt ;
DIR * dir = opendir( "/dev/mapper/" ) ;
if( dir != NULL ){
st = String( "/dev/mapper/" ) ;
while( ( entry = readdir( dir ) ) != NULL ){
if( !StringAtLeastOneMatch_1( entry->d_name,".","..","control",NULL ) ){
/*
* zuluCryptConvertIfPathIsLVM() is defined in ../lib/resolve_paths.c
*/
xt = zuluCryptConvertIfPathIsLVM( StringAppendAt( st,12,entry->d_name ) ) ;
if( StringStartsWith( xt,"/dev/mapper/" ) ){
StringDelete( &xt ) ;
}else{
stl = StringListAppendString_1( stl,&xt ) ;
}
}
}
StringDelete( &st ) ;
closedir( dir ) ;
}
return stl ;
}
int zuluMountCryptoUMount( ARGS * args )
{
const char * device = args->device ;
const char * UUID = args->uuid ;
uid_t uid = args->uid ;
const char * mapping_name ;
char * path = NULL ;
int st ;
string_t str = StringVoid ;
if( UUID == NULL ){
if( StringPrefixEqual( device,"/dev/loop" ) ){
/*
* zuluCryptLoopDeviceAddress_1() is defined in ../zuluCrypt-cli/create_loop_device.c
*/
path = zuluCryptLoopDeviceAddress_1( device ) ;
if( path == NULL ){
return 20 ;
}else{
device = path ;
}
}
mapping_name = device + StringLastIndexOfChar_1( device,'/' ) + 1 ;
}else{
str = String( UUID ) ;
StringRemoveString( str,"\"" ) ;
mapping_name = StringSubChar( str,4,'-' ) ;
}
/*
* zuluCryptEXECloseVolume() is defined in ../zuluCrypt-cli/bin/close_volume.c
*/
st = zuluCryptEXECloseVolume( device,mapping_name,uid ) ;
StringDelete( &str ) ;
StringFree( path ) ;
return st ;
}
void zuluCryptPrepareSocketPath( uid_t uid )
{
string_t st = zuluCryptGetUserHomePath( uid ) ;
const char * e = StringAppend( st,"/.zuluCrypt-socket" ) ;
zuluCryptSecurityGainElevatedPrivileges() ;
mkdir( e,0777 ) ;
if( chown( e,uid,uid ) ){}
if( chmod( e,0777 ) ){}
zuluCryptSecurityDropElevatedPrivileges() ;
StringDelete( &st ) ;
}
static int zuluExit( int result,string_t st,int fd_loop,int fd_path )
{
if( st == 0 ){
StringDelete( &st ) ;
if( fd_loop != -1 ){
close( fd_loop ) ;
}
}
if( fd_path != -1 ){
close( fd_path ) ;
}
return result ;
}
