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