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