MUON_INLINE T* cast() const
{
if (T* ptr = (T*)_cast(MUON_META(T)->id(), MUON_META(T)->name()))
{
return ptr;
}
return NULL;
}
static constexpr inline
data_t<TT, NT, VT>
apply(
data_param_t<TF, NF, VF> v,
data_param_t<TT, (NT>NF)?NT-NF:0, VT> d
) noexcept {
typedef _make_idx_seq<(NT>NF)?NF:NT> is;
typedef _make_idx_seq<(NT>NF)?NT-NF:0> ds;
return _cast(v, d, is(), ds());
}
static void _process_request( socket_t s,crypt_buffer_ctx ctx,const crypt_buffer_result * r )
{
zuluValue_t value ;
crypt_buffer_result e ;
if( r->length != sizeof( zuluKey_t ) ){
value.key_found = 0 ;
}else{
value = _get_key_from_wallet( r->buffer ) ;
if( crypt_buffer_encrypt( ctx,_cast( &value ),sizeof( zuluValue_t ),&e ) ){
SocketSendData( s,e.buffer,e.length ) ;
}
}
}
static result_t _network_key_get_key( const arguments_t * e )
{
zuluKey_t key ;
zuluValue_t * value ;
socket_t s ;
result_t result ;
crypt_buffer_ctx ctx ;
crypt_buffer_result r ;
const char * encryption_key = e->encryption_key ;
size_t encryption_key_key_length = strlen( encryption_key ) ;
const char * wallet_name = "zuluCrypt" ;
const char * wallet_key = e->wallet_key ;
size_t n ;
int k = 0 ;
char * buffer ;
memset( &result,'\0',sizeof( result ) ) ;
memset( &key,'\0',sizeof( zuluKey_t ) ) ;
key.key_0_length = strlen( e->path ) + 1 ;
if( key.key_0_length > sizeof( key.key_0 ) ){
_debug( "error: key length buffer overflow" ) ;
return result ;
}else{
memcpy( key.key_0,e->path,key.key_0_length ) ;
}
key.key_1_length = strlen( e->uuid ) + 1 ;
if( key.key_1_length > sizeof( key.key_1 ) ){
_debug( "error: key length buffer overflow" ) ;
return result ;
}else{
memcpy( key.key_1,e->uuid,key.key_1_length ) ;
}
key.wallet_key_length = strlen( wallet_key ) ;
if( key.wallet_key_length > sizeof( key.wallet_key ) ){
_debug( "error: wallet key length buffer overflow" ) ;
return result ;
}else{
memcpy( key.wallet_key,wallet_key,key.wallet_key_length ) ;
}
n = strlen( wallet_name ) ;
if( n > sizeof( key.wallet_name ) ){
_debug( "error: buffer overflow" ) ;
return result ;
}else{
memcpy( key.wallet_name,wallet_name,n + 1 ) ;
memcpy( key.application_name,wallet_name,n + 1 ) ;
}
while( 1 ){
_debug( "client connecting ..." ) ;
s = SocketNet( e->network_address,e->port_number ) ;
if( SocketConnect( &s ) ){
_debug( "client connected" ) ;
break ;
}else{
if( k == 10 ){
_debug( "failed to connect to server" ) ;
return result ;
}else{
sleep( 1 ) ;
k++ ;
}
}
}
if( crypt_buffer_init( &ctx,encryption_key,encryption_key_key_length ) ){
if( crypt_buffer_encrypt( ctx,_cast( &key ),sizeof( zuluKey_t ),&r ) ){
SocketSendData( s,_cast( r.buffer ),r.length ) ;
buffer = nullptr ;
n = SocketGetData( s,&buffer ) ;
if( buffer ){
if( crypt_buffer_decrypt( ctx,buffer,n,&r ) ){
if( r.length == sizeof( zuluValue_t ) ){
value = ( zuluValue_t * )r.buffer ;
if( value->key_found ){
if( value->value_length <= sizeof( result.key ) ){
result.key_len = value->value_length ;
memcpy( result.key,value->value,value->value_length ) ;
result.got_key = 1 ;
}
}else{
_debug( "key not found" ) ;
}
}
}
free( buffer ) ;
}
}
crypt_buffer_uninit( &ctx ) ;
}
SocketClose( &s ) ;
return result ;
}
void events::run()
{
m_running = true ;
m_mtoto = this ;
connect( m_mtoto,SIGNAL( finished() ),m_main,SLOT( threadStopped() ) ) ;
connect( m_mtoto,SIGNAL( finished() ),m_mtoto,SLOT( deleteLater() ) ) ;
connect( this,SIGNAL( volumeMiniProperties( volumeEntryProperties * ) ),
m_babu,SLOT( autoMountVolume( volumeEntryProperties * ) ) ) ;
connect( this,SIGNAL( volumeRemoved( QString ) ),
m_babu,SLOT( volumeRemoved( QString ) ) ) ;
utility::fileHandle f( inotify_init() ) ;
int fd = f.handle() ;
if( fd == -1 ){
return this->failedToStart() ;
}
int dev = inotify_add_watch( fd,"/dev",IN_CREATE|IN_DELETE ) ;
int dm = inotify_add_watch( fd,"/dev/mapper",IN_CREATE|IN_DELETE ) ;
int md = -1 ;
if( utility::pathExists( "/dev/dm" ) ){
md = inotify_add_watch( fd,"/dev/md",IN_DELETE ) ;
}
auto _allowed_device = []( const char * device ){
/*
* dont care about these devices.
* /dev/sgX seem to be created when a usb device is plugged in
* /dev/dm-X are dm devices we dont care about since we will be dealing with them differently
*/
bool s = _startsWith( device,"sg" ) ||
_startsWith( device,"dm-" ) ||
_contains( device,"dev/tmp" ) ||
_contains( device,"dev-tmp" ) ||
_contains( device,".tmp.md." ) ||
_contains( device,"md/md-device-map" ) ;
return s == false ;
} ;
auto _device_action = [&]( const struct inotify_event * event ){
/*
* /dev/md/ folder seem to be deleted when the last entry in it is removed and
* created before the first entry is added.To account for this,monitor for the
* folder creation to start monitoring its contents.
*/
if( event->wd == dev && event->mask & IN_CREATE ){
if( _stringsAreEqual( "md",event->name ) ){
md = inotify_add_watch( fd,"/dev/md",IN_DELETE ) ;
return false ;
}
}
if( event->wd == dev && event->mask & IN_DELETE ){
if( _stringsAreEqual( "md",event->name ) ){
inotify_rm_watch( md,dev ) ;
return false ;
}
}
return true ;
} ;
const char * currentEvent ;
const char * end ;
constexpr int BUFF_SIZE = 4096 ;
char buffer[ BUFF_SIZE ] ;
fd_set rfds ;
FD_ZERO( &rfds ) ;
int select_fd = fd + 1 ;
auto _eventsReceived = [ & ](){
/*
* we are blocking on select() and not on read() because QThread->terminate() does not seem to
* be able to get out of a blocked read() on certain Qt versions.
*/
auto _gotEvents = [ & ](){
FD_SET( fd,&rfds ) ;
return select( select_fd,&rfds,nullptr,nullptr,nullptr ) > 0 ;
} ;
if( _gotEvents() ){
auto s = read( fd,buffer,BUFF_SIZE ) ;
if( s > 0 ){
end = buffer + s ;
currentEvent = buffer ;
return true ;
}
}
return false ;
} ;
auto _processEvent = [ & ]( const struct inotify_event * event ){
if( _device_action( event ) && _allowed_device( event->name ) ){
auto _device = [ & ](){
if( event->wd == dm ){
return zuluMountTask::devices::dm_device ;
}else if( event->wd == md ){
return zuluMountTask::devices::md_device ;
}else{
return zuluMountTask::devices::device ;
}
} ;
zuluMountTask::event e{ _device(),event->mask == IN_CREATE,event->name } ;
Task::exec( [ this,e ](){
auto r = zuluMountTask::deviceProperties( e ) ;
if( r.volumeRemoved ){
emit volumeRemoved( r.volumeName ) ;
}else{
emit volumeMiniProperties( r.entry ) ;
}
} ) ;
}
} ;
#define _cast( x ) reinterpret_cast< const struct inotify_event * >( currentEvent )
#define _eventSize sizeof( struct inotify_event )
while( true ){
if( _eventsReceived() ){
while( currentEvent < end ){
auto event = _cast( currentEvent ) ;
if( event ){
_processEvent( event ) ;
currentEvent += _eventSize + event->len ;
}else{
currentEvent += _eventSize ;
}
}
}
}
}
pid_t ProcessStart( process_t p )
{
if( pipe( p->fd_0 ) == -1 ){
return -1 ;
}
if( pipe( p->fd_1 ) == -1 ){
return -1 ;
}
if( pipe( p->fd_2 ) == -1 ){
return -1 ;
}
p->pid = fork() ;
if( p->pid == -1 ){
return -1 ;
}
if( p->pid == 0 ){
if( p->str.user_id != ( uid_t )-1 ){
/*
* drop privileges permanently
*/
seteuid( 0 ) ;
setgid( p->str.user_id ) ;
setgroups( 1,&p->str.user_id ) ;
setegid( p->str.user_id ) ;
setuid( p->str.user_id ) ;
}
dup2( p->fd_0[ 0 ],0 ) ;
dup2( p->fd_1[ 1 ],1 ) ;
dup2( p->fd_2[ 1 ],2 ) ;
close( p->fd_1[ 0 ] ) ;
close( p->fd_0[ 1 ] ) ;
close( p->fd_2[ 0 ] ) ;
if( p->str.priority != 0 ){
setpriority( PRIO_PROCESS,0,p->str.priority ) ;
}
if( p->str.args == NULL ){
#define _null ( void * )0
if( p->str.env != NULL ){
execle( p->exe,p->exe,_null,p->str.env ) ;
}else{
execl( p->exe,p->exe,_null ) ;
}
}else{
#define _cast( x ) ( char * const * )x
if( p->str.env != NULL ){
execve( p->str.args[ 0 ],_cast( p->str.args ),_cast( p->str.env ) ) ;
}else{
execv( p->str.args[ 0 ],_cast( p->str.args ) ) ;
}
}
/*
* execv has failed :-(
*/
_Exit( 1 ) ;
/*
* child process block ends here
*/
}
/*
* parent process continues from here
*/
close( p->fd_0[ 0 ] ) ;
close( p->fd_1[ 1 ] ) ;
close( p->fd_2[ 1 ] ) ;
p->state = ProcessIsStillRunning ;
if( p->str.timeout != -1 ){
__ProcessStartTimer( p ) ;
}
return p->pid ;
}
virtual void *cast( const char * str )
{
return _cast(str,"TimeLine.Filter", "e6.Name");
}
