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; }