static string_t create_mount_point( const char * device,const char * label,uid_t uid )
{
const char * m_point ;
string_t path ;
struct stat st ;
mode_t mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IXOTH | S_IROTH ;
zuluCryptSecurityGainElevatedPrivileges() ;
path = zuluCryptGetUserName( uid ) ;
#define path_does_not_exist( x ) stat( x,&st ) != 0
#define path_does_exist( x ) stat( x,&st ) == 0
if( path_does_not_exist( "/run" ) ){
mkdir( "/run/",mode ) ;
}else{
_chmod( "/run",st.st_mode | S_IXOTH | S_IROTH ) ;
}
_chown( "/run",0,0 ) ;
if( path_does_not_exist( "/run/media" ) ){
mkdir( "/run/media",mode ) ;
}else{
_chmod( "/run/media",st.st_mode | S_IXOTH | S_IROTH ) ;
}
_chown( "/run/media",0,0 ) ;
if( path_does_not_exist( "/run/media/private" ) ){
mkdir( "/run/media/private",mode ) ;
}else{
_chmod( "/run/media/private",st.st_mode | S_IXOTH | S_IROTH ) ;
}
_chown( "/run/media/private",0,0 ) ;
m_point = StringPrepend( path,"/run/media/private/" ) ;
if( path_does_not_exist( m_point ) ){
mkdir( m_point,S_IRUSR | S_IXUSR ) ;
_chown( m_point,uid,uid ) ;
}else{
_chown( m_point,uid,uid ) ;
_chmod( m_point,S_IRUSR | S_IXUSR ) ;
}
zuluCryptSecurityDropElevatedPrivileges() ;
StringAppendChar( path,'/' ) ;
if( label == NULL ){
return _create_default_mount_point( device,uid,path ) ;
}else{
return _create_custom_mount_point( label,uid,path ) ;
}
}
int do_chown(int nargs, char **args) {
/* GID is optional. */
if (nargs == 3) {
if (_chown(args[2], decode_uid(args[1]), -1) < 0)
return -errno;
} else if (nargs == 4) {
if (_chown(args[3], decode_uid(args[1]), decode_uid(args[2])) < 0)
return -errno;
} else if (nargs == 5) {
int ret = 0;
int ftsflags = FTS_PHYSICAL;
FTS *fts;
FTSENT *ftsent;
char *options = args[1];
uid_t uid = decode_uid(args[2]);
uid_t gid = decode_uid(args[3]);
char * path_argv[] = {args[4], NULL};
if (strcmp(options, "-R")) {
ERROR("do_chown: Invalid argument: %s\n", args[1]);
return -EINVAL;
}
fts = fts_open(path_argv, ftsflags, NULL);
if (!fts) {
ERROR("do_chown: Error traversing hierarchy starting at %s\n", path_argv[0]);
return -errno;
}
while ((ftsent = fts_read(fts))) {
switch (ftsent->fts_info) {
case FTS_DP:
case FTS_SL:
break;
case FTS_DNR:
case FTS_ERR:
case FTS_NS:
ERROR("do_chown: Could not access %s\n", ftsent->fts_path);
fts_set(fts, ftsent, FTS_SKIP);
ret = -errno;
break;
default:
if (_chown(ftsent->fts_accpath, uid, gid) < 0) {
ret = -errno;
fts_set(fts, ftsent, FTS_SKIP);
}
break;
}
}
fts_close(fts);
if (ret)
return ret;
} else {
return -1;
}
return 0;
}
int do_chown(int nargs, char **args) {
/* GID is optional. */
if (nargs == 3) {
if (_chown(args[2], decode_uid(args[1]), -1) < 0)
return -errno;
} else if (nargs == 4) {
if (_chown(args[3], decode_uid(args[1]), decode_uid(args[2])) < 0)
return -errno;
} else {
return -1;
}
return 0;
}
int do_mkdir(int nargs, char **args)
{
mode_t mode = 0755;
int ret;
/* mkdir <path> [mode] [owner] [group] */
if (nargs >= 3) {
mode = strtoul(args[2], 0, 8);
}
ret = make_dir(args[1], mode);
/* chmod in case the directory already exists */
if (ret == -1 && errno == EEXIST) {
ret = _chmod(args[1], mode);
}
if (ret == -1) {
return -errno;
}
if (nargs >= 4) {
uid_t uid = decode_uid(args[3]);
gid_t gid = -1;
if (nargs == 5) {
gid = decode_uid(args[4]);
}
if (_chown(args[1], uid, gid) < 0) {
return -errno;
}
}
return 0;
}
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 ;
}
int chown(const char *path, uid_t uid, gid_t gid) {
return _chown(path, uid, gid, 0);
}
int lchown(const char *path, uid_t uid, gid_t gid) {
return _chown(path, uid, gid, S_IFLNK);
}
int zuluCryptBindMountVolume( const char * device,string_t z_path,unsigned long flags )
{
struct stat st ;
string_t path ;
string_t tmp ;
ssize_t index = StringLastIndexOfChar( z_path,'/' ) ;
const char * o_path = StringContent( z_path ) ;
const char * m_path ;
const char * e ;
int xt ;
stringList_t stl ;
mode_t mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IXOTH | S_IROTH ;
if( index == -1 ){
return 1 ;
}
if( device ){;}
zuluCryptSecurityGainElevatedPrivileges() ;
/*
* zuluCryptGetMoutedListFromMountInfo() is defined in ../lib/process_mountinfo.c
*/
stl = zuluCryptGetMoutedListFromMountInfo() ;
path = String( "/run/media/public/" ) ;
m_path = StringAppend( path,o_path + index + 1 ) ;
#define path_does_not_exist( x ) stat( x,&st ) != 0
#define path_does_exist( x ) stat( x,&st ) == 0
if( path_does_not_exist( "/run" ) ){
mkdir( "/run",mode ) ;
_chown( "/run",0,0 ) ;
}
if( path_does_not_exist( "/run/media" ) ){
mkdir( "/run/media",mode ) ;
_chown( "/run/media",0,0 ) ;
}
if( path_does_not_exist( "/run/media/public" ) ){
mkdir( "/run/media/public",mode ) ;
_chown( "/run/media/public",0,0 ) ;
}
if( path_does_exist( m_path ) ){
/*
* bind mount point exists,this will happen if the mount point is already taken or a mount point folder
* was not autodeleted for some reason
*/
tmp = StringCopy( path ) ;
e = StringAppend( tmp," " ) ;
if( StringListHasSequence( stl,e ) != -1 ){
/*
* An attempt is made to bind mount on a path already bind mounted path,dont attempt to mount
*/
xt = 1 ;
}else{
/*
* the mount point folder is there for some reason but is not being used.
*/
xt = mount( o_path,m_path,"",flags|MS_BIND,"" ) ;
}
StringDelete( &tmp ) ;
}else{
mkdir( m_path,S_IRWXU | S_IRWXG | S_IRWXG ) ;
_chown( m_path,0,0 ) ;
xt = mount( o_path,m_path,"",flags|MS_BIND,"" ) ;
if( xt != 0 ){
rmdir( m_path ) ;
}
}
StringListDelete( &stl ) ;
StringDelete( &path ) ;
zuluCryptSecurityDropElevatedPrivileges() ;
return xt ;
}
/**
* Interrupt 80h. Handles the system calls.
*
* @param regs Pointer to struct containing micro's registers.
*/
void int80(registers* regs) {
switch (regs->eax) {
case _SYS_READ:
regs->eax = _read((unsigned int)regs->ebx, (char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_WRITE:
regs->eax = _write((unsigned int)regs->ebx, (const char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_TIME:
regs->eax = _time((time_t*)translate(regs->ebx));
break;
case _SYS_IOCTL:
regs->eax = _ioctl(regs->ebx, regs->ecx, (void*)translate(regs->edx));
break;
case _SYS_TICKS:
regs->eax = _getTicksSinceStart();
break;
case _SYS_YIELD:
// This just makes sure we call the scheduler again, for now
break;
case _SYS_EXIT:
_exit();
break;
case _SYS_GETPID:
regs->eax = _getpid();
break;
case _SYS_GETPPID:
regs->eax = _getppid();
break;
case _SYS_RUN:
regs->eax = _run((EntryPoint) translate(regs->ebx), (char*) translate(regs->ecx), regs->edx);
break;
case _SYS_WAIT:
regs->eax = _wait();
break;
case _SYS_KILL:
_kill((pid_t) regs->ebx);
break;
case _SYS_PINFO:
regs->eax = _pinfo((struct ProcessInfo*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_SLEEP:
_sleep(regs->ebx);
break;
case _SYS_NICE:
regs->eax = _nice(regs->ebx);
break;
case _SYS_RENICE:
regs->eax = _renice(regs->ebx, regs->ecx);
break;
case _SYS_CLOSE:
regs->eax = _close(regs->ebx);
break;
case _SYS_OPEN:
regs->eax = _open((char*)translate(regs->ebx), regs->ecx, regs->edx);
break;
case _SYS_CREAT:
regs->eax = _creat((char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_MKDIR:
regs->eax = _mkdir((const char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_RMDIR:
regs->eax = _rmdir((const char*)translate(regs->ebx));
break;
case _SYS_UNLINK:
regs->eax = _unlink((const char*)translate(regs->ebx));
break;
case _SYS_RENAME:
regs->eax = _rename((const char*)translate(regs->ebx), (const char*)translate(regs->ecx));
break;
case _SYS_CHDIR:
regs->eax = _chdir((const char*)translate(regs->ebx));
break;
case _SYS_GETCWD:
regs->eax = _getcwd((char*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_READDIR:
regs->eax = _readdir(regs->ebx, (struct fs_DirectoryEntry*)translate(regs->ecx), regs->edx);
break;
case _SYS_SETPPERSONA:
_setProcessPersona(regs->ebx, regs->ecx, regs->edx);
break;
case _SYS_GETPPERSONA:
_getProcessPersona(regs->ebx, (int*)translate(regs->ecx), (int*) translate(regs->edx));
break;
case _SYS_SYMLINK:
regs->eax = _symlink((const char *)translate(regs->ebx), (const char *)translate(regs->ecx));
break;
case _SYS_MKFIFO:
regs->eax = _mkfifo((const char*)translate(regs->ebx));
break;
case _SYS_CHMOD:
regs->eax = _chmod(regs->ebx, (const char*)translate(regs->ecx));
break;
case _SYS_STAT:
regs->eax = _stat((const char*)translate(regs->ebx), (struct stat*)translate(regs->ecx));
break;
case _SYS_CHOWN:
regs->eax = _chown((const char*)translate(regs->ebx));
break;
case _SYS_LOG:
_loglevel(regs->ebx);
break;
case _SYS_STACKSIZE:
regs->eax = _stacksize();
}
}
int main(int argc, char * argv[], char * env[])
{
char line[128], command[128], pathname[128];
int ID;
// DEVICE SELECT
get_device();
// INITIALIZE
init();
// MOUNT ROOT
mount_root();
// PROCESS LOOP
while(1)
{
strcpy(line, "");
strcpy(command, "");
strcpy(pathname, "");
strcpy(completePath, "");
printf("\n\ninput a command (type help for more info): ");
//read a line containting command [pathname]; // [ ] means optional
fgets(line, 256, stdin);
line[strlen(line)-1] = '\0';
//Find the command string and call the corresponding function;
parseString(line, arg1, command, pathname);
compPath(pathname);
printf("PATHNAME: %s\n", pathname);
ID = findCommand(command);
switch(ID)
{
case -1 : printDir(running->cwd->ino); break;
case 0 : _menu (arg1, pathname); break;
case 1 : _ls (arg1, pathname); break;
case 2 : _cd (arg1, pathname); break;
case 3 : _mkdir (arg1, pathname); break;
case 4 : _rmdir (arg1, pathname); break;
case 5 : _pwd (arg1, pathname); break;
case 6 : _creat0(arg1, pathname); break;
case 7 : _rm (arg1, pathname); break;
case 8 : _stat (arg1, pathname); break;
case 9 : compPath(arg1); _link(arg1, pathname); break;
case 10: _unlink(arg1, pathname); break;
case 11: compPath(arg1); _symlink(arg1, pathname); break;
case 12: _touch (arg1, pathname); break;
case 13: _chmod (arg1, pathname); break;
case 14: _chown (arg1, pathname); break;
case 15: _chgrp (arg1, pathname); break;
case 16: _open (arg1, pathname); break;
case 17: _close (arg1, pathname); break;
case 18: _read (arg1, pathname); break;
case 19: _write (arg1, pathname); break;
case 20: _pfd (arg1, pathname); break;
case 21: _lseek (arg1, pathname); break;
case 22: _cat (arg1, pathname); break;
case 23: _cp (arg1, pathname); break;
case 24: _mv (arg1, pathname); break;
case 25: __exit (arg1, pathname); break;
}
}
quit();
return 0;
}
