shell.c

#pragma warning(disable : 4995)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include "shell.h"
#include "disksim.h"

#define		SECTOR					DWORD
#define		BLOCK_SIZE				1024
#define		SECTOR_SIZE				1024
#define		NUMBER_OF_SECTORS		( 4096 + 1 )

#define COND_MOUNT				0x01
#define COND_UMOUNT				0x02

typedef struct
{
	char*	name;
	int(*handler)(int, char**);
	char	conditions;
} COMMAND;

extern void shell_register_filesystem(SHELL_FILESYSTEM*);
extern void printf_by_sel(DISK_OPERATIONS* disk, SHELL_FS_OPERATIONS* fsOprs, const SHELL_ENTRY* parent, SHELL_ENTRY* entry, const char* name, int sel, int num);

void do_shell(void);
void unknown_command(void);
int seperate_string(char* buf, char* ptrs[]);

int shell_cmd_format(int argc, char* argv[]);
int shell_cmd_mount(int argc, char* argv[]);
int shell_cmd_touch(int argc, char* argv[]);
int shell_cmd_cd(int argc, char* argv[]);
int shell_cmd_ls(int argc, char* argv[]);
int shell_cmd_mkdir(int argc, char* argv[]);
int shell_cmd_dumpsuperblock(int argc, char * argv[]);
int shell_cmd_dumpgd(int argc, char * argv[]);
int shell_cmd_dumpblockbitmap(int argc, char * argv[]);
int shell_cmd_dumpinodebitmap(int argc, char * argv[]);
int shell_cmd_dumpinodetable(int argc, char * argv[]);
int shell_cmd_dumpdatablockbyname(int argc, char * agrv[]);
int shell_cmd_dumpfileinode(int argc, char * argv[]);
int shell_cmd_fill(int argc, char* argv[]);
int shell_cmd_dumpdatablockbynum(int argc, char * argv[]);
int shell_cmd_cat(int argc, char * argv[]);
int shell_cmd_rmdir(int argc, char* argv[]);
int shell_cmd_rm(int argc, char* argv[]);
int shell_cmd_df(int argc, char* argv[]);

static COMMAND g_commands[] =
{
	{ "cd",		shell_cmd_cd,		COND_MOUNT	},
	{ "cat",    shell_cmd_cat,		COND_MOUNT	},
	{ "mount",	shell_cmd_mount,	COND_UMOUNT	},
	{ "touch",	shell_cmd_touch,	COND_MOUNT	},
	{ "fill",	shell_cmd_fill,		COND_MOUNT	},
	{ "ls",		shell_cmd_ls,		COND_MOUNT	},
	{ "format",	shell_cmd_format,	COND_UMOUNT	},
	{ "mkdir",	shell_cmd_mkdir,	COND_MOUNT	},
	{ "dumpdatablockbynum",	shell_cmd_dumpdatablockbynum, COND_MOUNT },
	{ "dumpsuperblock" , shell_cmd_dumpsuperblock, COND_MOUNT  },
	{ "dumpgd" , shell_cmd_dumpgd , COND_MOUNT },
	{ "dumpblockbitmap" , shell_cmd_dumpblockbitmap, COND_MOUNT  },
	{ "dumpinodebitmap" , shell_cmd_dumpinodebitmap, COND_MOUNT  },
	{ "dumpinodetable" , shell_cmd_dumpinodetable, COND_MOUNT  },
	{ "dumpdatablockbyname", shell_cmd_dumpdatablockbyname, COND_MOUNT  },
	{ "dumpfileinode", shell_cmd_dumpfileinode, COND_MOUNT  },
	{ "rmdir", shell_cmd_rmdir, COND_MOUNT },
	{ "rm", shell_cmd_rm, COND_MOUNT},
	{ "df", shell_cmd_df, COND_MOUNT}
};

static SHELL_FILESYSTEM		g_fs;
static SHELL_FS_OPERATIONS	g_fsOprs;
static SHELL_ENTRY			g_rootDir;
static SHELL_ENTRY			g_currentDir;
static DISK_OPERATIONS		g_disk;


int g_commandsCount = sizeof(g_commands) / sizeof(COMMAND);
int g_isMounted;

int main(int argc, char* argv[])
{
	if (disksim_init(NUMBER_OF_SECTORS, SECTOR_SIZE, &g_disk) < 0)
	{
		printf("disk simulator initialization has been failed\n");
		return -1;
	}

	shell_register_filesystem(&g_fs);

	do_shell();

	return 0;
}

int check_conditions(int conditions)
{
	if (conditions & COND_MOUNT && !g_isMounted)
	{
		printf("file system is not mounted\n");
		return -1;
	}

	if (conditions & COND_UMOUNT && g_isMounted)
	{
		printf("file system is already mounted\n");
		return -1;
	}

	return 0;
}

static int x = 0;

void do_shell(void)
{
	char buf[1000];
	char command[100];
	char* argv[100];
	int argc;
	int i, j = 0;

	printf("%s File system shell\n", g_fs.name);

	while (-1)
	{
		printf("[%s]# ", g_currentDir.name);

		fgets(buf, 1000, stdin);
		argc = seperate_string(buf, argv);

		if (argc == 0)
			continue;

		for (i = 0; i < g_commandsCount; i++)
		{
			if (strcmp(g_commands[i].name, argv[0]) == 0)
			{
				if (check_conditions(g_commands[i].conditions) == 0)
					g_commands[i].handler(argc, argv);

				break;
			}
		}

		if (argc != 0 && i == g_commandsCount)
			unknown_command();
	}
}

void unknown_command(void)
{
	int i;

	printf(" * ");
	for (i = 0; i < g_commandsCount; i++)
	{
		if (i < g_commandsCount - 1)
			printf("%s, ", g_commands[i].name);
		else
			printf("%s", g_commands[i].name);
	}
	printf("\n");
}

int seperate_string(char* buf, char* ptrs[])
{
	char prev = 0;
	int count = 0;

	while (*buf)
	{
		if (isspace(*buf))
			*buf = 0;
		else if (prev == 0)
			ptrs[count++] = buf;

		prev = *buf++;
	}

	return count;
}

int shell_cmd_dumpsuperblock(int argc, char * argv[])
{
	SHELL_ENTRY entry;
	printf_by_sel(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1], 1, 0);
	return 0;
}
int shell_cmd_dumpgd(int argc, char * argv[])
{
	SHELL_ENTRY entry;
	printf_by_sel(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1], 2, 0);
	return 0;
}
int shell_cmd_dumpblockbitmap(int argc, char * argv[])
{
	SHELL_ENTRY entry;
	printf_by_sel(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1], 3, 0);
	return 0;

}
int shell_cmd_dumpinodebitmap(int argc, char * argv[])
{
	SHELL_ENTRY entry;
	printf_by_sel(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1], 4, 0);
	return 0;
}
int shell_cmd_dumpinodetable(int argc, char * argv[])
{
	SHELL_ENTRY entry;
	printf_by_sel(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1], 5, 0);
	return 0;
}
int shell_cmd_dumpdatablockbyname(int argc, char * argv[])
{
	SHELL_ENTRY entry;
	printf_by_sel(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1], 6, 0);
	return 0;
}
int shell_cmd_dumpfileinode(int argc, char * argv[])
{
	SHELL_ENTRY entry;
	printf_by_sel(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1], 7, 0);
	return 0;
}
int shell_cmd_dumpdatablockbynum(int argc, char * argv[])
{
	SHELL_ENTRY entry;
	printf_by_sel(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1], 8, atoi(argv[1]));
	return 0;
}
int shell_cmd_cd(int argc, char* argv[])
{
	SHELL_ENTRY	newEntry;
	int			result, i;
	static SHELL_ENTRY	path[256];
	static int			pathTop = 0;

	path[0] = g_rootDir;

	if (argc > 2)
	{
		printf("usage : %s [directory]\n", argv[0]);
		return 0;
	}

	if (argc == 1)
		pathTop = 0;
	else
	{
		if (strcmp(argv[1], ".") == 0)
			return 0;
		else if (strcmp(argv[1], "..") == 0 && pathTop > 0)
			pathTop--;
		else
		{
			result = g_fsOprs.lookup(&g_disk, &g_fsOprs, &g_currentDir, &newEntry, argv[1]);

			if (result)
			{
				printf("directory not found\n");
				return -1;
			}
			else if (!newEntry.isDirectory)
			{
				printf("%s is not a directory\n", argv[1]);
				return -1;
			}
			path[++pathTop] = newEntry;

		}
	}

	g_currentDir = path[pathTop];

	return 0;
}

int shell_cmd_exit(int argc, char* argv[])
{
	disksim_uninit(&g_disk);
	_exit(0);

	return 0;
}

int shell_cmd_mount(int argc, char* argv[])
{
	int result;
	x++;
	if (g_fs.mount == NULL)
	{
		printf("The mount functions is NULL\n");
		return 0;
	}

	result = g_fs.mount(&g_disk, &g_fsOprs, &g_rootDir);
	g_currentDir = g_rootDir;
     
	if (result < 0)
	{
		printf("%s file system mounting has been failed\n", g_fs.name);
		return -1;
	}
	else
	{  printf(" %s\n",g_currentDir.name);
		printf("%s file system has been mounted successfully\n\n", g_fs.name);
		g_isMounted = 1;
	}

	return 0;
}

int shell_cmd_umount(int argc, char* argv[])
{
	g_isMounted = 0;

	if (g_fs.umount == NULL)
		return 0;

	g_fs.umount(&g_disk, &g_fsOprs);
	return 0;
}

int shell_cmd_touch(int argc, char* argv[])
{
	SHELL_ENTRY	entry;
	int			result;

	if (argc < 2)
	{
		printf("usage : touch [files...]\n");
		return 0;
	}

	result = g_fsOprs.fileOprs->create(&g_disk, &g_fsOprs, &g_currentDir, argv[1], &entry);

	if (result)
	{
		printf("create failed\n");
		return -1;
	}

	return 0;
}

int shell_cmd_fill(int argc, char* argv[])
{
	SHELL_ENTRY	entry;
	char*		buffer;
	char*		tmp;
	int			size;
	int			result;
	char opt[3] = { 0, };
	const char CREATE[3] = "-c";
	const char APPEND[3] = "-a";
	unsigned long offset;

	if (argc != 4)
	{
		printf("usage : fill [file] [size] [option]\n");
		return 0;
	}

	sscanf(argv[2], "%d", &size);
	sscanf(argv[3], "%s", opt);

	if (strcmp(opt, CREATE) == 0)
	{
		result = g_fsOprs.fileOprs->create(&g_disk, &g_fsOprs, &g_currentDir, argv[1], &entry);
		if (result)
		{
			printf("create failed\n");
			return -1;
		}
		offset = 0;
	}
	if (strcmp(opt, APPEND) == 0) {
		g_fsOprs.lookup(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1]);
		offset = entry.size;
	}

	buffer = (char*)malloc(size + 13);
	tmp = buffer;
	while (tmp < buffer + size)
	{
		memcpy(tmp, "Can you see? ", 13);
		tmp += 13;
	}
	
	g_fsOprs.fileOprs->write(&g_disk, &g_fsOprs, &g_currentDir, &entry, offset, size, buffer);
	free(buffer);

	return 0;
}

int shell_cmd_rm(int argc, char* argv[])
{
	int i;

	if (argc < 2)
	{
		printf("usage : rm [files...]\n");
		return 0;
	}

	for (i = 1; i < argc; i++)
	{
		if (g_fsOprs.fileOprs->remove(&g_disk, &g_fsOprs, &g_currentDir, argv[i]))
			printf("cannot remove file\n");
	}

	return 0;
}

typedef struct
{
	char*	address;
} DISK_MEMORY;

int shell_cmd_format(int argc, char* argv[])
{
	int		result;
	unsigned int k = 0;
	char*	param = NULL;
	x++;

	if (argc >= 2)
		param = argv[1];

	result = g_fs.format(&g_disk, param);

	if (result < 0)
	{
		printf("%s formatting is failed\n", g_fs.name);
		return -1;
	}

	printf("disk has been formatted successfully\n\n");
	return 0;
}

double get_percentage(unsigned int number, unsigned int total)
{
	return ((double)number) / total * 100.;
}

int shell_cmd_df(int argc, char* argv[])
{
	unsigned int used, total;
	int result;

	g_fsOprs.stat(&g_disk, &g_fsOprs, &total, &used);

	printf("free sectors : %u(%.2lf%%)\tused sectors : %u(%.2lf%%)\ttotal : %u\n",
		total - used, get_percentage(total - used, g_disk.numberOfSectors),
		used, get_percentage(used, g_disk.numberOfSectors),
		total);

	return 0;
}

int shell_cmd_mkdir(int argc, char* argv[])
{
	SHELL_ENTRY	entry;
	int result;

	if (argc != 2)
	{
		printf("usage : %s [name]\n", argv[0]);
		return 0;
	}

	result = g_fsOprs.mkdir(&g_disk, &g_fsOprs, &g_currentDir, argv[1], &entry);
       
	if (result)
	{
		printf("cannot create directory\n");
		return -1;
	}

	return 0;
}

int shell_cmd_rmdir(int argc, char* argv[])
{
	int result;

	if (argc != 2)
	{
		printf("usage : %s [name]\n", argv[0]);
		return 0;
	}

	result = g_fsOprs.rmdir(&g_disk, &g_fsOprs, &g_currentDir, argv[1]);

	if (result)
	{
		printf("cannot remove directory\n");
		return -1;
	}

	return 0;
}

int shell_cmd_mkdirst(int argc, char* argv[])
{
	SHELL_ENTRY	entry;
	int		result, i, count;
	char	buf[10];

	if (argc != 2)
	{
		printf("usage : %s [count]\n", argv[0]);
		return 0;
	}

	sscanf(argv[1], "%d", &count);
	for (i = 0; i < count; i++)
	{
		printf(buf, "%d", i);
		result = g_fsOprs.mkdir(&g_disk, &g_fsOprs, &g_currentDir, buf, &entry);

		if (result)
		{
			printf("cannot create directory\n");
			return -1;
		}
	}

	return 0;
}

int shell_cmd_cat(int argc, char* argv[])
{
	SHELL_ENTRY	entry;
	char		buf[1025] = { 0, };
	int			result;
	unsigned long	offset = 0;

	if (argc != 2)
	{
		printf("usage : %s [file name]\n", argv[0]);
		return 0;
	}

	result = g_fsOprs.lookup(&g_disk, &g_fsOprs, &g_currentDir, &entry, argv[1]);
	if (result)
	{
		printf("%s lookup failed\n", argv[1]);
		return -1;
	}
	printf("1\n");
	while (g_fsOprs.fileOprs->read(&g_disk, &g_fsOprs, &g_currentDir, &entry, offset, 1024, buf) > 0)
	{
		printf("%s", buf);
		offset += 1024;
		memset(buf, 0, sizeof(buf));
	}
	printf("\n");
}

int shell_cmd_ls(int argc, char* argv[])
{
	SHELL_ENTRY_LIST		list = {0, };
	SHELL_ENTRY_LIST_ITEM*	current;

	if (argc > 2)
	{
		printf("usage : %s [path]\n", argv[0]);
		return 0;
	}

	init_entry_list(&list);
	
	if (g_fsOprs.read_dir(&g_disk, &g_fsOprs, &g_currentDir, &list))
	{
		printf("Failed to read_dir\n");
		return -1;
	}

	current = list.first;

	printf("[File names] [D] [File sizes]\n");
	while (current)
	{
		printf("%-12.11s  %1d  %12d\n",
			current->entry.name, current->entry.isDirectory, current->entry.size);
		current = current->next;
	}
	printf("\n");

	release_entry_list(&list);
	return 0;
}