apps/Makefile

@@ -1,4 +1,4 @@
-APPS := init sym sh crash uname uptime hello ps ls args cat stat
+APPS := init sym sh crash uname uptime hello ps ls args cat
 
 APPS_DIR := $(LUNA_ROOT)/apps
 APPS_SRC := $(APPS_DIR)/src

apps/src/init.c

@@ -1,5 +1,4 @@
 #include <errno.h>
-#include <fcntl.h>
 #include <luna.h>
 #include <stdio.h>
 #include <sys/wait.h>
@@ -7,16 +6,10 @@
 
 void show_motd()
 {
-    int fd = open("/etc/motd", O_RDONLY | O_CLOEXEC);
+    FILE* fp = fopen("/etc/motd", "r");
-    if (fd < 0)
-    {
-        if (errno != ENOENT) { perror("open"); }
-        return;
-    }
-    FILE* fp = fdopen(fd, "r");
     if (!fp)
     {
-        perror("fopen");
+        if (errno != ENOENT) { perror("fopen"); }
         return;
     }
 

apps/src/stat.c

@@ -1,55 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-
-const char* mode_to_string(mode_t mode)
-{
-    static char mode_string[12];
-
-    char mode_set[12] = {'s', 'g', 'r', 'w', 'x', 'r', 'w', 'x', 'r', 'w', 'x', 0};
-    mode_t mode_val[12] = {S_ISUID, S_ISGID, S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP,
-                           S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH, S_IFMT};
-
-    for (int i = 0; i < 12; i++)
-    {
-        if (mode & mode_val[i]) mode_string[i] = mode_set[i];
-        else
-            mode_string[i] = '-';
-    }
-
-    return mode_string;
-}
-
-int main(int argc, char** argv)
-{
-    if (argc == 1)
-    {
-        fprintf(stderr, "Usage: stat [file]\n");
-        return EXIT_FAILURE;
-    }
-
-    struct stat st;
-    if (stat(argv[1], &st) < 0)
-    {
-        perror("stat");
-        return EXIT_FAILURE;
-    }
-
-    printf("Type: ");
-
-    switch (st.st_mode & S_IFMT)
-    {
-    case S_IFREG: puts("Regular file"); break;
-    case S_IFDIR: puts("Directory"); break;
-    case S_IFCHR: puts("Character device"); break;
-    default: puts("Unknown"); break;
-    }
-
-    printf("Length: %ld\n", st.st_size);
-    printf("Inode: %ld\n", st.st_ino);
-    printf("UID: %d\n", st.st_uid);
-    printf("GID: %d\n", st.st_gid);
-    printf("Mode: %s\n", mode_to_string(st.st_mode));
-
-    return EXIT_SUCCESS;
-}

kernel/include/fs/VFS.h

@@ -1,7 +1,6 @@
 #pragma once
 #include <stddef.h>
 #include <stdint.h>
-#include <sys/types.h>
 
 typedef long ssize_t;
 
@@ -20,7 +19,7 @@ namespace VFS
     typedef ssize_t (*node_read)(Node*, size_t, size_t, char*);
     typedef ssize_t (*node_write)(Node*, size_t, size_t, const char*);
     typedef Node* (*node_finddir)(Node*, const char*);
-    typedef int (*node_mkdir)(Node*, const char*, mode_t);
+    typedef int (*node_mkdir)(Node*, const char*);
     typedef int (*node_block)(Node*);
     typedef Node* (*node_readdir)(Node*, long);
 
@@ -39,9 +38,6 @@ namespace VFS
         node_block block_func;
         int tty = 0;
         Node* link;
-        int uid;
-        int gid;
-        mode_t mode;
     };
 
     ssize_t read(Node* node, size_t offset, size_t length, char* buffer);
@@ -49,9 +45,6 @@ namespace VFS
     int mkdir(const char* path, const char* name);
     int mkdir(const char* pathname);
 
-    int do_mkdir(const char* path, const char* name, int uid, int gid, mode_t mode);
-    int do_mkdir(const char* pathname, int uid, int gid, mode_t mode);
-
     int would_block(Node* node);
 
     void mount_root(Node* root);
@@ -68,11 +61,4 @@ namespace VFS
     Node* root();
 
     Node* readdir(Node* dir, long offset);
-
-    bool can_execute(Node* node, int uid, int gid);
-    bool can_read(Node* node, int uid, int gid);
-    bool can_write(Node* node, int uid, int gid);
-
-    bool is_setuid(Node* node);
-    bool is_setgid(Node* node);
 }

kernel/include/std/errno.h

@@ -9,7 +9,6 @@
 #define EBADF 9
 #define EAGAIN 11
 #define ENOMEM 12
-#define EACCES 13
 #define EFAULT 14
 #define EEXIST 17
 #define ENOTDIR 20

kernel/include/sys/Syscall.h

@@ -28,8 +28,6 @@
 #define SYS_getdents 22
 #define SYS_stat 23
 #define SYS_dup2 24
-#define SYS_setuid 25
-#define SYS_setgid 26
 
 struct stat;
 struct pstat;
@@ -56,7 +54,7 @@ void sys_execv(Context* context, const char* pathname, char** argv);
 void sys_fcntl(Context* context, int fd, int command, uintptr_t arg);
 void sys_mprotect(Context* context, void* address, size_t size, int prot);
 void sys_clock(Context* context);
-void sys_mkdir(Context* context, const char* filename, mode_t mode);
+void sys_mkdir(Context* context, const char* filename);
 void sys_fork(Context* context);
 void sys_waitpid(Context* context, long pid, int* wstatus, int options);
 void sys_access(Context* context, const char* path, int amode);
@@ -65,5 +63,3 @@ void sys_pstat(Context* context, long pid, struct pstat* buf);
 void sys_getdents(Context* context, int fd, struct luna_dirent* buf, size_t count);
 void sys_stat(Context* context, const char* path, struct stat* buf);
 void sys_dup2(Context* context, int fd, int fd2);
-void sys_setuid(Context* context, int new_uid, int new_euid);
-void sys_setgid(Context* context, int new_gid, int new_egid);

kernel/include/thread/Task.h

@@ -36,11 +36,6 @@ struct Task
 
     int64_t task_time = 0;
 
-    int uid;
-    int euid;
-    int gid;
-    int egid;
-
     Task* next_task = nullptr;
     Task* prev_task = nullptr;
 
@@ -103,8 +98,6 @@ struct Task
 
     Descriptor* descriptor_from_fd(int fd, int& error);
 
-    bool is_superuser();
-
   private:
     void resume_read();
     void resume_wait();

kernel/src/fs/VFS.cpp

@@ -157,43 +157,7 @@ int VFS::mkdir(const char* path, const char* name)
         kwarnln("Already exists");
         return -EEXIST;
     }
-    return node->mkdir_func(node, name, 0755);
+    return node->mkdir_func(node, name);
-}
-
-int VFS::do_mkdir(const char* path, const char* name, int uid, int gid, mode_t mode)
-{
-    Node* node = resolve_path(path, vfs_root);
-    if (!node)
-    {
-        kwarnln("Attempting to mkdir in %s, which does not exist", path);
-        return -ENOENT;
-    }
-    if (node->type != VFS_DIRECTORY)
-    {
-        kwarnln("Attempting to mkdir in %s, which is not a directory!!", path);
-        return -ENOTDIR;
-    }
-    if (!node->mkdir_func)
-    {
-        kwarnln("Chosen node does not support mkdir()");
-        return -ENOTSUP;
-    }
-    if (!node->find_func)
-    {
-        kwarnln("Chosen node does not support finddir()");
-        return -ENOTSUP;
-    }
-    if (node->find_func(node, name) != nullptr)
-    {
-        kwarnln("Already exists");
-        return -EEXIST;
-    }
-    if (!can_write(node, uid, gid))
-    {
-        kwarnln("Not enough permissions");
-        return -EACCES;
-    }
-    return node->mkdir_func(node, name, mode);
 }
 
 int VFS::mkdir(const char* pathname)
@@ -214,24 +178,6 @@ int VFS::mkdir(const char* pathname)
     return result;
 }
 
-int VFS::do_mkdir(const char* pathname, int uid, int gid, mode_t mode)
-{
-    char* bstr = strdup(pathname);
-    char* dstr = strdup(pathname);
-
-    char* base = basename(bstr);
-    char* dir = dirname(dstr);
-
-    kdbgln("mkdir(): creating %s in directory %s", base, dir);
-
-    int result = do_mkdir(dir, base, uid, gid, mode);
-
-    kfree(bstr);
-    kfree(dstr);
-
-    return result;
-}
-
 bool VFS::exists(const char* pathname)
 {
     return resolve_path(pathname) != nullptr;
@@ -263,34 +209,3 @@ VFS::Node* VFS::readdir(VFS::Node* dir, long offset)
     if (!dir->readdir_func) return 0;
     return dir->readdir_func(dir, offset);
 }
-
-bool VFS::can_execute(VFS::Node* node, int uid, int gid)
-{
-    if (uid == node->uid) return node->mode & 0100;
-    if (gid == node->gid) return node->mode & 0010;
-    return node->mode & 0001;
-}
-
-bool VFS::can_write(VFS::Node* node, int uid, int gid)
-{
-    if (uid == node->uid) return node->mode & 0200;
-    if (gid == node->gid) return node->mode & 0020;
-    return node->mode & 0002;
-}
-
-bool VFS::can_read(VFS::Node* node, int uid, int gid)
-{
-    if (uid == node->uid) return node->mode & 0400;
-    if (gid == node->gid) return node->mode & 0040;
-    return node->mode & 0004;
-}
-
-bool VFS::is_setuid(VFS::Node* node)
-{
-    return node->mode & 04000;
-}
-
-bool VFS::is_setgid(VFS::Node* node)
-{
-    return node->mode & 02000;
-}

kernel/src/fs/devices/Console.cpp

@@ -14,8 +14,6 @@ VFS::Node* ConsoleDevice::create_new(const char* devname)
     dev->type = VFS_DEVICE;
     dev->flags = 0;
     dev->tty = 1;
-    dev->uid = dev->gid = 0;
-    dev->mode = 0222;
     strncpy(dev->name, devname, sizeof(dev->name));
     return dev;
 }

kernel/src/fs/devices/DeviceFS.cpp

@@ -25,8 +25,6 @@ VFS::Node* DeviceFS::get()
     devfs_root->type = VFS_DIRECTORY;
     devfs_root->find_func = DeviceFS::finddir;
     devfs_root->readdir_func = DeviceFS::readdir;
-    devfs_root->mode = 0755;
-    devfs_root->uid = devfs_root->gid = 0;
     strncpy(devfs_root->name, "dev", sizeof(devfs_root->name));
 
     devfs_files[devfs_file_count++] = VersionDevice::create_new("version");

kernel/src/fs/devices/Keyboard.cpp

@@ -26,8 +26,6 @@ VFS::Node* KeyboardDevice::create_new(const char* devname)
     dev->type = VFS_DEVICE;
     dev->flags = 0;
     dev->tty = 1;
-    dev->uid = dev->gid = 0;
-    dev->mode = 0444;
     strncpy(dev->name, devname, sizeof(dev->name));
     return dev;
 }

kernel/src/fs/devices/NullDevice.cpp

@@ -12,8 +12,6 @@ VFS::Node* NullDevice::create_new(const char* devname)
     dev->length = 0;
     dev->type = VFS_DEVICE;
     dev->flags = 0;
-    dev->uid = dev->gid = 0;
-    dev->mode = 0666;
     strncpy(dev->name, devname, sizeof(dev->name));
     return dev;
 }

kernel/src/fs/devices/Random.cpp

@@ -14,8 +14,6 @@ VFS::Node* RandomDevice::create_new(const char* devname)
     dev->length = 0;
     dev->type = VFS_DEVICE;
     dev->flags = 0;
-    dev->uid = dev->gid = 0;
-    dev->mode = 0444;
     strncpy(dev->name, devname, sizeof(dev->name));
     return dev;
 }

kernel/src/fs/devices/Serial.cpp

@@ -13,8 +13,6 @@ VFS::Node* SerialDevice::create_new(const char* devname)
     dev->length = 0;
     dev->type = VFS_DEVICE;
     dev->flags = 0;
-    dev->uid = dev->gid = 0;
-    dev->mode = 0200;
     strncpy(dev->name, devname, sizeof(dev->name));
     return dev;
 }

kernel/src/fs/devices/Uptime.cpp

@@ -12,8 +12,6 @@ VFS::Node* UptimeDevice::create_new(const char* devname)
     dev->length = 0;
     dev->type = VFS_DEVICE;
     dev->flags = 0;
-    dev->uid = dev->gid = 0;
-    dev->mode = 0444;
     strncpy(dev->name, devname, sizeof(dev->name));
     return dev;
 }

kernel/src/fs/devices/Version.cpp

@@ -12,8 +12,6 @@ VFS::Node* VersionDevice::create_new(const char* devname)
     dev->length = strlen(moon_version()) + 5;
     dev->type = VFS_DEVICE;
     dev->flags = 0;
-    dev->uid = dev->gid = 0;
-    dev->mode = 0444;
     strncpy(dev->name, devname, sizeof(dev->name));
     return dev;
 }

kernel/src/init/InitRD.cpp

@@ -195,7 +195,7 @@ VFS::Node* initrd_read_dir(VFS::Node* node, long offset)
     return dir.files[offset];
 }
 
-int initrd_mkdir(VFS::Node* node, const char* name, mode_t mode) // FIXME: Return proper error numbers.
+int initrd_mkdir(VFS::Node* node, const char* name) // FIXME: Return proper error numbers.
 {
     if (total_dirs >= 32)
     {
@@ -225,8 +225,6 @@ int initrd_mkdir(VFS::Node* node, const char* name, mode_t mode) // FIXME: Retur
     new_node.mkdir_func = initrd_mkdir;
     new_node.length = 0;
     new_node.type = VFS_DIRECTORY;
-    new_node.mode = mode;
-    new_node.uid = new_node.gid = 0;
     strncpy(new_node.name, name, sizeof(new_node.name));
     InitRD::Directory dir;
     strncpy(dir.name, name, sizeof(dir.name));
@@ -284,8 +282,6 @@ static bool initrd_register_dir(InitRD::Directory& dir, uint64_t inode)
                 node.mkdir_func = initrd_mkdir;
                 node.readdir_func = initrd_read_dir;
                 node.length = 0;
-                node.mode = 0755;
-                node.uid = node.gid = 0;
                 strncpy(node.name, buffer, sizeof(node.name));
                 strncpy(dir.name, buffer, sizeof(dir.name));
 
@@ -345,8 +341,6 @@ static bool initrd_register_file(InitRD::File& f, uint64_t inode)
                 node.read_func = initrd_read;
                 node.length = f.size;
                 node.type = VFS_FILE;
-                node.mode = 0555;
-                node.uid = node.gid = 0;
                 strncpy(node.name, buffer, sizeof(node.name));
                 strncpy(f.name, buffer, sizeof(f.name));
 
@@ -389,8 +383,6 @@ static void initrd_initialize_root()
     initrd_root.length = 0;
     initrd_root.inode = 0;
     initrd_root.type |= VFS_DIRECTORY;
-    initrd_root.mode = 0755;
-    initrd_root.uid = initrd_root.gid = 0;
     InitRD::Directory& root = dirs[0];
     total_dirs++;
     strncpy(initrd_root.name, "initrd", sizeof(initrd_root.name));

kernel/src/sys/Syscall.cpp

@@ -27,19 +27,16 @@ void Syscall::entry(Context* context)
     case SYS_fcntl: sys_fcntl(context, (int)context->rdi, (int)context->rsi, context->rdx); break;
     case SYS_mprotect: sys_mprotect(context, (void*)context->rdi, context->rsi, (int)context->rdx); break;
     case SYS_clock: sys_clock(context); break;
-    case SYS_mkdir: sys_mkdir(context, (const char*)context->rdi, (mode_t)context->rsi); break;
+    case SYS_mkdir: sys_mkdir(context, (const char*)context->rdi); break;
     case SYS_fork: sys_fork(context); break;
     case SYS_waitpid: sys_waitpid(context, (long)context->rdi, (int*)context->rsi, (int)context->rdx); break;
     case SYS_access: sys_access(context, (const char*)context->rdi, (int)context->rsi); break;
     case SYS_fstat: sys_fstat(context, (int)context->rdi, (struct stat*)context->rsi); break;
-    case SYS_stat: sys_stat(context, (const char*)context->rdi, (struct stat*)context->rsi); break;
     case SYS_pstat: sys_pstat(context, (long)context->rdi, (struct pstat*)context->rsi); break;
     case SYS_getdents:
         sys_getdents(context, (int)context->rdi, (struct luna_dirent*)context->rsi, (size_t)context->rdx);
         break;
     case SYS_dup2: sys_dup2(context, (int)context->rdi, (int)context->rsi); break;
-    case SYS_setuid: sys_setuid(context, (int)context->rdi, (int)context->rsi); break;
-    case SYS_setgid: sys_setgid(context, (int)context->rdi, (int)context->rsi); break;
     default: context->rax = -ENOSYS; break;
     }
     VMM::exit_syscall_context();

kernel/src/sys/exec.cpp

@@ -45,11 +45,6 @@ void sys_fork(Context* context)
 
     child->ppid = parent->id;
 
-    child->uid = parent->uid;
-    child->euid = parent->euid;
-    child->gid = parent->gid;
-    child->egid = parent->egid;
-
     child->regs.rax = 0;
     context->rax = child->id;
 
@@ -97,13 +92,6 @@ void sys_execv(Context* context, const char* pathname, char** argv)
         return;
     }
 
-    if (!VFS::can_execute(program, Scheduler::current_task()->euid, Scheduler::current_task()->egid))
-    {
-        kfree(kpathname);
-        context->rax = -EACCES;
-        return;
-    }
-
     long memusage;
     if ((memusage = ELFLoader::check_elf_image(program)) < 0)
     {
@@ -223,9 +211,6 @@ void sys_execv(Context* context, const char* pathname, char** argv)
     ASSERT(image); // If check_elf_image succeeded, load_elf_from_vfs MUST succeed, unless something has gone terribly
                    // wrong.
 
-    if (VFS::is_setuid(program)) task->uid = program->uid;
-    if (VFS::is_setgid(program)) task->gid = program->gid;
-
     strlcpy(task->name, kpathname, sizeof(task->name));
 
     Scheduler::reset_task(task, image);

kernel/src/sys/id.cpp

@@ -3,10 +3,6 @@
 
 #define ID_PID 0
 #define ID_PPID 1
-#define ID_UID 2
-#define ID_EUID 3
-#define ID_GID 4
-#define ID_EGID 5
 
 void sys_getprocid(Context* context, int field)
 {
@@ -20,77 +16,9 @@ void sys_getprocid(Context* context, int field)
         context->rax = Scheduler::current_task()->ppid;
         return;
     }
-    else if (field == ID_UID)
-    {
-        context->rax = Scheduler::current_task()->uid;
-        return;
-    }
-    else if (field == ID_EUID)
-    {
-        context->rax = Scheduler::current_task()->euid;
-        return;
-    }
-    else if (field == ID_GID)
-    {
-        context->rax = Scheduler::current_task()->gid;
-        return;
-    }
-    else if (field == ID_EGID)
-    {
-        context->rax = Scheduler::current_task()->egid;
-        return;
-    }
     else
     {
         context->rax = -EINVAL;
         return;
     }
 }
-
-void sys_setuid(Context* context, int new_uid, int new_euid)
-{
-    Task* current_task = Scheduler::current_task();
-
-    if (!current_task->is_superuser())
-    {
-        if (new_uid != current_task->uid && new_uid != current_task->euid)
-        {
-            context->rax = -EPERM;
-            return;
-        }
-        if (new_euid != current_task->euid && new_euid != current_task->uid)
-        {
-            context->rax = -EPERM;
-            return;
-        }
-    }
-
-    current_task->uid = new_uid;
-    current_task->euid = new_euid;
-
-    context->rax = 0;
-}
-
-void sys_setgid(Context* context, int new_gid, int new_egid)
-{
-    Task* current_task = Scheduler::current_task();
-
-    if (!current_task->is_superuser())
-    {
-        if (new_gid != current_task->gid && new_gid != current_task->egid)
-        {
-            context->rax = -EPERM;
-            return;
-        }
-        if (new_egid != current_task->egid && new_egid != current_task->gid)
-        {
-            context->rax = -EPERM;
-            return;
-        }
-    }
-
-    current_task->gid = new_gid;
-    current_task->egid = new_egid;
-
-    context->rax = 0;
-}

kernel/src/sys/stat.cpp

@@ -5,6 +5,7 @@
 #include "sys/UserMemory.h"
 #include "thread/Scheduler.h"
 
+typedef unsigned long off_t;
 typedef unsigned short mode_t;
 typedef unsigned long ino_t;
 
@@ -14,8 +15,6 @@ struct stat // FIXME: This struct is quite stubbed out.
     mode_t st_mode;
     off_t st_size;
     int st_dev; // FIXME: Implement this.
-    uid_t st_uid;
-    gid_t st_gid;
 };
 
 void do_stat(Context* context, VFS::Node* node, struct stat* buf)
@@ -27,10 +26,8 @@ void do_stat(Context* context, VFS::Node* node, struct stat* buf)
         return;
     }
     kstat->st_ino = node->inode;
-    kstat->st_mode = node->mode | ((1 << (node->type)) * 010000);
+    kstat->st_mode = (mode_t)node->type;
     kstat->st_size = node->length;
-    kstat->st_uid = node->uid;
-    kstat->st_gid = node->gid;
     release_user_ref(kstat);
     context->rax = 0;
 }

kernel/src/sys/stdio.cpp

@@ -207,24 +207,6 @@ void sys_open(Context* context, const char* filename, int flags, mode_t) // FIXM
         return;
     }
 
-    if (can_read && !VFS::can_read(node, current_task->euid, current_task->egid))
-    {
-        kwarnln("open failed because process with uid %d and gid %d couldn't open file %s with mode %d for reading",
-                current_task->euid, current_task->egid, kfilename, node->mode);
-        kfree(kfilename);
-        context->rax = -EACCES;
-        return;
-    }
-
-    if (can_write && !VFS::can_write(node, current_task->euid, current_task->egid))
-    {
-        kwarnln("open failed because process with uid %d and gid %d couldn't open file %s with mode %d for writing",
-                current_task->euid, current_task->egid, kfilename, node->mode);
-        kfree(kfilename);
-        context->rax = -EACCES;
-        return;
-    }
-
     bool able_to_block = (flags & OPEN_NONBLOCK) == 0;
     bool close_on_exec = (flags & OPEN_CLOEXEC) > 0;
 
@@ -322,7 +304,7 @@ void sys_close(Context* context, int fd)
     return;
 }
 
-void sys_mkdir(Context* context, const char* filename, mode_t mode)
+void sys_mkdir(Context* context, const char* filename)
 {
     char* kfilename = strdup_from_user(filename);
     if (!kfilename)
@@ -331,9 +313,7 @@ void sys_mkdir(Context* context, const char* filename, mode_t mode)
         return;
     }
 
-    Task* current_task = Scheduler::current_task();
+    int rc = VFS::mkdir(kfilename);
-
-    int rc = VFS::do_mkdir(kfilename, current_task->euid, current_task->egid, mode);
 
     kfree(kfilename);
 

kernel/src/thread/Scheduler.cpp

@@ -115,7 +115,6 @@ void Scheduler::add_kernel_task(const char* taskname, void (*task)(void))
     new_task->user_task = false;
     new_task->id = free_pid++;
     new_task->ppid = 0;
-    new_task->uid = new_task->euid = new_task->gid = new_task->egid = 0;
     new_task->regs.rip = (uint64_t)task;
     new_task->allocated_stack =
         (uint64_t)MemoryManager::get_pages(TASK_PAGES_IN_STACK); // 16 KB is enough for everyone, right?
@@ -160,7 +159,6 @@ long Scheduler::load_user_task(const char* filename)
     memset(&new_task->regs, 0, sizeof(Context));
     new_task->id = free_pid++;
     new_task->ppid = 0;
-    new_task->uid = new_task->euid = new_task->gid = new_task->egid = 0;
     if (!new_task->allocator.init())
     {
         delete new_task;

kernel/src/thread/Task.cpp

@@ -126,8 +126,3 @@ Descriptor* Task::descriptor_from_fd(int fd, int& error)
     }
     return &files[fd];
 }
-
-bool Task::is_superuser()
-{
-    return euid == 0;
-}

libs/libc/include/bits/getprocid.h

@@ -3,9 +3,5 @@
 
 #define ID_PID 0
 #define ID_PPID 1
-#define ID_UID 2
-#define ID_EUID 3
-#define ID_GID 4
-#define ID_EGID 5
 
 #endif

libs/libc/include/luna/vfs.h

@@ -5,6 +5,4 @@
 #define __VFS_DIRECTORY 0x1
 #define __VFS_DEVICE 0x2
 
-#define __VFS_TO_IFMT(type) ((1 << type) * 010000)
-
 #endif

libs/libc/include/sys/stat.h

@@ -10,49 +10,18 @@ struct stat // FIXME: This struct is quite stubbed out.
     mode_t st_mode;
     off_t st_size;
     int st_dev; // Not implemented.
-    uid_t st_uid;
-    gid_t st_gid;
 };
 
-/* Type of file. */
+#define S_ISDIR(mode) (((mode)&0xf) == __VFS_DIRECTORY)
-#define S_IFMT 070000
+#define S_ISREG(mode) (((mode)&0xf) == __VFS_FILE)
-/* Directory. */
+#define S_ISCHR(mode) (((mode)&0xf) == __VFS_DEVICE)
-#define S_IFDIR __VFS_TO_IFMT(__VFS_DIRECTORY)
-/* Regular file. */
-#define S_IFREG __VFS_TO_IFMT(__VFS_FILE)
-/* Character device. */
-#define S_IFCHR __VFS_TO_IFMT(__VFS_DEVICE)
-
-#define __S_IFCMP(mode, value) (mode & S_IFMT) == value
-
-/* Is it a directory? */
-#define S_ISDIR(mode) (__S_IFCMP((mode), S_IFDIR))
-/* Is it a regular file? */
-#define S_ISREG(mode) (__S_IFCMP((mode), S_IFREG))
-/* Is it a character device? */
-#define S_ISCHR(mode) (__S_IFCMP((mode), S_IFCHR))
-
-#define S_IRWXU 0700
-#define S_IRUSR 0400
-#define S_IWUSR 0200
-#define S_IXUSR 0100
-#define S_IRWXG 070
-#define S_IRGRP 040
-#define S_IWGRP 020
-#define S_IXGRP 010
-#define S_IRWXO 07
-#define S_IROTH 04
-#define S_IWOTH 02
-#define S_IXOTH 01
-#define S_ISUID 04000
-#define S_ISGID 02000
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-    /* Creates a new directory at the path pathname with the specified mode. */
+    /* Creates a new directory at the path pathname. FIXME: For now, mode is ignored. */
     int mkdir(const char* pathname, mode_t mode);
 
     /* Returns information about the file pointed to by fd in buf. */

libs/libc/include/sys/syscall.h

@@ -26,7 +26,5 @@
 #define SYS_getdents 22
 #define SYS_stat 23
 #define SYS_dup2 24
-#define SYS_setuid 25
-#define SYS_setgid 26
 
 #endif

libs/libc/include/sys/types.h

@@ -28,10 +28,4 @@ typedef long int time_t;
 /* Type representing signed time in microseconds. */
 typedef long int suseconds_t;
 
-/* Type representing a user ID. */
-typedef int uid_t;
-
-/* Type representing a group ID. */
-typedef int gid_t;
-
 #endif

libs/libc/src/file.cpp

@@ -3,14 +3,13 @@
 #include <luna.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <unistd.h>
 
 FILE* stderr;
 FILE* stdout;
 FILE* stdin;
 
-static void file_read_buf(FILE* stream)
+void file_read_buf(FILE* stream)
 {
     if (!stream->f_buf)
     {
@@ -32,29 +31,6 @@ static void file_read_buf(FILE* stream)
     stream->f_bufsize = nread;
 }
 
-static int file_parse_mode(const char* mode)
-{
-    int flags = 0;
-    switch (mode[0])
-    {
-    case 'r': flags |= O_RDONLY; break;
-    case 'w':
-        flags |= O_WRONLY;
-        flags |= O_CREAT;
-        flags |= O_TRUNC;
-        break;
-    case 'a':
-        flags |= O_WRONLY;
-        flags |= O_CREAT;
-        flags |= O_APPEND;
-        break;
-    default: errno = EINVAL; return -1;
-    }
-
-    if (strchr(mode, '+')) flags |= O_RDWR;
-    return flags;
-}
-
 extern "C"
 {
     int fclose(FILE* stream)
@@ -80,9 +56,7 @@ extern "C"
 
     FILE* fopen(const char* pathname, const char* mode)
     {
-        int flags = file_parse_mode(mode);
+        int fd = open(pathname, O_RDWR); // FIXME: Use the mode string.
-        if (flags < 0) return NULL;
-        int fd = open(pathname, flags, 0666); // If we create the file, create it as rw-rw-rw-.
         if (fd < 0) { return 0; }
         return fdopen(fd, mode);
     }
@@ -104,12 +78,10 @@ extern "C"
         return stream;
     }
 
-    FILE* freopen(const char* pathname, const char* mode,
+    FILE* freopen(const char* pathname, const char*,
                   FILE* stream) // FIXME: If pathname is NULL, open the original file with the new mode.
     {
-        int flags = file_parse_mode(mode);
+        int fd = open(pathname, O_RDWR); // FIXME: Use the mode string.
-        if (flags < 0) return NULL;
-        int fd = open(pathname, flags, 0666); // If we create the file, create it as rw-rw-rw-.
         if (fd < 0) { return 0; }
 
         fflush(stream); // To make it future-proof.

libs/libc/src/init.cpp

@@ -57,8 +57,8 @@ extern char* program_invocation_name;
 extern "C" void initialize_libc(int, char** argv)
 {
     check_for_file(STDIN_FILENO, &stdin, "/dev/kbd", "r");
-    check_for_file(STDOUT_FILENO, &stdout, "/dev/console", "w");
+    check_for_file(STDOUT_FILENO, &stdout, "/dev/console", "rw");
-    check_for_file(STDERR_FILENO, &stderr, "/dev/console", "w");
+    check_for_file(STDERR_FILENO, &stderr, "/dev/console", "rw");
 
     if (argv) program_invocation_name = argv[0];
 

libs/libc/src/sys/stat.cpp

@@ -4,9 +4,9 @@
 
 extern "C"
 {
-    int mkdir(const char* pathname, mode_t mode)
+    int mkdir(const char* pathname, mode_t)
     {
-        return (int)__lc_fast_syscall2(SYS_mkdir, pathname, mode);
+        return (int)__lc_fast_syscall1(SYS_mkdir, pathname);
     }
 
     int fstat(int fd, struct stat* buf)

libs/libc/src/syscall.cpp

@@ -26,8 +26,6 @@ extern "C" long syscall(long number, ...)
     case SYS_fstat:
     case SYS_stat:
     case SYS_dup2:
-    case SYS_setuid:
-    case SYS_setgid:
     case SYS_pstat: {
         arg arg0 = va_arg(ap, arg);
         arg arg1 = va_arg(ap, arg);