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 void NewsArticleFree(void *elem)
{
rssNewsArticle *article = elem;
StringFree(&article->title);
StringFree(&article->server);
StringFree(&article->fullURL);
}
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 void ArticleFree(void *vp)
{
article *a = vp;
StringFree(&a->url);
StringFree(&a->title);
StringFree(&a->server);
}
static void ThreadDataFree(void *elem){
threadData* data = elem;
pthread_join(data->threadID,NULL);
threadArguments* arg =data->arg;
StringFree(&arg->title);
StringFree(&arg->URL);
free(data->arg);
}
int zuluCryptUnmountVolume( const char * device,char ** m_point )
{
char * m ;
int h = 3 ;
char * loop_path = NULL ;
if( StringPrefixMatch( device,"/dev/loop",9 ) ){
/*
* zuluCryptLoopDeviceAddress() is defined in ./create_loop_device.c
*/
loop_path = zuluCryptLoopDeviceAddress( device ) ;
if( loop_path != NULL ){
device = loop_path ;
}
}
/*
* zuluCryptGetMountPointFromPath() is defined in ./process_mountinfo.c
*/
m = zuluCryptGetMountPointFromPath( device ) ;
if( m != NULL ){
h = _unmount_volume( m ) ;
if( h == 0 ){
/*
*zuluCryptMtabIsAtEtc() is defined in ./mount_volume.c
*/
if( zuluCryptMtabIsAtEtc() ){
h = zuluCrypRemoveEntryFromMtab( m ) ;
}
if( m_point != NULL ){
*m_point = m ;
}else{
StringFree( m ) ;
}
}else{
StringFree( m ) ;
}
}
if( h != 0 && h != 3 && h != 4 ){
h = 2 ;
}
StringFree( loop_path ) ;
return h ;
}
boolean ScaleObj::SetName(char *name)
{
XmString xm_string = StringCreate(name);
XtVaSetValues(_w, XmNtitleString, xm_string, NULL);
StringFree(xm_string);
return true;
}
static stringList_t _eval_path( string_t path,stringList_t stl_1 )
{
string_t st ;
const char * e ;
char * ac ;
if( StringStartsWith( path,"/" ) ){
/*
* zuluCryptResolvePath_1() is defined in resolve_paths.c
*/
st = zuluCryptResolvePath_1( StringContent( path ) ) ;
if( st != StringVoid ){
stl_1 = StringListAppendString_1( stl_1,&st ) ;
}
}else if( StringStartsWith( path,"UUID=" ) ){
/*
* check above did not find '/' character and we are in this block assuming the line uses UUID
*/
e = StringRemoveString( path,"\"" ) ;
/*
* zuluCryptEvaluateDeviceTags() is defined in path_access.c
*/
ac = zuluCryptEvaluateDeviceTags( "UUID",e + 5 ) ;
if( ac != NULL ){
stl_1 = StringListAppend( stl_1,ac ) ;
StringFree( ac ) ;
}
}
return stl_1 ;
}
static stringList_t _zuluCryptAddMDRAIDVolumes( stringList_t stl )
{
DIR * dir = opendir( "/dev/md/" ) ;
struct dirent * entry ;
char * e ;
const char * f ;
string_t st ;
if( dir != NULL ){
while( ( entry = readdir( dir ) ) != NULL ){
f = entry->d_name ;
if( !StringAtLeastOneMatch_1( f,".","..","md-device-map",NULL ) ){
st = String( "/dev/md/" ) ;
e = zuluCryptRealPath( StringAppend( st,f ) ) ;
if( e != NULL ){
StringListRemoveString( stl,e ) ;
StringFree( e ) ;
}
stl = StringListAppendString_1( stl,&st ) ;
}
}
closedir( dir ) ;
}
return stl ;
}
static void _print_list( stringList_t stl )
{
const char * e ;
char * z ;
StringListIterator it ;
StringListIterator end ;
StringListGetIterators( stl,&it,&end ) ;
while( it != end ){
e = StringContent( *it ) ;
it++ ;
if( StringPrefixEqual( e,"/dev/loop" ) ){
/*
* zuluCryptLoopDeviceAddress_1() is defined in ../lib/create_loop_device.c
*/
z = zuluCryptLoopDeviceAddress_1( e ) ;
if( z != NULL ){
puts( z ) ;
StringFree( z ) ;
}else{
puts( e ) ;
}
}else{
puts( e ) ;
}
}
}
static int _zuluCryptExECheckEmptySlots( const char * device )
{
int status = 0 ;
char * c ;
char * d ;
zuluCryptSecurityGainElevatedPrivileges() ;
c = zuluCryptEmptySlots( device ) ;
zuluCryptSecurityDropElevatedPrivileges() ;
if( c == NULL ){
return 1 ;
}
d = c - 1 ;
while( *++d ){
if( *d == '3' ){
status = 3 ;
break ;
}
}
StringFree( c ) ;
return status ;
}
char * zuluCryptVolumeStatus( const char * mapper )
{
char * path ;
string_t p ;
if( zuluCryptTrueCryptOrVeraCryptVolume( mapper ) ){
p = _get_crypto_info_from_tcplay( mapper ) ;
}else{
p = _get_crypto_info_from_cryptsetup( mapper ) ;
}
if( p == StringVoid ){
return NULL ;
}else{
/*
* zuluCryptGetMountPointFromPath() is defined in ./process_mountinfo.c
*/
path = zuluCryptGetMountPointFromPath( mapper ) ;
if( path != NULL ){
zuluCryptFileSystemProperties( p,mapper,path ) ;
StringFree( path ) ;
}
return StringDeleteHandle( &p ) ;
}
}
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 ;
}
char * zuluCryptLoopDeviceAddress_1( const char * device )
{
int fd ;
char * path ;
struct loop_info64 l_info ;
string_t st = String_1( "/sys/block/",device + 5,"/loop/backing_file",NULL ) ;
string_t xt = _StringGetFromVirtualFile( &st ) ;
if( xt == StringVoid ){
memset( &l_info,'\0',sizeof( struct loop_info64 ) ) ;
fd = open( device,O_RDONLY ) ;
ioctl( fd,LOOP_GET_STATUS64,&l_info ) ;
path = zuluCryptRealPath( ( char * ) l_info.lo_file_name ) ;
close( fd ) ;
st = String( path ) ;
StringFree( path ) ;
_clean_loop_path( st ) ;
return StringDeleteHandle( &st ) ; ;
}else{
_clean_loop_path( xt ) ;
return StringDeleteHandle( &xt ) ;
}
}
void Container::DoEndUpdate()
{
XtRemoveEventHandler(XtParent(_workArea), ExposureMask, FALSE,
&Container::UpdateAreaMessage, (XtPointer) this);
StringFree(_xm_update_message);
if (XtIsRealized(_workArea))
XClearArea(display, XtWindow(XtParent(_workArea)), 0, 0, 0, 0, TRUE);
_xm_update_message = NULL;
if (_container_type == SCROLLED_WORK_AREA ||
_container_type == WORK_AREA ||
_container_type == SCROLLED_ICON_LIST ||
_container_type == ICON_LIST)
{
if (XtIsRealized(_workArea))
XtMapWidget(_workArea);
GuiWorkAreaEnableRedisplay(_workArea);
XmDropSiteEndUpdate(XtParent(_workArea));
}
else
{
XtManageChild(_workArea);
if (_container_type == SCROLLED_HORIZONTAL_ROW_COLUMN)
XtAppAddTimeOut(appContext, 500, ResizeTimeOut, this);
}
}
static int zuluExit( int st,const char * dev )
{
switch( st ){
case 0 : printf( gettext( "SUCCESS: header saved successfully\n" ) ) ; break ;
case 1 : printf( gettext( "SUCCESS: header restored successfully\n" ) ) ; break ;
case 2 : printf( gettext( "ERROR: presented device is not a LUKS device\n" ) ) ; break ;
case 3 : printf( gettext( "ERROR: failed to perform requested operation\n" ) ) ; break ;
case 4 : printf( gettext( "ERROR: failed to perform requested operation\n" ) ) ; break ;
case 5 : printf( gettext( "INFO: operation terminater per user request\n" ) ) ; break ;
case 6 : printf( gettext( "ERROR: path to be used to create a back up file is occupied or permission denied\n" ) ); break ;
case 7 : printf( gettext( "ERROR: failed to perform requested operation\n" ) ) ; break ;
case 8 : printf( gettext( "ERROR: insufficient privilege to open backup header file for reading\n" ) ) ; break ;
case 9 : printf( gettext( "ERROR: invalid path to back up header file\n" ) ) ; break ;
case 10: printf( gettext( "ERROR: insufficient privilege to create a backup header in a destination folder\n" )); break ;
case 11: printf( gettext( "ERROR: invalid path to device\n" ) ) ; break ;
case 12: printf( gettext( "ERROR: argument for path to a backup header file is missing\n" ) ) ; break ;
case 13: printf( gettext( "ERROR: argument for path to a backup header file is missing\n" ) ) ; break ;
case 14: printf( gettext( "ERROR: only root and \"zulucrypt\" group members can restore and back up luks headers on system devices\n" ) ); break ;
case 15: printf( gettext( "ERROR: insufficient privilege to open device for writing\n" ) ) ; break ;
case 16: printf( gettext( "ERROR: could not resolve path to device\n" ) ) ; break ;
case 17: printf( gettext( "ERROR: backup file does not appear to contain luks header\n" ) ) ; break ;
case 18: printf( gettext( "ERROR: insufficient privilege to open device for reading\n" ) ) ; break ;
case 19: printf( gettext( "ERROR: insufficient memory to hold your responce\n" ) ) ; break ;
case 20: printf( gettext( "ERROR: wrong password entered or volume is not a truecrypt volume\n" ) ) ; break ;
}
StringFree( dev ) ;
if( st == 1 ){
return 0 ;
}else{
return st ;
}
}
/*
* Here,we check if the path we sent to open() is the path open() used. This check is necessary to
* guard against some known hypothetical exploits
*/
static int _paths_are_not_sane( int fd,const char * path )
{
char * c = zuluCryptGetFileNameFromFileDescriptor( fd ) ;
int st = StringsAreNotEqual( c,path ) ;
StringFree( c ) ;
return st ;
}
JNIEXPORT jobjectArray JNICALL Java_ConfigManager_getListValue(JNIEnv * env, jobject obj, jstring parameterName)
{
const jbyte* str;
char* name;
char* value;
int i;
ParameterList* list;
jobjectArray result = NULL;
str = (*env)->GetStringUTFChars(env, parameterName, NULL);
if (str != NULL)
{
name = StringNew((char*) str);
list = PM_getValue(GetJavaPMPointer(env, obj), name).list_val;
result = (jobjectArray) (*env)->NewObjectArray(env, PL_getLength(list), (*env)->FindClass(env, "java/lang/String"), NULL);
i = 0;
while((value = PL_next(list)) != NULL)
{
(*env)->SetObjectArrayElement(env, result, i, (*env)->NewStringUTF(env, value));
i++;
}
(*env)->ReleaseStringUTFChars(env, parameterName, str);
StringFree(name);
}
return result;
}
void IconObj::TopString(char *topString)
{
delete _topString;
_topString = STRDUP(topString);
XmString xm_string = StringCreate(topString);
XtVaSetValues(_w, GuiNtopLabelString, xm_string, NULL);
StringFree(xm_string);
}
void IconObj::BottomString(char *bottomString)
{
delete _bottomString;
_bottomString = STRDUP(bottomString);
XmString xm_string = StringCreate(bottomString);
XtVaSetValues(_w, GuiNbottomLabelString, xm_string, NULL);
StringFree(xm_string);
}
void Container::DoUpdateMessage(char *message)
{
StringFree(_xm_update_message);
_xm_update_message = StringCreate(message);
if (XtIsRealized(_workArea))
XClearArea(display, XtWindow(XtParent(_workArea)), 0, 0, 0, 0, TRUE);
Refresh();
}
int CleanUp(int exitCode)
{
DWORD processExitCode;
BOOL error = FALSE;
// Signal termination to the pipe redirection threads
SignalHandlingRedirecionPipesForExiting();
// Close all existing pipes
// Some programs can get confused if we disconnect before closing
CloseHandleSafe(gIpcPipe);
CloseHandleSafe(gStdInPipe);
CloseHandleSafe(gStdOutPipe);
CloseHandleSafe(gStdErrPipe);
// Wait the termination of all pipe redirection threads and check the termination cause
error = WaitHandlingRedirecionPipesForExiting();
// Pass-through the stub process termination error
if (gStubProcess != NULL &&
WaitForSingleObject(gStubProcess, MAX_WAITING_TIME) != WAIT_FAILED &&
GetExitCodeProcess(gStubProcess, &processExitCode) &&
processExitCode != ERROR_SUCCESS) {
SetLastError(processExitCode);
SysError();
error = TRUE;
}
// if this program or the stub had errors and the target process returned
// a success exit code, then exit with failure
if (error && exitCode == EXIT_SUCCESS)
exitCode = EXIT_FAILURE;
// Close the handles to pipe redirection threads and to the target process
CloseHandleSafe(gStdInThread);
CloseHandleSafe(gStdOutThread);
CloseHandleSafe(gStdErrThread);
CloseHandleSafe(gStubProcess);
CloseHandleSafe(gTargetProcess);
// Free allocated memory for strings
StringFree(gCurrentDirectory);
StringFree(gCmdLine);
return exitCode;
}
int zuluCryptOpenPlain_2( const char * device,const char * mapper,
const char * mode,const char * key,size_t key_len,
const char * options )
{
open_struct_t opt ;
stringList_t stl ;
int r ;
char * const * e = NULL ;
size_t n = 0 ;
args s = { "/dev/urandom","aes","cbc-essiv:sha256","256","ripemd160","0" } ;
memset( &opt,'\0',sizeof( open_struct_t ) ) ;
opt.device = device ;
opt.mapper_name = mapper ;
opt.key = key ;
opt.key_len = key_len ;
opt.m_opts = mode ;
opt.variables = &s ;
stl = StringListSplit( options,'.' ) ;
StringListStringArray_1( &e,&n,stl ) ;
if( n == 6 ){
s.rng = *( e + 0 ) ;
s.algo = *( e + 1 ) ;
s.cipher = *( e + 2 ) ;
s.keySize = *( e + 3 ) ;
s.hash = *( e + 4 ) ;
s.offset = *( e + 5 ) ;
}else if( n == 5 ){
s.algo = *( e + 0 ) ;
s.cipher = *( e + 1 ) ;
s.keySize = *( e + 2 ) ;
s.hash = *( e + 3 ) ;
s.offset = *( e + 4 ) ;
}
/*
* zuluCryptResolveDevicePath_0() is defined in resolve_path.c
*/
r = zuluCryptResolveDevicePath_0( _open_plain,&opt,2 ) ;
StringListDelete( &stl ) ;
StringFree( e ) ;
return r ;
}
int zuluCryptEXECloseVolume( const char * dev,const char * mapping_name,uid_t uid )
{
int st ;
int i ;
string_t p = StringVoid ;
char * m_point = NULL ;
struct stat xt ;
const char * mapper ;
/*
* ZULUCRYPTlongMapperPath is set in ../constants.h
* zuluCryptCreateMapperName() defined in ../lib/create_mapper_name.c
*/
p = zuluCryptCreateMapperName( dev,mapping_name,uid,ZULUCRYPTlongMapperPath ) ;
mapper = StringContent( p ) ;
if( stat( mapper,&xt ) != 0 ){
return zuluExit( 1,p ) ;
}
/*
* zuluCryptBindUnmountVolume() is defined in ./bind.c
*/
switch( zuluCryptBindUnmountVolume( StringListVoid,mapper,uid ) ){
case 3 : return zuluExit( 7,p ) ;
case 4 : return zuluExit( 8,p ) ;
case 5 : return zuluExit( 9,p ) ;
default: ;
}
zuluCryptSecurityGainElevatedPrivileges() ;
/*
* zuluCryptCloseVolume() is defined in ../lib/close_volume.c
*/
st = zuluCryptCloseVolume( mapper,&m_point ) ;
if( st == 0 && m_point != NULL ){
for( i = 0 ; i < 2 ; i++ ){
if( rmdir( m_point ) == 0 ){
break ;
}else{
sleep( 1 ) ;
}
}
StringFree( m_point ) ;
}
zuluCryptSecurityDropElevatedPrivileges() ;
return zuluExit( st,p ) ;
}
char * zuluCryptResolvePath( const char * path )
{
char * e ;
char * f ;
if( StringsAreEqual( path,"/dev/root" ) ){
e = _zuluCryptResolveDevRoot() ;
if( e == NULL ){
return StringCopy_2( path ) ;
}else{
return e ;
}
}else if( StringPrefixEqual( path,"/dev/disk/by-" ) ){
/*
* zuluCryptRealPath() is defined in real_path.c
*/
e = zuluCryptRealPath( path ) ;
if( e == NULL ){
return StringCopy_2( path ) ;
}else{
if( StringPrefixEqual( e,"/dev/mapper/" ) ){
f = _convert_if_path_is_lvm( e ) ;
StringFree( e ) ;
return f ;
}else{
return e ;
}
}
}else if( StringPrefixEqual( path,"/dev/mapper/" ) ){
return _convert_if_path_is_lvm( path ) ;
}else if( StringPrefixEqual( path,"/dev/md" ) ){
return zuluCryptResolveMDPath( path ) ;
}else if( StringPrefixEqual( path,"/dev/dm-" ) ){
return zuluCryptResolveDMPath( path ) ;
}else if( StringPrefixEqual( path,"/dev/loop" ) ){
/*
* zuluCryptLoopDeviceAddress() is defined in create_loop_device.c
*/
return zuluCryptLoopDeviceAddress( path ) ;
}else{
return StringCopy_2( path ) ;
}
}
/*
* dm path is a path like "/dev/dm-5".
* this routine will transform the path to /dev/abc/def if the path is
* an lvm path or to /dev/mapper/xyz if the volume is any other device manager volume.
*/
char * zuluCryptResolveDMPath( const char * path )
{
char * e = zuluCryptRealPath( path ) ;
char * f = _convert_if_path_is_lvm( e ) ;
StringFree( e ) ;
return f ;
}
void MotifUI::StringWidthHeight(const char *string, int *width, int *height)
{
Dimension w, h;
XmString xm_string = StringCreate((char *)string);
XmStringExtent(userFont, xm_string, &w, &h);
*width = w;
*height = h;
StringFree(xm_string);
}
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 ) ;
}
}
}
boolean MotifUI::SetName(char *name)
{
if (!InnerWidget())
return false;
XmString xm_string = StringCreate(name);
XtVaSetValues(InnerWidget(), XmNlabelString, xm_string, NULL);
StringFree(xm_string);
return true;
}
void
RequestFree(TSession * const sessionP) {
if (sessionP->validRequest)
freeRequestInfo(&sessionP->requestInfo);
ListFree(&sessionP->cookies);
ListFree(&sessionP->ranges);
TableFree(&sessionP->requestHeaderFields);
TableFree(&sessionP->responseHeaderFields);
StringFree(&(sessionP->header));
}
