static void client_cb(uv_stream_t* target, uvm_reader_message_t msg, msgpack_object* obj, void* p, int status){ connection_status_t* st; msgpack_packer* pac = (msgpack_packer*)p; switch(msg){ case MESSAGE: if(obj){ handle_client_message(target,pac,obj); } break; case CONNECT: printf("client connect = %lx\n",(unsigned long)target); /* Fill current connection status */ st = malloc(sizeof(connection_status_t)); st->pac = pac; st->target = target; async_request_queue.data = st; start_test_thread(); break; case DISCONNECT: printf("client disconnect = %lx\n",(unsigned long)target); async_request_queue.data = NULL; break; default: break; } }
int main(int argc, char** argv) { int quit = 0; if (argc != 3) { fprintf(stderr, "usage: RE216_CLIENT hostname port\n"); return 1; } //get address info from the server //get_addr_info() struct addrinfo addr; struct addrinfo * add = &addr; struct addrinfo ** ad = &add; ad = get_addr_info(argv[1], argv[2], ad); add = *ad; addr = *add; //get the socket int s; s = do_socket(); //connect to remote socket do_connect(s, addr.ai_addr, addr.ai_addrlen); char * buffer = malloc(MAXLEN); memset(buffer, 0, MAXLEN); for(;;) { //get user input readline(0, buffer, MAXLEN); //send message to the server handle_client_message(s, buffer); // Test if log off signal was sent if (strcmp(buffer, "/quit\n") == 0) { fprintf(stderr, "Quit signal sent\n"); break; } // Receive an echo and display it memset(buffer, 0, MAXLEN); read(s, buffer, 256); fprintf(stderr, "--> %s", buffer); } //Clean buffer free(buffer); //clean up socket shutdown(s, SHUT_RDWR); close(s); return 0; }
int serve_client(int e, struct epoll_event* ee, struct user_list* ul) { int result = -1; struct message* m = 0; if (ee->events & EPOLLIN) { m = receive_message(ee->data.fd); if (m) result = handle_client_message(ee->data.fd, m, ul); } if (result < 0) { ul->rm_user_by_fd(ul->ctx, ee->data.fd); result = epoll_ctl(e, EPOLL_CTL_DEL, ee->data.fd, ee); close(ee->data.fd); result = 0; } return result; }
int get(SSL *ssl, char *fname, char *uid) { msg_t req, resp; memset(&req, 0, sizeof(msg_t)); memset(&resp, 0, sizeof(msg_t)); req.hdr.type = REQ_GET; req.u.get_req.del_req = 0; req.u.get_req.filename_len = strlen(fname); req.u.get_req.num_tokens = 0; req.u.get_req.filename = fname; if(STATUS_FAILURE == send_message(ssl, &req)) { perror("send req failed\n"); return STATUS_FAILURE; } return handle_client_message(ssl, &req, &resp); }
int put(SSL *ssl, char *fname, char *uid) { struct stat buffer; int fd; msg_t req, res; memset(&req, 0, sizeof(msg_t)); memset(&res, 0, sizeof(msg_t)); req.hdr.type = REQ_PUT; req.u.put_req.del_req = 0; req.u.put_req.filename = fname; req.u.put_req.filename_len = strlen(fname); req.u.put_req.num_tokens = 0; fd= open(fname, O_RDWR); if(-1 == fstat(fd, &buffer)) { perror("fstat"); return STATUS_FAILURE; } req.u.put_req.file_len = buffer.st_size; req.u.put_req.data = malloc(buffer.st_size); assert(NULL != req.u.put_req.data); if(read(fd, req.u.put_req.data, buffer.st_size) != buffer.st_size) { perror("get: Error reading from file\n"); return STATUS_FAILURE; } if(STATUS_FAILURE == send_message(ssl, &req)) { perror("send req failed\n"); return STATUS_FAILURE; } return handle_client_message(ssl, &req, &res); }
int delegate(SSL *ssl, char *fname, char *uid, char *rights, char *host, char *time, char *prop ) { msg_t req, res; int propagate; memset(&req, 0, sizeof(msg_t)); memset(&res, 0, sizeof(msg_t)); req.hdr.type = REQ_DELG; req.u.delg_req.del_req = 0; req.u.delg_req.filename = fname; req.u.delg_req.filename_len = strlen(fname); req.u.delg_req.num_tokens = 0; if(0 == strcmp(prop, "propagate")) propagate = 1; else propagate = 0; if(0 == strcmp(rights, "get")) req.u.delg_req.rights = (propagate == 0) ? DELG_GET : DELG_GET | DELG_DELG; else if(0 == strcmp(rights, "put")) req.u.delg_req.rights = (propagate == 0) ? DELG_PUT : DELG_PUT | DELG_DELG; if(0 == strcmp(rights, "both")) req.u.delg_req.rights = (propagate == 0) ? DELG_GET | DELG_PUT : DELG_GET | DELG_PUT | DELG_DELG;; req.u.delg_req.host_len = strlen(host); req.u.delg_req.host = host; req.u.delg_req.time = atoi(time); if(STATUS_FAILURE == send_message(ssl, &req)) { perror("send req failed\n"); return STATUS_FAILURE; } return handle_client_message(ssl, &req, &res); }
int main(int argc, char *argv[]) { puts("Starting server."); fd_set file_descriptors; connection_info server_info; int i; if (argc != 4) { fprintf(stderr, "Usage:./%s <server_ip> <server_port> <max_client> \n", argv[0]); exit(1); } MAX_CLIENTS=atoi(argv[3]); //check the max clients //printf("%d",MAX_CLIENTS); connection_info *clients=(connection_info*)malloc(MAX_CLIENTS*sizeof(connection_info)); for(i = 0; i < MAX_CLIENTS; i++) { clients[i].socket = 0; } initialize_server(&server_info, atoi(argv[2])); while(true) { int max_fd = construct_fd_set(&file_descriptors, &server_info, clients); if(select(max_fd+1, &file_descriptors, NULL, NULL, NULL) < 0) { perror("Select Failed"); stop_server(clients); } if(FD_ISSET(STDIN_FILENO, &file_descriptors)) { handle_user_input(clients); } if(FD_ISSET(server_info.socket, &file_descriptors)) { handle_new_connection(&server_info, clients); } for(i = 0; i < MAX_CLIENTS; i++) { if(clients[i].socket > 0 && FD_ISSET(clients[i].socket, &file_descriptors)) { handle_client_message(clients, i); } } } return 0; }
void handle_event(XEvent *ev) { switch(ev->type){ CASE_EVENT(MapRequest) handle_map_request(&(ev->xmaprequest)); break; CASE_EVENT(ConfigureRequest) handle_configure_request(&(ev->xconfigurerequest)); break; CASE_EVENT(UnmapNotify) handle_unmap_notify(&(ev->xunmap)); break; CASE_EVENT(DestroyNotify) handle_destroy_notify(&(ev->xdestroywindow)); break; CASE_EVENT(ClientMessage) handle_client_message(&(ev->xclient)); break; CASE_EVENT(PropertyNotify) handle_property(&(ev->xproperty)); break; CASE_EVENT(FocusIn) handle_focus_in(&(ev->xfocus)); break; CASE_EVENT(FocusOut) handle_focus_out(&(ev->xfocus)); break; CASE_EVENT(EnterNotify) handle_enter_window(ev); break; CASE_EVENT(Expose) handle_expose(&(ev->xexpose)); break; CASE_EVENT(KeyPress) assert(wglobal.input_handler!=NULL); assert(wglobal.input_handler->keyboard!=NULL); wglobal.input_handler->keyboard(ev); break; CASE_EVENT(KeyRelease) assert(wglobal.input_handler!=NULL); assert(wglobal.input_handler->keyboard!=NULL); wglobal.input_handler->keyboard(ev); break; CASE_EVENT(ButtonPress) assert(wglobal.input_handler!=NULL); if(wglobal.input_handler->pointer!=NULL) wglobal.input_handler->pointer(ev); break; CASE_EVENT(ColormapNotify) handle_colormap_notify(&(ev->xcolormap)); break; CASE_EVENT(MappingNotify) XRefreshKeyboardMapping(&(ev->xmapping)); update_modmap(); break; CASE_EVENT(SelectionClear) clear_selection(); break; CASE_EVENT(SelectionNotify) receive_selection(&(ev->xselection)); break; CASE_EVENT(SelectionRequest) send_selection(&(ev->xselectionrequest)); break; } }
// Handle X event on queue. Return true if event was handled. bool jbxvt_handle_xevents(xcb_connection_t * xc) { jb_check_x(xc); static bool init; if (!init) { // Set up the wm_del_win property here. wm_del_win(xc); } xcb_generic_event_t * event = xcb_poll_for_event(xc); if (!event) // nothing to process return false; bool ret = true; switch (event->response_type & ~0x80) { // Put things to ignore here: case 0: // Unimplemented, undefined, no event case 150: // Undefined case XCB_KEY_RELEASE: // Unimplemented case XCB_MAP_NOTIFY: case XCB_NO_EXPOSURE: // Unimplemented case XCB_REPARENT_NOTIFY: // handle here to ensure cursor filled. ret = false; break; case XCB_CONFIGURE_NOTIFY: jbxvt_resize_window(xc); break; case XCB_KEY_PRESS: key_press(xc, event); break; case XCB_CLIENT_MESSAGE: handle_client_message(xc, (xcb_client_message_event_t *)event); break; case XCB_EXPOSE: case XCB_GRAPHICS_EXPOSURE: handle_expose(xc, (xcb_expose_event_t *)event); break; case XCB_ENTER_NOTIFY: case XCB_FOCUS_IN: handle_focus(true); break; case XCB_LEAVE_NOTIFY: case XCB_FOCUS_OUT: handle_focus(false); break; case XCB_SELECTION_CLEAR: jbxvt_clear_selection(); break; case XCB_SELECTION_NOTIFY: handle_selection_notify(xc, (xcb_selection_notify_event_t *)event); break; case XCB_SELECTION_REQUEST: handle_selection_request(xc, (xcb_selection_request_event_t *)event); break; case XCB_BUTTON_PRESS: jbxvt_handle_button_press_event(xc, (xcb_button_press_event_t *)event); break; case XCB_BUTTON_RELEASE: jbxvt_handle_button_release_event(xc, (xcb_button_release_event_t *)event); break; case XCB_MOTION_NOTIFY: handle_motion_notify(xc, (xcb_motion_notify_event_t *)event); break; default: LOG("Unhandled event %d", event->response_type); } free(event); return ret; }