directory.c

#include "hints/directory.h"
#include "helpers/blocks.h"
#include "helpers/bitmap.h"
#include <string.h>    
#include "hints/inode.h"  
#include "helpers/slist.h"
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>

void directory_init() {
  int inode_alloced = alloc_inode();
  if (inode_alloced == -1) {
    printf("Alloc inode failed");
    return;
  }

  inode_t* inodes = get_inode(inode_alloced);
  if (inodes) {
    inodes->mode = 040755;  // Directory permissions: rwxr-xr-x
    inodes->refs = 1;
  }

  int block_alloced = alloc_block();
  if (block_alloced == -1) {
    printf("Block allocation failed");
    free_inode(inode_alloced);
    return;
  }

  void* block = blocks_get_block(block_alloced);
  if (!block) {
    printf("The block pointer is null");
    free_block(block_alloced);
    free_inode(inode_alloced);
    return;
  }

  dirent_t* dir = (dirent_t*)block;
  memset(dir, 0, BLOCK_SIZE);

  strcpy(dir[0].name, ".");
  dir[0].inum = inode_alloced;

  strcpy(dir[1].name, "..");
  dir[1].inum = inode_alloced;

  inodes->block = block_alloced;
  inodes->size = 2 * sizeof(dirent_t);
}

int directory_lookup(inode_t *di, const char *name) {
  if (!di || !name) {
    return -1;
  }

  void* block = blocks_get_block(di->block);
  if (!block) {
    return -1;
  }
  
  dirent_t* dir = (dirent_t*)block;
  int entry_count = di->size / sizeof(dirent_t);

  for (int i = 0; i < entry_count; i++) {
    if (dir[i].name[0] != '\0' && strcmp(dir[i].name, name) == 0) {
      return dir[i].inum;
    }
  }
  return -1;
}

int directory_put(inode_t *di, const char *name, int inum) {
  if (!di || !name || inum < 0) {
    return -EINVAL;
  }

  if ((di->mode & 040000) != 040000) {
    return -ENOTDIR;
  }

  if (strlen(name) >= DIR_NAME_LENGTH) {
    return -ENAMETOOLONG;
  }

  void* block = blocks_get_block(di->block);
  if (!block) {
    return -EIO;
  }

  dirent_t* dir_entries = (dirent_t*)block;
  int entry_count = di->size / sizeof(dirent_t);

  // Check if name already exists
  for (int i = 0; i < entry_count; i++) {
    if (dir_entries[i].name[0] != '\0' && strcmp(dir_entries[i].name, name) == 0) {
      return -EEXIST;
    }
  }

  // Find first free entry or use next slot
  int free_index = entry_count;
  for (int i = 0; i < entry_count; i++) {
    if (dir_entries[i].name[0] == '\0') {
      free_index = i;
      break;
    }
  }

  if (free_index * sizeof(dirent_t) >= BLOCK_SIZE) {
    return -ENOSPC;
  }

  strcpy(dir_entries[free_index].name, name);
  dir_entries[free_index].inum = inum;
  
  if (free_index == entry_count) {
    di->size += sizeof(dirent_t);
  }

  return 0;
}

int directory_delete(inode_t *di, const char *name) {
  if (!di || !name) {
    return -EINVAL;
  }

  void* block = blocks_get_block(di->block);
  if (!block) {
    return -EIO;
  }

  dirent_t* dir_entries = (dirent_t*)block;
  int entry_count = di->size / sizeof(dirent_t);

  if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
    return -EINVAL;
  }

  for (int i = 0; i < entry_count; i++) {
    if (dir_entries[i].name[0] != '\0' && strcmp(dir_entries[i].name, name) == 0) {
      memset(&dir_entries[i], 0, sizeof(dirent_t));
      if (i == entry_count - 1) {
        // Adjust size if removing last entry
        while (i > 0 && dir_entries[i-1].name[0] == '\0') {
          i--;
        }
        di->size = (i + 1) * sizeof(dirent_t);
      }
      return 0;
    }
  }
  return -ENOENT;
}

slist_t *directory_list(const char *path) {
  int inum;
  inode_t* dir_inode;

  if (strcmp(path, "/") == 0) {
    inum = 0;
  } else {
    // Get inode for the target directory
    const char* clean_path = (*path == '/') ? path + 1 : path;
    inode_t* current = get_inode(0);
    inum = 0;

    char* path_copy = strdup(clean_path);
    char* component = strtok(path_copy, "/");

    while (component) {
      inum = directory_lookup(current, component);
      if (inum == -1) {
        free(path_copy);
        return NULL;
      }
      current = get_inode(inum);
      if (!current) {
        free(path_copy);
        return NULL;
      }
      component = strtok(NULL, "/");
    }
    free(path_copy);
  }

  dir_inode = get_inode(inum);
  if (!dir_inode) {
    return NULL;
  }

  void* block = blocks_get_block(dir_inode->block);
  if (!block) {
    return NULL;
  }

  dirent_t* entries = (dirent_t*)block;
  int entry_count = dir_inode->size / sizeof(dirent_t);
  slist_t* list = NULL;

  for (int i = 0; i < entry_count; i++) {
    if (entries[i].name[0] != '\0') {
      list = slist_cons(entries[i].name, list);
    }
  }

  return list;
}

void print_directory(inode_t *dd) {
  if (!dd) {
    printf("Invalid directory inode\n");
    return;
  }

  void* block = blocks_get_block(dd->block);
  if (!block) {
    printf("Invalid directory block\n");
    return;
  }

  dirent_t* entries = (dirent_t*)block;
  int entry_count = dd->size / sizeof(dirent_t);

  for (int i = 0; i < entry_count; i++) {
    if (entries[i].name[0] != '\0') {
      printf("Name: %s, Inode: %d\n", entries[i].name, entries[i].inum);
    }
  }
}