/*
* Returns the index to a directory table
*/
static int ifs_get_directory(struct device *dev, int parent, char *dir)
{
if(dir[0] == 0 && parent == 0)
return 0;
bool has_sep = contains(dir, '/');
int32_t directory[256];
struct ifs_entry dentry;
device_read(dev, &dentry, sizeof(struct ifs_entry), ifs_get_address(dev, parent));
int dtable = dentry.data_index;
device_read(dev, directory, 1024, ifs_get_address(dev, dtable));
for (int i = 0; i < 256 && directory[i] != -1; i++) {
int e = directory[i];
struct ifs_entry entry;
device_read(dev, &entry, sizeof(struct ifs_entry), ifs_get_address(dev, e));
if (has_sep && strncmp(dir, entry.file_name, strindx(dir, '/')) == 0) {
return ifs_get_directory(dev, e, strrchr(dir, '/') + 1);
} else if (!has_sep) {
if (strncmp(entry.file_name, dir, strlen(entry.file_name)) == 0) {
return e;
}
}
}
return -1;
}
/*
* Reads an IFS directory entry
*/
static int ifs_read_dir(struct device *dev, ino_t ino, int d, struct dirent *dent)
{
struct ifs_entry entry;
int32_t *directory = (int32_t *)kalloc(1024);
device_read(dev, &entry, sizeof(struct ifs_entry), ifs_get_address(dev, ino));
device_read(dev, directory, 1024, ifs_get_address(dev, entry.data_index));
if (directory[d] == -1)
return -1;
device_read(dev, &entry, sizeof(struct ifs_entry), ifs_get_address(dev, directory[d]));
dent->d_ino = directory[d];
switch(entry.file_type) {
case IFS_DIRECTORY:
dent->d_type = DT_DIR;
break;
case IFS_REG_FILE:
dent->d_type = DT_REG;
break;
case IFS_LINK:
dent->d_type = DT_LNK;
break;
default:
dent->d_type = DT_UNKNOWN;
break;
}
memcpy(dent->d_name, entry.file_name, 256);
kfree(directory);
return 0;
}
/*
* Gets an IFSFileEntry from a certain directory, and copies it
* into dest
*/
static int ifs_get_file_entry(int parent, char* dir, IFSFileEntry* dest)
{
bool has_sep = contains(dir, '/');
int32_t* directory = (int32_t*)(initrd + ifs_get_address(parent));
for(int i = 0; i < 256&& directory[i] != -1; i++)
{
int e = directory[i];
IFSFileEntry* entry = (IFSFileEntry*)(initrd + ifs_get_address(e));
if(has_sep && strncmp(dir, entry->file_name, strindx(dir, '/')) == 0)
{
return ifs_get_file_entry(entry->data_index, strrchr(dir, '/') + 1, dest);
}
else if (!has_sep)
{
if(strcmp(entry->file_name, dir) == 0)
{
memcpy(dest, entry, sizeof(IFSFileEntry));
return 1;
}
}
}
return 0;
}
static int ifs_chmod(struct device *dev, const char *path, mode_t newmode)
{
struct ifs_entry entry;
if (ifs_get_directory(dev, 0, path) != -1) {
ino_t ino = ifs_get_directory(dev, 0, path);
device_read(dev, &entry, sizeof(struct ifs_entry), ifs_get_address(dev, ino));
entry.mode = newmode;
device_write(dev, &entry, ifs_get_address(dev, ino), sizeof(struct ifs_entry));
return 0;
}
return ENOENT;
}
static int ifs_readlink(struct device *dev, const char *path, char *buf, int len)
{
struct ifs_entry entry;
if (ifs_get_directory(dev, 0, path) != -1) {
ino_t ino = ifs_get_directory(dev, 0, path);
device_read(dev, &entry, sizeof(struct ifs_entry), ifs_get_address(dev, ino));
if(entry.file_type == IFS_LINK) {
device_read(dev, buf, len % 1024, ifs_get_address(dev, entry.data_index));
return 0;
}
}
return ENOENT;
}
/*
* Reads a file, copies data into buff
*/
static size_t ifs_read_file (int inode, char* buff, size_t len, uint32_t addr)
{
IFSFileEntry* entry = (IFSFileEntry*)(initrd + ifs_get_address(inode));
int offset = addr - ((addr / vol_header->file_block_size) * vol_header->file_block_size);
for(int i = 0; i < len; i += vol_header->file_block_size)
{
int block = len / vol_header->file_block_size;
int rlen = len - i;
memcpy(buff + i, initrd + offset + ifs_get_address(ifs_find_block(vol_header->file_block_size, entry->data_index, addr + i, 0)), rlen);
offset = 0;
}
return len;
}
/*
* Reads a file, copies data into buff
*/
static size_t ifs_read_file(struct device *dev, ino_t ino, char *buff, off_t addr, size_t len)
{
struct ifs_entry entry;
struct ifs_volume_hdr vol_header;
size_t bytes_read = 0;
device_read(dev, &vol_header, sizeof(struct ifs_volume_hdr), 0);
device_read(dev, &entry, sizeof(struct ifs_entry), ifs_get_address(dev, ino));
int i = 0;
int offset = addr % vol_header.file_block_size;
int blk = entry.data_index;
int start = addr - addr % vol_header.file_block_size;
int end = addr + len > entry.file_size ? 0 : addr + len;
do {
struct ifs_block block;
ifs_get_block(dev, blk, &block);
if(i >= start && i < end) {
int rlen = i + vol_header.file_block_size >= len ? len % vol_header.file_block_size : vol_header.file_block_size;
bytes_read += device_read(dev, buff + bytes_read, rlen, block.data + offset);
offset = 0;
}
i += vol_header.file_block_size;
blk = block.next;
} while(blk);
return bytes_read;
}
/*
* Creates an image
*/
void create_image(void* image, int size)
{
initrd = image;
vol_header = (IFSVolume*)image;
memset(vol_header, 0, size);
vol_header->file_block_size = 1024;
vol_header->block_pool_size = (0xFFFF * sizeof(IFSBlock));
placement = sizeof(IFSVolume) + (0xFFFF * sizeof(IFSBlock)) ;
block_pool = (image + sizeof(IFSVolume));
for(int i = 0; i < 0xFFFF; i++)
block_pool[i].state = BLOCK_NONEXISTENT;
vol_header->root_directory = 0;
IFSFileEntry* rootdir = ifs_create_file_entry();
rootdir->data_index = 1;
IFSBlock* root = ifs_block_alloc();
memset(initrd + ifs_get_address(1), 0xFF, 1024);
/*
* Yes Courtney, even though you completely f****d me over
* in just about every respect, I immortalized you in the IFS
* magic number. Not that you will ever see this. Maybe because
* I still love you, maybe because, well I have no f*****g clue....
*
* Magic number: 0xCB0A0D0D (Big endian)
*/
vol_header->mag0 = 0xCB;
vol_header->mag1 = 0x0A;
vol_header->mag2 = 0x0D;
vol_header->mag3 = 0x0D;
}
static inline int ifs_remove_entry(struct device *dev, const char *path, struct ifs_entry *entry)
{
int parent = ifs_get_parent(dev, path);
struct ifs_entry p_ent;
device_read(dev, &p_ent, sizeof(struct ifs_entry), ifs_get_address(dev, parent));
int32_t files[256];
device_read(dev, files, 1024, ifs_get_address(dev, p_ent.data_index));
int i = 0;
while(files[i] != entry->block_index && files[i] != -1) i++;
for(int j = i; j < 255 && files[j] != -1; j++) {
files[j] = files[j + 1];
}
device_write(dev, files, 1024, ifs_get_address(dev, p_ent.data_index));
return 0;
}
static inline int ifs_insert_entry(struct device *dev, const char *path, struct ifs_entry *entry)
{
int e_block = ifs_block_alloc(dev, 1024);
entry->block_index = e_block;
int parent = ifs_get_parent(dev, path);
struct ifs_entry p_ent;
device_read(dev, &p_ent, sizeof(struct ifs_entry), ifs_get_address(dev, parent));
int32_t *files = (int32_t *)kalloc(1024);
device_read(dev, files, 1024, ifs_get_address(dev, p_ent.data_index));
int i = 0;
while (files[i] != -1) i++;
files[i] = e_block;
device_write(dev, files, 1024, ifs_get_address(dev, p_ent.data_index));
device_write(dev, entry, sizeof(struct ifs_entry), ifs_get_address(dev, e_block));
kfree(files);
return e_block;
}
static int ifs_rmdir(struct device *dev, const char *path)
{
struct ifs_entry entry;
if (ifs_get_directory(dev, 0, path) != -1) {
ino_t ino = ifs_get_directory(dev, 0, path);
device_read(dev, &entry, sizeof(struct ifs_entry), ifs_get_address(dev, ino));
if(entry.file_type != IFS_DIRECTORY) return ENOTDIR;
ifs_remove_entry(dev, path, &entry);
ifs_free_blockgroup(dev, &entry);
ifs_free_block(dev, ino);
return 0;
}
return ENOENT;
}
static int ifs_fstat(struct device *dev, ino_t ino, struct stat *stat_struct)
{
struct ifs_entry entry;
device_read(dev, &entry, sizeof(struct ifs_entry), ifs_get_address(dev, ino));
stat_struct->st_mode = entry.mode;
stat_struct->st_ctime = entry.created_time;
stat_struct->st_mtime = entry.modified_time;
stat_struct->st_atime = entry.modified_time;
stat_struct->st_ino = ino;
stat_struct->st_size = entry.file_size;
stat_struct->st_uid = 0;
stat_struct->st_gid = 1;
return 0;
}
/*
* Returns the index to a directory table
*/
static int ifs_get_directory(int parent, char* dir)
{
bool has_sep = contains(dir, '/');
int32_t* directory = (int32_t*)(initrd + ifs_get_address(parent));
for(int i = 0; i < 256 && directory[i] != -1; i++)
{
int e = directory[i];
IFSFileEntry* entry = (IFSFileEntry*)(initrd + ifs_get_address(e));
if(has_sep && strncmp(dir, entry->file_name, strindx(dir, '/')) == 0)
{
return ifs_get_directory(entry->data_index, strrchr(dir, '/') + 1);
}
else if (!has_sep)
{
if(strncmp(entry->file_name, dir, strlen(entry->file_name)) == 0)
{
return e;
}
}
}
return -1;
}
static int ifs_symlink(struct device *dev, const char *from, const char *to)
{
int d_block = ifs_block_alloc(dev, 1024);
struct ifs_entry dir;
dir.mode = 0444;
dir.file_type = IFS_LINK;
dir.data_index = d_block;
dir.file_size = 1024;
dir.uid = getuid();
dir.gid = getgid();
strcpy(dir.file_name, basename(from));
int e = ifs_insert_entry(dev, from, &dir);
device_write(dev, to, (strlen(to) + 1) % 1024, ifs_get_address(dev, d_block));
return 0;
}
static int ifs_creat(struct device *dev, const char *path, mode_t mode)
{
int d_block = ifs_block_alloc(dev, 1024);
struct ifs_entry dir;
dir.mode = mode;
dir.file_type = IFS_DIRECTORY;
dir.data_index = d_block;
dir.file_size = 0;
dir.uid = getuid();
dir.gid = getgid();
strcpy(dir.file_name, basename(path));
int e = ifs_insert_entry(dev, path, &dir);
int32_t files[256];
memset(files, 0xFF, 1024);
device_write(dev, files, 1024, ifs_get_address(dev, d_block));
}
static int ifs_read_ino(struct device *dev, struct inode *inos, const char *path)
{
struct ifs_entry entry;
if (ifs_get_directory(dev, 0, path) != -1) {
ino_t ino = ifs_get_directory(dev, 0, path);
device_read(dev, &entry, sizeof(struct ifs_entry), ifs_get_address(dev, ino));
inos->i_ino = ino;
inos->i_size = entry.file_size;
inos->i_dev = dev->dev_id;
inos->i_mode = entry.mode;
inos->i_uid = entry.uid;
inos->i_gid = entry.gid;
inos->i_islnk = entry.file_type == IFS_LINK;
inos->i_isfifo = entry.file_type == IFS_PIPE;
return 0;
} else {
return -1;
}
}
/*
* Returns an IFS directory table containing up to
* 256 files
*/
static int* ifs_get_directory_table(int inode)
{
return (int*)(initrd + ifs_get_address(inode));
}
