fix: cleaning up source files

systeme_fichiers/libminix/inode_info.c

@@ -13,7 +13,10 @@ int main(int argc, char *argv[]) {
     struct minix_inode inode = {0};
     int inode_nb = atoi(argv[2]);
 
-    marshal_inode(&inode, inode_nb, argv[1]);
+    if (marshal_inode(&inode, inode_nb, argv[1]) == -1) {
+        fprintf(stdout, "marshal_inode has failed\n");
+        exit(EXIT_FAILURE);
+    }
     read_inode(&inode);
 
     return EXIT_SUCCESS;

systeme_fichiers/libminix/list_inodes.c

@@ -29,13 +29,13 @@ int main(int argc, char *argv[]) {
                 fprintf(stderr, "Exiting...\n");
                 exit(EXIT_FAILURE);
             }
-            fprintf(stdout, "Inode n°%d ", i);
+            fprintf(stdout, "\nInode n°%d ", i);
             read_inode(&inode);
         }
     }
 
     fprintf(stdout,
-            "Number of allocated inodes : %d\tTotal number of inodes : %d\n",
+            "\nNumber of allocated inodes : %d\tTotal number of inodes : %d\n",
             nb_allocated_inodes, sb.s_ninodes);
 
     return EXIT_SUCCESS;

systeme_fichiers/libminix/read_dir.c

@@ -22,7 +22,7 @@ int main(int argc, char *argv[]) {
     }
 
     for (int i = 0; i < nb_blocks_used; i++) {
-        ssize_t phys_num = bmap(inode, argv[1], i);
+        ssize_t phys_num = bmap(&inode, argv[1], i);
 
         if (phys_num == -1) {
             fprintf(stderr, "bmap has failed...\n");

systeme_fichiers/libminix/read_file.c

@@ -21,7 +21,7 @@ int main(int argc, char *argv[]) {
     }
 
     for (int i = 0; i < nb_blocks_used; i++) {
-        ssize_t phys_num = bmap(inode, argv[1], i);
+        ssize_t phys_num = bmap(&inode, argv[1], i);
 
         if (phys_num == -1) {
             fprintf(stderr, "bmap has failed...\n");

systeme_fichiers/libminix/struct/minix.c

@@ -6,8 +6,8 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-int marshal_sb(struct minix_super_block *sb, const char *filepath) {
-    int fd = open(filepath, O_RDONLY);
+int marshal_sb(struct minix_super_block *sb, const char *img_filepath) {
+    int fd = open(img_filepath, O_RDONLY);
 
     if (fd == -1) {
         perror("open");
@@ -34,8 +34,8 @@ int marshal_sb(struct minix_super_block *sb, const char *filepath) {
     return 0;
 }
 
-bool is_inode_allocated(uint32_t inode_nb, const char *filepath) {
-    int fd = open(filepath, O_RDONLY);
+bool is_inode_allocated(const uint32_t inode_nb, const char *img_filepath) {
+    int fd = open(img_filepath, O_RDONLY);
     if (fd == -1) {
         perror("open");
         close(fd);
@@ -67,16 +67,16 @@ bool is_inode_allocated(uint32_t inode_nb, const char *filepath) {
     return false;
 }
 
-int marshal_inode(struct minix_inode *inode, uint32_t inode_nb,
-                  const char *filepath) {
+int marshal_inode(struct minix_inode *inode, const uint32_t inode_nb,
+                  const char *img_filepath) {
     struct minix_super_block sb = {0};
 
-    if (marshal_sb(&sb, filepath) == -1) {
+    if (marshal_sb(&sb, img_filepath) == -1) {
         perror("marshal_sb");
         return -1;
     }
 
-    int fd = open(filepath, O_RDONLY);
+    int fd = open(img_filepath, O_RDONLY);
 
     if (fd == -1) {
         perror("open");
@@ -87,7 +87,7 @@ int marshal_inode(struct minix_inode *inode, uint32_t inode_nb,
     lseek(fd, BLOCK_SIZE * BITMAP_INODE_FIRST_IDX, SEEK_SET);
 
     if (inode_nb == 0 || inode_nb > sb.s_ninodes ||
-        !is_inode_allocated(inode_nb, filepath)) {
+        !is_inode_allocated(inode_nb, img_filepath)) {
         fprintf(stderr, "Inode isn't allocated or inode value is invalid\n");
         return -1;
     }
@@ -111,7 +111,7 @@ int marshal_inode(struct minix_inode *inode, uint32_t inode_nb,
     return 0;
 }
 
-int read_sb(struct minix_super_block *sb) {
+int read_sb(const struct minix_super_block *sb) {
     uint16_t inode_table_size = sb->s_ninodes / sizeof(struct minix_inode);
     uint16_t idx_first_block_inode_table =
         sb->s_firstdatazone - inode_table_size;
@@ -137,7 +137,7 @@ int read_sb(struct minix_super_block *sb) {
     return 0;
 }
 
-int read_inode(struct minix_inode *inode) {
+int read_inode(const struct minix_inode *inode) {
     uint16_t file_type = inode->i_mode >> 12;
 
     fprintf(stdout, "========= MINIX inode =========\n");
@@ -216,8 +216,9 @@ int read_inode(struct minix_inode *inode) {
     return 0;
 }
 
-int read_indir_block(uint16_t *buf, const char *filepath, size_t block_number) {
-    int fd = open(filepath, O_RDONLY);
+int read_indir_block(uint16_t *buf, const char *img_filepath,
+                     const size_t block_number) {
+    int fd = open(img_filepath, O_RDONLY);
 
     if (fd == -1) {
         perror("open");
@@ -245,18 +246,18 @@ int read_indir_block(uint16_t *buf, const char *filepath, size_t block_number) {
     return 0;
 }
 
-ssize_t bmap(const struct minix_inode inode, const char *filepath,
+ssize_t bmap(const struct minix_inode *inode, const char *img_filepath,
              size_t logical_block) {
-    if (logical_block < sizeof(inode.i_zone) / sizeof(uint16_t)) {
-        return inode.i_zone[logical_block];
+    if (logical_block < sizeof(inode->i_zone) / sizeof(uint16_t)) {
+        return inode->i_zone[logical_block];
     }
 
-    logical_block = logical_block - sizeof(inode.i_zone) / sizeof(uint16_t);
+    logical_block = logical_block - sizeof(inode->i_zone) / sizeof(uint16_t);
 
     if (logical_block < BLOCK_SIZE / sizeof(uint16_t)) {
         uint16_t buf[BLOCK_SIZE] = {0};
 
-        if (read_indir_block(buf, filepath, inode.i_indir_zone) == -1) {
+        if (read_indir_block(buf, img_filepath, inode->i_indir_zone) == -1) {
             fprintf(stderr, "read_indir_block failed\n");
             return -1;
         }
@@ -271,13 +272,14 @@ ssize_t bmap(const struct minix_inode inode, const char *filepath,
         uint16_t buf1[BLOCK_SIZE] = {0};
         uint16_t buf2[BLOCK_SIZE] = {0};
 
-        if (read_indir_block(buf1, filepath, inode.i_dbl_indir_zone) == -1) {
+        if (read_indir_block(buf1, img_filepath, inode->i_dbl_indir_zone) ==
+            -1) {
             fprintf(stderr, "read_indir_block failed\n");
             return -1;
         }
 
         if (read_indir_block(
-                buf2, filepath,
+                buf2, img_filepath,
                 buf1[logical_block / BLOCK_SIZE * sizeof(uint16_t)]) == -1) {
             fprintf(stderr, "read_indir_block failed\n");
             return -1;
@@ -317,7 +319,7 @@ int read_data_block(char *buf, const char *filepath, size_t phys_num_block) {
     return 0;
 }
 
-int lookup_entry(struct minix_inode *inode, const char *token,
+int lookup_entry(const struct minix_inode *inode, const char *token,
                  const char *img_filepath) {
     int nb_blocks_used = inode->i_size / BLOCK_SIZE;
     if (inode->i_size % BLOCK_SIZE != 0) {
@@ -325,7 +327,7 @@ int lookup_entry(struct minix_inode *inode, const char *token,
     }
 
     for (int i = 0; i < nb_blocks_used; i++) {
-        ssize_t phys_num = bmap(*inode, img_filepath, i);
+        ssize_t phys_num = bmap(inode, img_filepath, i);
 
         if (phys_num == -1) {
             fprintf(stderr, "bmap has failed...\n");
@@ -392,7 +394,7 @@ int namei(const char *img_filepath, char *filepath) {
     }
 
     for (int i = 0; i < nb_blocks_used; i++) {
-        ssize_t phys_num = bmap(inode, img_filepath, i);
+        ssize_t phys_num = bmap(&inode, img_filepath, i);
 
         if (phys_num == -1) {
             fprintf(stderr, "bmap has failed...\n");

systeme_fichiers/libminix/struct/minix.h

@@ -46,14 +46,15 @@ struct __attribute__((packed)) minix_super_block {
     uint16_t s_state;         // was the FS properly unmounted ?
 };
 
-extern int marshal_sb(struct minix_super_block *sb, const char *filepath);
-extern int marshal_inode(struct minix_inode *inode, uint32_t inode_nb,
-                         const char *filepath);
-extern bool is_inode_allocated(uint32_t inode_nb, const char *filepath);
-extern int read_sb(struct minix_super_block *sb);
-extern int read_inode(struct minix_inode *inode);
-extern int read_indir_block(uint16_t *buf, const char *filepath,
-                            size_t block_number);
+extern int marshal_sb(struct minix_super_block *sb, const char *img_filepath);
+extern int marshal_inode(struct minix_inode *inode, const uint32_t inode_nb,
+                         const char *img_filepath);
+extern bool is_inode_allocated(const uint32_t inode_nb,
+                               const char *img_filepath);
+extern int read_sb(const struct minix_super_block *sb);
+extern int read_inode(const struct minix_inode *inode);
+extern int read_indir_block(uint16_t *buf, const char *img_filepath,
+                            const size_t block_number);
 /**
  * @brief Returns physical number of data block based on its logical
  * representation
@@ -63,7 +64,7 @@ extern int read_indir_block(uint16_t *buf, const char *filepath,
  * @param logical_block_idx
  * @return
  */
-extern ssize_t bmap(const struct minix_inode inode, const char *filepath,
+extern ssize_t bmap(const struct minix_inode *inode, const char *img_filepath,
                     size_t logical_block_idx);
 
 /**
@@ -76,7 +77,7 @@ extern ssize_t bmap(const struct minix_inode inode, const char *filepath,
  * @return
  */
 extern int read_data_block(char *buf, const char *filepath,
-                           size_t phys_num_block);
+                           const size_t phys_num_block);
 
 /**
  * @brief
@@ -85,7 +86,7 @@ extern int read_data_block(char *buf, const char *filepath,
  * @param token
  * @return -1 in case of an error or if entry hasn't been found
  */
-extern int lookup_entry(struct minix_inode *inode, const char *token,
+extern int lookup_entry(const struct minix_inode *inode, const char *token,
                         const char *img_filepath);
 
 /**