int ln_cmd(int argc, char **argv) {
if (argc != 2) {
printf("ln: missing file operand\n");
return 0;
}
u32int currentiNode = tty_getCurrentTTY()->currDirectory;
fs_node_t currentFsNode;
fs_getFsNode(¤tFsNode, currentiNode);
fs_node_t *target = finddir_fs(¤tFsNode, argv[0]);
if (target == NULL) {
printf("ln: accessing \"%s\": No such file or directory\n", argv[0]);
return -1;
}
// create sym link
u32int symLinkiNode = createdir_fs(¤tFsNode, argv[1], FS_SYMLINK);
if (symLinkiNode == E_FILE_EXISTS) {
printf("ln: accessing \"%s\": File exists\n", argv[1]);
return -1;
}
fs_node_t symLink;
fs_getFsNode(&symLink, symLinkiNode);
// add contents to sym link
//write_fs(&symLink, 0, sizeof(u32int), (u8int*) &target->inode);
write_fs(&symLink, 0, MAX_NAME_LENGTH, (u8int*) target->name);
kfree(target);
return 0;
}
static int sys_write(int fd, char * ptr, int len) {
if (FD_CHECK(fd)) {
PTR_VALIDATE(ptr);
fs_node_t * node = FD_ENTRY(fd);
uint32_t out = write_fs(node, node->offset, len, (uint8_t *)ptr);
node->offset += out;
return out;
}
return -1;
}
static int sys_write(int fd, char * ptr, int len) {
if (FD_CHECK(fd)) {
PTR_VALIDATE(ptr);
fs_node_t * node = FD_ENTRY(fd);
if (!has_permission(node, 02)) {
debug_print(WARNING, "access denied (write, fd=%d)", fd);
return -EACCES;
}
uint32_t out = write_fs(node, node->offset, len, (uint8_t *)ptr);
node->offset += out;
return out;
}
return -1;
}
static int sys_write(int fd, char * ptr, int len) {
if (FD_CHECK(fd)) {
PTR_VALIDATE(ptr);
fs_node_t * node = FD_ENTRY(fd);
if (!(FD_MODE(fd) & 02)) {
debug_print(WARNING, "access denied (write, fd=%d)", fd);
return -EACCES;
}
uint32_t out = write_fs(node, FD_OFFSET(fd), len, (uint8_t *)ptr);
FD_OFFSET(fd) += out;
return out;
}
return -EBADF;
}
void mouse_handler(struct regs *r) {
uint8_t status = inportb(MOUSE_STATUS);
while (status & MOUSE_BBIT) {
int8_t mouse_in = inportb(MOUSE_PORT);
if (status & MOUSE_F_BIT) {
switch (mouse_cycle) {
case 0:
mouse_byte[0] = mouse_in;
if (!(mouse_in & MOUSE_V_BIT)) return;
++mouse_cycle;
break;
case 1:
mouse_byte[1] = mouse_in;
++mouse_cycle;
break;
case 2:
mouse_byte[2] = mouse_in;
/* We now have a full mouse packet ready to use */
if (mouse_byte[0] & 0x80 || mouse_byte[0] & 0x40) {
/* x/y overflow? bad packet! */
break;
}
mouse_device_packet_t packet;
packet.magic = MOUSE_MAGIC;
packet.x_difference = mouse_byte[1];
packet.y_difference = mouse_byte[2];
packet.buttons = 0;
if (mouse_byte[0] & 0x01) {
packet.buttons |= LEFT_CLICK;
}
if (mouse_byte[0] & 0x02) {
packet.buttons |= RIGHT_CLICK;
}
if (mouse_byte[0] & 0x04) {
packet.buttons |= MIDDLE_CLICK;
}
mouse_cycle = 0;
mouse_device_packet_t bitbucket;
while (pipe_size(mouse_pipe) > (DISCARD_POINT * sizeof(packet))) {
read_fs(mouse_pipe, 0, sizeof(packet), (uint8_t *)&bitbucket);
}
write_fs(mouse_pipe, 0, sizeof(packet), (uint8_t *)&packet);
break;
}
}
status = inportb(MOUSE_STATUS);
}
irq_ack(MOUSE_IRQ);
}
static int serial_handler_ac(struct regs *r) {
char serial;
int port = 0;
if (inportb(SERIAL_PORT_A+1) & 0x01) {
port = SERIAL_PORT_A;
} else {
port = SERIAL_PORT_C;
}
serial = serial_recv(port);
irq_ack(SERIAL_IRQ_AC);
uint8_t buf[] = {convert(serial), 0};
write_fs(*pipe_for_port(port), 0, 1, buf);
return 1;
}
static int serial_handler_bd(struct regs *r) {
char serial;
int port = 0;
debug_print(NOTICE, "Received something on secondary port");
if (inportb(SERIAL_PORT_B+1) & 0x01) {
port = SERIAL_PORT_B;
} else {
port = SERIAL_PORT_D;
}
serial = serial_recv(port);
irq_ack(SERIAL_IRQ_BD);
uint8_t buf[] = {convert(serial), 0};
write_fs(*pipe_for_port(port), 0, 1, buf);
return 1;
}
void keyboard_callback(registers_t *regs) {
while(inb(PS2_COMMAND_PORT) & 2) {}
uint8_t scan_code = inb(PS2_DATA_PORT);
// TODO: send back RESEND if something was wrong.
irq_ack(IRQ1);
printk("scan_code found: %x\n", scan_code);
// open '/dev/keyboard', write scan_code to it.
// TODO: make this understand paths better.
fs_node_t * keyboard = devfs_keyboard;
if (keyboard) {
printk("calling write_fs with %x %c\n", scan_code, scan_code);
write_fs(keyboard, 0, 4, scan_code);
} else {
printk("ERROR: can't write to NULL /dev/keyboard char device.\n");
}
}
int do_sys_write_flags(struct file *f, off_t off, char *buf, size_t count)
{
if(!f || !buf)
return -EINVAL;
struct inode *inode = f->inode;
if(S_ISFIFO(inode->mode))
return write_pipe(inode, buf, count);
else if(S_ISCHR(inode->mode))
return char_rw(WRITE, inode->dev, buf, count);
else if(S_ISBLK(inode->mode))
return (block_device_rw(WRITE, inode->dev, off, buf, count));
/* Again, we want to write to the link because we have that node */
else if(S_ISDIR(inode->mode) || S_ISREG(inode->mode) || S_ISLNK(inode->mode))
return write_fs(inode, off, count, buf);
printk(1, "sys_write (%s): invalid mode %x\n", inode->name, inode->mode);
return -EINVAL;
}
int DMTest2(int argc, char **argv) {
char* fileName = "test";
// rm_cmd(1, &fileName);
fs_node_t root;
fs_getRoot(&root);
int inodeNumber = createdir_fs(&root, fileName, FS_FILE);
if (inodeNumber == -1) {
printf("file already exists\n");
}
fs_node_t* file = finddir_fs(&root, fileName);
u8int* contents = (u8int*) "Hola Manolo!";
u32int len = strlen((char*) contents) + 1;
printf("writing contents...");
// write_fs(file, 0, len, contents);
int offset = 0;
while(offset++ < len) {
write_fs(file, offset, 1, contents + offset);
}
kfree(file);
return 0;
}
int touch_cmd(int argc, char **argv) {
if(argc == 0 ) {
printf("touch: missing operand\n");
} else {
errno = 0;
fs_node_t current;
fs_getFsNode(¤t, tty_getCurrentTTY()->currDirectory);
createdir_fs(¤t, argv[0], FS_FILE);
char* err = NULL;
switch(errno) {
case OK:
break;
case E_ACCESS:
err = "No write permission";
break;
case E_FILE_EXISTS:
err = "File exists";
break;
default:
printf("errno: %d", errno);
err = "Unknown error";
break;
}
if (errno != 0) {
printf("touch: cannot create file %s: %s\n", argv[0], err);
return -1;
}
if (argc == 2) {
TTY* tty = tty_getCurrentTTY();
u32int currentiNode = tty->currDirectory;
fs_node_t current;
fs_getFsNode(¤t, currentiNode);
fs_node_t* file = finddir_fs(¤t, argv[0]);
write_fs(file, 0, strlen(argv[1]) + 1, (u8int*) argv[1]);
kfree(file);
}
}
return 0;
}
static int drv_stderr_write(vnode *node, off_t offset, size_t size, const char *buffer)
{
FILE *f = current_task->files[STDERR_FILENO];
if (!f || !f->node || f->node == node) return 0;
return write_fs(f->node, offset, size, buffer);
}
int filewrite()
{
char c;
FILE * fp;
unsigned int needed_block,file_size,buffcount=0;
unsigned int tmp_offset,pos;
int file_inode_index;
inode *file_inode;
data_block *buff;
buff = (data_block *) malloc(sizeof(data_block));
fp = fopen ("bigfile.txt", "rb");
fseek(fp, 0, SEEK_END);
file_size = ftell(fp);
needed_block = ceil(file_size*1.0/(BS));
if(sb_object->no_free_inodes < needed_block){
printf("E: not enough memory");
return 0;
}
fseek(fp, 0, SEEK_SET);
// allocate inode
file_inode_index = sb_object->next_free_inode_index;
set_next_free_inode_index();
// fill data inode
file_inode = (inode *) &inode_table_object->inode_index[file_inode_index];
file_inode->file_type = 0;
file_inode->size = 0;
#ifdef DEBUG_BUILD
printf("in write.c: ***file_size %d***\n",file_size);
#endif
while((pos=ftell(fp))<=file_size){
fread(&c,sizeof(char),1,fp);
if(buffcount == BS || pos==file_size){
tmp_offset = get_next_offset_to_write(file_inode);
#ifdef DEBUG_BUILD
printf("*** db_block_write_offset(%d): %d size: %d ***\n", buffcount, tmp_offset,file_inode->size);
//printf("in write.c filewrite(): *** db_block_write_offset(%d): %d size: %d ***\n", buffcount, tmp_offset,file_inode->size);
#endif
my_write(buff,buffcount,tmp_offset);
set_next_free_block();
file_inode->size += buffcount;
buffcount=0;
write_fs();
}
if(pos!=file_size){
buff->data[buffcount]=c;
//printf("%d\n",buffcount);
buffcount++;
}else{
break;
}
}
free(buff);
return file_inode_index;
}
