int KSGDevice::create_handler(KSGDeviceNode*node,ACE_HANDLE* handler) { ACE_HANDLE oldhandler; int ret; ret = make_handler(node,handler); if(ret == 0) { ret = find_handler(node,&oldhandler); if(ret == 0) { close_handler(node,oldhandler); } save_handler(node,*handler); return 0; } else if(ret > 0) { if(node->GetParent() && node->GetParent()->GetDevice()) ret = node->GetParent()->GetDevice()->create_handler(node->GetParent(),handler); return ret; } else { return -1; } }
void network_handler(ev, data){ char buf[UIP_BUFSIZE]; // packet data buffer unsigned short cmd; // DataPayload *dp; ChannelState *state = NULL; uint16_t len = uip_datalen(); PRINTF("ipaddr=%d.%d.%d.%d\n", uip_ipaddr_to_quad(&(UDP_HDR->srcipaddr))); PRINTF("Packet is %d bytes long\n",len); memcpy(buf, uip_appdata, len); buf[len] = '\0'; dp = (DataPayload *)buf; PRINTF("Data is %d bytes long\n",uip_ntohs(dp->dhdr.tlen)); cmd = dp->hdr.cmd; // only a byte so no reordering :) PRINTF("Received a %s command.\n", cmdnames[cmd]); PRINTF("Message for channel %d\n",dp->hdr.dst_chan_num); if (dp->hdr.dst_chan_num == HOMECHANNEL || cmd == DISCONNECT){ if (cmd == QACK){ state = &home_channel_state; copy_link_address(state); } else if (cmd == DISCONNECT){ state = get_channel_state(dp->hdr.dst_chan_num); if (state){ remove_channel(state->chan_num); } state = &home_channel_state; copy_link_address(state); } } else{ state = get_channel_state(dp->hdr.dst_chan_num); if (state == NULL){ PRINTF("Channel %d doesn't exist\n", dp->hdr.dst_chan_num); return; } if (check_seqno(state, dp) == 0) { printf("OH NOES\n"); return; }else { //CHECK IF RIGHT CONNECTION //copy_link_address(state); } } // Received a message so reset pingOUT state->pingOUT = 0; if (cmd == QUERY) PRINTF("I'm a controller, Ignoring QUERY\n"); else if (cmd == CONNECT) PRINTF("I'm a controller, Ignoring CONNECT\n"); else if (cmd == QACK) qack_handler(state, dp); else if (cmd == CACK) cack_handler(state, dp); else if (cmd == RESPONSE) response_handler(state, dp); else if (cmd == CMDACK) command_ack_handler(state,dp); else if (cmd == PING) ping_handler(state, dp); else if (cmd == PACK) pack_handler(state, dp); else if (cmd == DISCONNECT) close_handler(state,dp); }
int KSGDevice::release_handler(KSGDeviceNode* node,ACE_HANDLE* handler,bool bfree /*= false*/) { int ret; int found = 0; //ACE_DEBUG((LM_DEBUG,"申请释放连接资源")); { ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,mon,_handle_mutex,-1); ret = -1; //ACE_DEBUG((LM_DEBUG,"释放连接资源")); DeviceHandleMap::iterator i = _used_handlers.find(node); if( i != _used_handlers.end()) { found = 1; if(i->second == *handler) { // 将连接资源从[已使用连接表]中删除 _used_handlers.erase(i); found = 2; } } else if( (i = _handlers.find(node)) != _handlers.end()) { found = 1; if(i->second == *handler) { // 将连接资源从[可用连接表]中删除 _handlers.erase(i); found = 2; } } if(found) { ret = 0; // 如果需要被释放, 或者 handler 不是已经打开的handler if(bfree || 1 == found) { // 关闭连接 ret = close_handler(node,*handler); } else _handlers.insert(DeviceHandleMap::value_type(node,*handler)); // 通知其它等待的线程 _handle_cond.signal(); } } if(!found) { // 从父设备查找 if(node->GetParent() && node->GetParent()->GetDevice()) { return node->GetParent()->GetDevice()->release_handler(node->GetParent(),handler,bfree); } ACE_DEBUG((LM_DEBUG,"释放的连接资源不正确")); } return ret; }
static BOOL close_cdrom(WCHAR drive) { HANDLE handle; BOOL ret; handle = get_handler(drive); ret = cdrom_io_control(handle, IOCTL_STORAGE_LOAD_MEDIA, NULL); close_handler(handle); return ret; }
static BOOL unlock_cdrom(WCHAR drive) { HANDLE handle; PREVENT_MEDIA_REMOVAL removal; removal.PreventMediaRemoval = FALSE; handle = get_handler(drive); cdrom_io_control(handle, IOCTL_STORAGE_MEDIA_REMOVAL, &removal); close_handler(handle); return TRUE; }
void KSGDevice::close_all_handler() { DeviceHandleMap::iterator i ; for(i = _handlers.begin();i != _handlers.end();++i) { ACE_HANDLE handler = i->second; if(close_handler(NULL,handler)) { ACE_DEBUG((LM_ERROR,"关闭handler失败")); } } _handlers.clear(); for(i = _used_handlers.begin();i != _used_handlers.end();++i) { ACE_HANDLE handler = i->second; if(close_handler(NULL,handler)) { ACE_DEBUG((LM_ERROR,"关闭handler失败")); } } _used_handlers.clear(); }
static BOOL eject_cdrom(WCHAR drive) { HANDLE handle; PREVENT_MEDIA_REMOVAL removal; removal.PreventMediaRemoval = FALSE; handle = get_handler(drive); cdrom_io_control(handle, FSCTL_DISMOUNT_VOLUME, NULL); cdrom_io_control(handle, IOCTL_STORAGE_MEDIA_REMOVAL, &removal); cdrom_io_control(handle, IOCTL_STORAGE_EJECT_MEDIA, NULL); close_handler(handle); return TRUE; }
inline void rawsocket_connection::handle_system_error(const boost::system::error_code& error_code) { // NOTE: The boost documentation does not indicate what all of the possible error // codes are that can occur for the async receive handlers. So it will be an // ongoing exercise in trying to figure this out. if (error_code == boost::asio::error::eof) { BONEFISH_TRACE("connection closed: %1%", error_code); const auto& close_handler = get_close_handler(); close_handler(shared_from_this()); } else if (error_code != boost::asio::error::operation_aborted) { BONEFISH_TRACE("connection failed: %1%", error_code); const auto& fail_handler = get_fail_handler(); fail_handler(shared_from_this(), error_code.message().c_str()); } else { BONEFISH_TRACE("unhandled system error: %1%", error_code); assert(0); } }
/*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 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; }
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(); }
int main (int argc, char *argv[]) { struct sockaddr_in server; ssize_t rval; int msgsock, i, j, ret; long int check; uint16_t port; char *tmp; /* Kontrola parametrów wywołania */ if ((argc != 1) && (argc != 2)) fatal("Usage: %s [port]", argv[0]); port = PORT_NUM; // Domyślny port if (argc == 2) { check = strtol(argv[1], &tmp, 10); if (*tmp != 0 || check < 1 || check > USHRT_MAX) fatal("Invalid port number"); port = check; } /* Obsługa Ctrl-C */ if (signal(SIGINT, catch_int) == SIG_ERR) { perror("Unable to change signal handler"); exit(EXIT_FAILURE); } /* Inicjalizacja tablicy gniazd klientów, client[0] to gniazdo centrali*/ for (i = 0; i < CLIENTS_MAX; ++i) { client[i].fd = -1; client[i].events = POLLIN; client[i].revents = 0; memset(&client_info[i], 0, sizeof(struct client_info_t)); } active_clients = 0; /* Tworzenie gniazda centrali */ client[0].fd = socket(PF_INET, SOCK_STREAM, 0); if (client[0].fd < 0) { perror("Opening stream socket"); exit(EXIT_FAILURE); } server.sin_family = AF_INET; server.sin_addr.s_addr = htonl(INADDR_ANY); server.sin_port = htons(port); if (bind(client[0].fd, (struct sockaddr*)&server, (socklen_t)sizeof(server)) < 0) { perror("Binding stream socket"); exit(EXIT_FAILURE); } if (listen(client[0].fd, 5) == -1) { perror("Starting to listen"); exit(EXIT_FAILURE); } do { for (i = 0; i < CLIENTS_MAX; ++i) { client[i].events = POLLIN; client[i].revents = 0; } /* Po Ctrl-C następuje zamknięcie gniazda centrali */ if (finish == TRUE && client[0].fd >= 0) { if (close(client[0].fd) < 0) perror("Closing main socket"); client[0].fd = -1; } ret = poll(client, CLIENTS_MAX, TIMEOUT); if (ret < 0) { perror("Poll"); } else if (ret > 0) { if (finish == FALSE && (client[0].revents & POLLIN)) { msgsock = accept(client[0].fd, (struct sockaddr*)0, (socklen_t*)0); if (msgsock == -1) { perror("Accept"); } else { for (i = 1; i < CLIENTS_MAX; ++i) { if (client[i].fd == -1) { client[i].fd = msgsock; active_clients += 1; break; } } if (i >= CLIENTS_MAX) { fprintf(stderr, "Too many clients\n"); if (close(msgsock) < 0) perror("Closing stream socket"); } } } for (i = 1; i < CLIENTS_MAX; ++i) { if (client[i].fd != -1 && (client[i].revents & (POLLIN | POLLERR))) { if (client_info[i].len == 0) { /* Odczyt pierwszych 2 bajtów oznaczajacych długość wiadomośći */ rval = read(client[i].fd, ((char*)&client_info[i].rcv_msg), sizeof(client_info[i].rcv_msg.len)); if (rval < 0) { perror("Reading stream message"); close_handler(i); continue; } else if (rval == 0) { fprintf(stderr, "Ending connection\n"); close_handler(i); continue; } else { client_info[i].len = ntohs(client_info[i].rcv_msg.len); if (client_info[i].len == 0 || client_info[i].len > BUFFER_SIZE) { fprintf(stderr, "Received invalid message length\n"); if (close(client[i].fd) < 0) perror("Closing stream socket"); continue; } client_info[i].remains = client_info[i].len; client_info[i].prev_rval = 0; } } else { /* Odczyt reszty wiadomości */ rval = read(client[i].fd, ((char*)&client_info[i].rcv_msg) + sizeof(client_info[i].rcv_msg.len) + client_info[i].prev_rval, (size_t)client_info[i].remains); if (rval < 0) { perror("Reading stream message"); close_handler(i); continue; } else if (rval == 0) { fprintf(stderr, "Ending connection\n"); close_handler(i); continue; } client_info[i].prev_rval += rval; client_info[i].remains -= rval; if (client_info[i].prev_rval == client_info[i].len) { for (j = 1; j < CLIENTS_MAX; ++j) client[j].revents = POLLOUT; for (j = 1; j < CLIENTS_MAX; ++j) { if (i != j && client[j].fd != -1 && (client[j].revents & POLLOUT)) { /* Wysyłka wiadomości do wszystkich klientów prócz nadawcy */ rval = write(client[j].fd, &client_info[i].rcv_msg, sizeof(client_info[i].rcv_msg.len) + client_info[i].len); if (rval < 0) { perror("Writing to client socket"); if (close(client[j].fd) < 0) perror("Closing stream socket"); client[j].fd = -1; active_clients -= 1; } else { client[j].events = POLLIN; } } } /* Czyszczenie client_info[i] po wysłaniu wszystkich wiadomośći */ memset(&client_info[i], 0, sizeof(struct client_info_t)); } } } } } } while (finish == FALSE || active_clients > 0); if (client[0].fd >= 0) if (close(client[0].fd) < 0) perror("Closing main socket"); exit(EXIT_SUCCESS); }