static int handler(void *handler_context, void *conn_context, qd_conn_event_t event, qd_connection_t *qd_conn)
{
qd_container_t *container = (qd_container_t*) handler_context;
pn_connection_t *conn = qd_connection_pn(qd_conn);
switch (event) {
case QD_CONN_EVENT_LISTENER_OPEN:
open_handler(container, qd_conn, QD_INCOMING, conn_context);
return 1;
case QD_CONN_EVENT_CONNECTOR_OPEN:
open_handler(container, qd_conn, QD_OUTGOING, conn_context);
return 1;
case QD_CONN_EVENT_CLOSE:
return close_handler(container, conn_context, conn, qd_conn);
case QD_CONN_EVENT_WRITABLE:
return writable_handler(container, conn, qd_conn);
}
return 0;
}
int open64(const char *pathname, int flags, ...) {
static int (*open_handler)(const char*, int, ...);
fprintf(stderr, "[opened file: '%s']\n", pathname);
// load the real open call
open_handler = dlsym(RTLD_NEXT, "open64");
mode_t mode = 0;
va_list arg;
if ( flags & O_CREAT ) {
va_start(arg, flags);
mode = va_arg(arg, mode_t);
va_end(arg);
}
return open_handler(pathname, flags, mode);
}
/*Thread Function
* INPUT:
* void *parameter : Connection Identifier
*/
void
*thread_fun (void *parameter) {
char recvBuff[1024] , len[5] , data[500];
int p_size , res , conn = 0 , st = 0;
/*Connection Identifier */
conn = *(int *)parameter;
/*Loops till the File is closed */
while (st == 0) {
/*Clear the Buffer content */
memset (recvBuff , 0 , sizeof (recvBuff));
/*Receive marshalled data sent by Client*/
p_size = read (conn , recvBuff , sizeof (recvBuff) - 1);
if (p_size != 0) {
recvBuff[p_size] = 0;
memset (data , 0 , sizeof (data));
memcpy (data , &recvBuff , 3);
res = atoi (data);
/*Interprete received data based on type of call */
switch (res) {
case _r_list:
st = list_handler (conn);
break;
case _r_open:
st = open_handler (conn , recvBuff);
break;
case _r_read:
st = read_handler (conn , recvBuff);
break;
case _r_write:
st = write_handler (conn , recvBuff);
break;
case _r_close:
st = close_handler (conn , recvBuff);
break;
}
}
}
out:
return;
}
static void syscall_handler(struct intr_frame *f) {
void *esp = f->esp;
thread_current()->saved_esp = f->esp;
// printf("$esp = %p\n",esp);
byte_access_ok(esp,false);
// hex_dump(esp, esp,16,true);
// printf("\n");
int sys_call_num = *(int*) esp;
esp += sizeof(int *);
byte_access_ok(esp,false);
// printf("$sys_call_num = %p\n",sys_call_num);
char* argv[5];
switch (sys_call_num) {
/* Projects 2 and later. */
//TODO: please retrieve parameters from the stack
// and pass them to the handlers.
case SYS_HALT: /* Halt the operating system. */
halt_handler();
break;
case SYS_EXIT: /* Terminate this process. */
parse_arg(esp, 1, argv);
exit_handler((int) argv[0]);
break;
case SYS_EXEC: /* Start another process. */
parse_arg(esp, 1, argv);
f->eax=exec_handler((void*)argv[0]);
break;
case SYS_WAIT: /* Wait for a child process to die. */
parse_arg(esp, 1, argv);
f->eax=wait_handler((int) argv[0]);
break;
case SYS_CREATE: /* Create a file. */
parse_arg(esp, 2, argv);
f->eax=create_handler((void*)argv[0], (unsigned) argv[1]);
break;
case SYS_REMOVE: /* Delete a file. */
parse_arg(esp, 1, argv);
f->eax=remove_handler((void*)argv[0]);
break;
case SYS_OPEN: /* Open a file. */
parse_arg(esp, 1, argv);
f->eax=open_handler((void*)argv[0]);
break;
case SYS_FILESIZE: /* Obtain a file's size. */
parse_arg(esp, 1, argv);
f->eax=filesize_handler((int) argv[0]);
break;
case SYS_READ: /* Read from a file. */
parse_arg(esp, 3, argv);
f->eax=read_handler((int) argv[0], (void*) argv[1], (unsigned) argv[2]);
break;
case SYS_WRITE: /* Write to a file. */
parse_arg(esp, 3, argv);
f->eax=write_handler((int) argv[0], (void*) argv[1], (unsigned) argv[2]);
break;
case SYS_SEEK: /* Change position in a file. */
parse_arg(esp, 2, argv);
seek_handler((int) argv[0], (unsigned) argv[1]);
break;
case SYS_TELL: /* Report current position in a file. */
parse_arg(esp, 1, argv);
f->eax=tell_handler((int) argv[0]);
break;
case SYS_CLOSE: /* Close a file. */
parse_arg(esp, 1, argv);
close_handler((int) argv[0]);
break;
case SYS_MMAP:
parse_arg(esp, 2, argv);
f->eax=mmap_handler ((int) argv[0], (void*)argv[1]);
break;
case SYS_MUNMAP:
parse_arg(esp, 1, argv);
munmap_handler ((mapid_t) argv[0]);
break;
default:
printf("system call %d not implemented!\n", sys_call_num);
}
//thread_exit();
}
/* Open and init uinput file descriptors */
int uinput_init(void)
{
struct uinput_user_dev dev_mouse, dev_kbd;
int i;
uinput_mouse_fd = open_handler("uinput", O_WRONLY | O_NDELAY);
if (uinput_mouse_fd < 0)
{
perror( OUT_PRE "Error opening the uinput device.\n"
OUT_PRE "Make sure you have loaded the uinput module (modprobe uinput)");
exit(BTNX_ERROR_OPEN_UINPUT);
}
uinput_kbd_fd = open_handler("uinput", O_WRONLY | O_NDELAY);
if (uinput_kbd_fd < 0)
{
perror(OUT_PRE "Error opening the uinput device");
exit(BTNX_ERROR_OPEN_UINPUT);
}
memset(&dev_mouse, 0, sizeof(dev_mouse));
dev_mouse.id.bustype = 0;
dev_mouse.id.vendor = BTNX_VENDOR;
dev_mouse.id.product = BTNX_PRODUCT_MOUSE;
dev_mouse.id.version = 0;
strcpy(dev_mouse.name, UMOUSE_NAME);
write(uinput_mouse_fd, &dev_mouse, sizeof(dev_mouse));
memset(&dev_kbd, 0, sizeof(dev_kbd));
dev_kbd.id.bustype = 0;
dev_kbd.id.vendor = BTNX_VENDOR;
dev_kbd.id.product = BTNX_PRODUCT_KBD;
dev_kbd.id.version = 0;
strcpy(dev_kbd.name, UKBD_NAME);
write(uinput_kbd_fd, &dev_kbd, sizeof(dev_kbd));
ioctl(uinput_mouse_fd, UI_SET_EVBIT, EV_REL);
ioctl(uinput_mouse_fd, UI_SET_RELBIT, REL_X);
ioctl(uinput_mouse_fd, UI_SET_RELBIT, REL_Y);
ioctl(uinput_mouse_fd, UI_SET_RELBIT, REL_WHEEL);
ioctl(uinput_mouse_fd, UI_SET_EVBIT, EV_KEY);
for (i=BTN_MISC; i<KEY_OK; i++)
{
ioctl(uinput_mouse_fd, UI_SET_KEYBIT, i);
}
ioctl(uinput_kbd_fd, UI_SET_EVBIT, EV_KEY);
ioctl(uinput_kbd_fd, UI_SET_EVBIT, EV_REP);
for (i=0; i<BTN_MISC; i++)
{
ioctl(uinput_kbd_fd, UI_SET_KEYBIT, i);
}
for (i=KEY_OK; i<KEY_MAX; i++)
{
ioctl(uinput_kbd_fd, UI_SET_KEYBIT, i);
}
ioctl(uinput_kbd_fd, UI_DEV_CREATE, 0);
ioctl(uinput_mouse_fd, UI_DEV_CREATE, 0);
return 0;
}
int main(int argc, char* argv[])
{
int pid;
Msg myMsg;
int sender_pid;
initialize();
if (Register(FILE_SERVER)) {
perror("Register server process error!");
}
if (argc>1) {
pid = Fork();
if (pid==0) {
Exec(argv[1],argv+1);
}
}
while (1) {
if ((sender_pid=Receive(&myMsg))==ERROR) {
// perror("error receiving message!");
continue;
}
switch (myMsg.type) {
case OPEN:
open_handler(&myMsg,sender_pid);break;
/*
case CLOSE:
close_handler(&myMsg,sender_pid);break;
*/
case CREATE:
create_handler(&myMsg,sender_pid);break;
case READ:
read_handler(&myMsg,sender_pid);break;
case WRITE:
write_handler(&myMsg,sender_pid);break;
/*
case SEEK:
seek_handler(&myMsg,sender_pid);break;
*/
case LINK:
link_handler(&myMsg,sender_pid);break;
case UNLINK:
unlink_handler(&myMsg,sender_pid);break;
case SYMLINK:
symlink_handler(&myMsg,sender_pid);break;
case READLINK:
readlink_handler(&myMsg,sender_pid);break;
case MKDIR:
mkdir_handler(&myMsg,sender_pid);break;
case RMDIR:
rmdir_handler(&myMsg,sender_pid);break;
case CHDIR:
chdir_handler(&myMsg,sender_pid);break;
case STAT:
stat_handler(&myMsg,sender_pid);break;
case SYNC:
sync_handler(&myMsg);break;
case SHUTDOWN:
shutdown_handler(&myMsg,sender_pid);break;
default:
perror("message type error!");
break;
}
if (Reply(&myMsg,sender_pid)==ERROR) fprintf(stderr, "Error replying to pid %d\n",sender_pid);
}
terminate();
return 0;
}
