Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Update shell.c #13

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Update shell.c #13

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
364 changes: 348 additions & 16 deletions src/shell.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,27 +28,359 @@ void shell() {
}
}

// TODO: 4. Implement printCWD function
void printCWD(byte cwd) {}
// Implement printCWD function
void printCWD(byte cwd) {
struct node_fs node_fs_buf;
char path[256];
int i;
int length = 0;

// TODO: 5. Implement parseCommand function
void parseCommand(char* buf, char* cmd, char arg[2][64]) {}
readSector(&(node_fs_buf.nodes[0]), FS_NODE_SECTOR_NUMBER);
readSector(&(node_fs_buf.nodes[32]), FS_NODE_SECTOR_NUMBER);

// TODO: 6. Implement cd function
void cd(byte* cwd, char* dirname) {}
if (cwd == FS_NODE_P_ROOT) {
printString("/");
return;
}

while (cwd != FS_NODE_P_ROOT) {
for (i = strlen(node_fs_buf.nodes[cwd].node_name) - 1; i >= 0; i--) {
path[length++] = node_fs_buf.nodes[cwd].node_name[i];
}
path[length++] = '/';
cwd = node_fs_buf.nodes[cwd].parent_index;
}
path[length] = '\0';

for (i = length - 1; i >= 0; i--) {
interrupt(0x10, 0xE << 8 | path[i], 0, 0, 0);
}
}

// Implement parseCommand function
void parseCommand(char* buf, char* cmd, char arg[2][64]) {
int i = 0;
int j = 0;
int arg_idx = 0;

// Skip leading whitespace
while (buf[i] == ' ') i++;

// Read command
while (buf[i] != ' ' && buf[i] != '\0') {
cmd[j++] = buf[i++];
}
cmd[j] = '\0';

// Skip whitespace before arguments
while (buf[i] == ' ') i++;

// Read arguments
while (buf[i] != '\0') {
j = 0;
while (buf[i] != ' ' && buf[i] != '\0') {
arg[arg_idx][j++] = buf[i++];
}
arg[arg_idx][j] = '\0';
arg_idx++;
while (buf[i] == ' ') i++;
}

// Fill remaining argument slots with empty strings
for (; arg_idx < 2; arg_idx++) {
arg[arg_idx][0] = '\0';
}
}

void cd(byte* cwd, char* dirname) {
struct node_fs node_fs_buf;
int i;

// Read the node sectors into memory
readSector(&(node_fs_buf.nodes[0]), FS_NODE_SECTOR_NUMBER);
readSector(&(node_fs_buf.nodes[32]), FS_NODE_SECTOR_NUMBER);

// Handle special case: cd ..
if (strcmp(dirname, "..") == 1) {
if (*cwd != FS_NODE_P_ROOT) {
*cwd = node_fs_buf.nodes[*cwd].parent_index;
}
return;
}

// Handle special case: cd /
if (strcmp(dirname, "/") == 1) {
*cwd = FS_NODE_P_ROOT;
return;
}

// Iterate through the nodes to find the target directory by name
for (i = 0; i < FS_MAX_NODE; i++) {
if (node_fs_buf.nodes[i].parent_index == *cwd &&
strcmp(node_fs_buf.nodes[i].node_name, dirname) == 1) {
// Check if the found node is a directory
if (node_fs_buf.nodes[i].data_index == FS_NODE_D_DIR) {
*cwd = i;
} else {
printString("Not a directory!\n");
}
return;
}
}

// If target directory is not found, print an error message
printString("Directory not found\n");
}

void ls(byte cwd, char* dirname) {
struct node_fs node_fs_buf;
int i;
byte target_cwd = cwd;

// Baca sektor node dari file system
readSector(&(node_fs_buf.nodes[0]), FS_NODE_SECTOR_NUMBER);
readSector(&(node_fs_buf.nodes[32]), FS_NODE_SECTOR_NUMBER);

if (strcmp(dirname, ".") != 0 && strlen(dirname) > 0) {
// Cari direktori yang sesuai dengan dirname
for (i = 0; i < FS_MAX_NODE; i++) {
if (node_fs_buf.nodes[i].parent_index == cwd &&
strcmp(node_fs_buf.nodes[i].node_name, dirname) == 0 &&
node_fs_buf.nodes[i].data_index == FS_NODE_D_DIR) {
target_cwd = i;
break;
}
}
if (i == FS_MAX_NODE) {
printString("Directory not found\n");
return;
}
}

// Tampilkan isi direktori
for (i = 0; i < FS_MAX_NODE; i++) {
if (node_fs_buf.nodes[i].parent_index == target_cwd) {
printString(node_fs_buf.nodes[i].node_name);
if (node_fs_buf.nodes[i].data_index == FS_NODE_D_DIR) {
printString("/");
}
printString(" ");
}
}
printString("\n");
}


void mv(byte cwd, char* src, char* dst) {
struct node_fs node_fs_buf;
int i, src_index = -1, dst_dir_index = cwd;
char* outputname;

// Baca sektor node dari file system
readSector(&(node_fs_buf.nodes[0]), FS_NODE_SECTOR_NUMBER);
readSector(&(node_fs_buf.nodes[32]), FS_NODE_SECTOR_NUMBER);

// Cari sumber file
for (i = 0; i < FS_MAX_NODE; i++) {
if (node_fs_buf.nodes[i].parent_index == cwd && strcmp(node_fs_buf.nodes[i].node_name, src) == 0) {
src_index = i;
break;
}
}

if (src_index == -1) {
printString("File not found\n");
return;
}

// Parsing dst untuk mendapatkan direktori tujuan dan nama output
if (dst[0] == '/') {
dst_dir_index = FS_NODE_P_ROOT;
outputname = dst + 1;
} else if (dst[0] == '.' && dst[1] == '.' && dst[2] == '/') {
dst_dir_index = node_fs_buf.nodes[cwd].parent_index;
outputname = dst + 3;
} else {
outputname = dst;
}

// Cek jika dst adalah direktori
for (i = 0; i < FS_MAX_NODE; i++) {
if (node_fs_buf.nodes[i].parent_index == dst_dir_index && strcmp(node_fs_buf.nodes[i].node_name, outputname) == 0) {
printString("Destination already exists\n");
return;
}
}

// Pindahkan file
node_fs_buf.nodes[src_index].parent_index = dst_dir_index;
strcpy(node_fs_buf.nodes[src_index].node_name, outputname);

// Tulis kembali sektor node ke file system
writeSector(&(node_fs_buf.nodes[0]), FS_NODE_SECTOR_NUMBER);
writeSector(&(node_fs_buf.nodes[32]), FS_NODE_SECTOR_NUMBER);

printString("File moved\n");
}

void cp(byte cwd, char* src, char* dst) {
struct node_fs node_fs_buf;
struct data_fs data_fs_buf;
struct file_metadata file_meta;
enum fs_return status;
int i, src_index = -1, dst_dir_index = cwd;
char* outputname;

// Baca sektor node dan data dari file system
readSector(&(node_fs_buf.nodes[0]), FS_NODE_SECTOR_NUMBER);
readSector(&(node_fs_buf.nodes[32]), FS_NODE_SECTOR_NUMBER);
readSector(&(data_fs_buf.datas[0]), FS_DATA_SECTOR_NUMBER);
readSector(&(data_fs_buf.datas[16]), FS_DATA_SECTOR_NUMBER);

// Cari sumber file
for (i = 0; i < FS_MAX_NODE; i++) {
if (node_fs_buf.nodes[i].parent_index == cwd && strcmp(node_fs_buf.nodes[i].node_name, src) == 0) {
src_index = i;
break;
}
}

if (src_index == -1) {
printString("File not found\n");
return;
}

// Parsing dst untuk mendapatkan direktori tujuan dan nama output
if (dst[0] == '/') {
dst_dir_index = FS_NODE_P_ROOT;
outputname = dst + 1;
} else if (dst[0] == '.' && dst[1] == '.' && dst[2] == '/') {
dst_dir_index = node_fs_buf.nodes[cwd].parent_index;
outputname = dst + 3;
} else {
outputname = dst;
}

// Cek jika dst adalah direktori
for (i = 0; i < FS_MAX_NODE; i++) {
if (node_fs_buf.nodes[i].parent_index == dst_dir_index && strcmp(node_fs_buf.nodes[i].node_name, outputname) == 0) {
printString("Destination already exists\n");
return;
}
}

// Set metadata file untuk penyalinan
file_meta.parent_index = dst_dir_index;
file_meta.filesize = 0;
strcpy(file_meta.node_name, outputname);

for (i = 0; i < FS_MAX_SECTOR; i++) {
file_meta.buffer[i] = 0;
}

fsRead(&file_meta, &status);
if (status != FS_SUCCESS) {
printString("Error reading file\n");
return;
}

fsWrite(&file_meta, &status);
if (status != FS_SUCCESS) {
printString("Error writing file\n");
return;
}

printString("File copied\n");
}

void cat(byte cwd, char* filename) {
struct node_fs node_fs_buf;
struct file_metadata file_meta;
enum fs_return status;
int i, file_index = -1;

// Baca sektor node dari file system
readSector(&(node_fs_buf.nodes[0]), FS_NODE_SECTOR_NUMBER);
readSector(&(node_fs_buf.nodes[32]), FS_NODE_SECTOR_NUMBER);

// Cari file
for (i = 0; i < FS_MAX_NODE; i++) {
if (node_fs_buf.nodes[i].parent_index == cwd && strcmp(node_fs_buf.nodes[i].node_name, filename) == 0) {
file_index = i;
break;
}
}

if (file_index == -1) {
printString("File not found\n");
return;
}

// Baca isi file
file_meta.parent_index = cwd;
strcpy(file_meta.node_name, filename);

fsRead(&file_meta, &status);
if (status != FS_SUCCESS) {
printString("Error reading file\n");
return;
}

// Tampilkan isi file
for (i = 0; i < file_meta.filesize; i++) {
interrupt(0x10, 0xE << 8 | file_meta.buffer[i], 0, 0, 0);
}
printString("\n");
}


void mkdir(byte cwd, char* dirname) {
struct node_fs node_fs_buf;
struct map_fs map_fs_buf;
int i, empty_node_index = -1;

// Baca sektor node dan map dari file system
readSector(&(node_fs_buf.nodes[0]), FS_NODE_SECTOR_NUMBER);
readSector(&(node_fs_buf.nodes[32]), FS_NODE_SECTOR_NUMBER + 1);
readSector(&(map_fs_buf.is_used[0]), FS_MAP_SECTOR_NUMBER);

// Cek apakah direktori sudah ada
for (i = 0; i < FS_MAX_NODE; i++) {
if (node_fs_buf.nodes[i].parent_index == cwd && strcmp(node_fs_buf.nodes[i].node_name, dirname) == 0) {
printString("Directory already exists\n");
return;
}
}

// Cari node yang kosong
for (i = 0; i < FS_MAX_NODE; i++) {
if (!map_fs_buf.is_used[i]) {
empty_node_index = i;
break;
}
}

if (empty_node_index == -1) {
printString("No free nodes available\n");
return;
}

// Buat direktori baru
strcpy(node_fs_buf.nodes[empty_node_index].node_name, dirname);
node_fs_buf.nodes[empty_node_index].parent_index = cwd;
node_fs_buf.nodes[empty_node_index].data_index = FS_NODE_D_DIR;
map_fs_buf.is_used[empty_node_index] = true;

// Tulis kembali sektor node dan map ke file system
writeSector(&(node_fs_buf.nodes[0]), FS_NODE_SECTOR_NUMBER);
writeSector(&(node_fs_buf.nodes[32]), FS_NODE_SECTOR_NUMBER + 1);
writeSector(&(map_fs_buf.is_used[0]), FS_MAP_SECTOR_NUMBER);

printString("Directory created\n");
}

// TODO: 7. Implement ls function
void ls(byte cwd, char* dirname) {}

// TODO: 8. Implement mv function
void mv(byte cwd, char* src, char* dst) {}

// TODO: 9. Implement cp function
void cp(byte cwd, char* src, char* dst) {}

// TODO: 10. Implement cat function
void cat(byte cwd, char* filename) {}

// TODO: 11. Implement mkdir function
void mkdir(byte cwd, char* dirname) {}