static void hashtbl_empty_all(void)
{
int bkt;
struct ub_entry* e;
if (hash_empty(hashtable))
return;
// Need to walk the hash table to unset every struct hlist_node structure
hash_for_each_rcu(hashtable, bkt, e, hlist)
{
kfree_skb(e->skb);
hash_del_rcu(&e->hlist);
}
/**
* Transform dwarf2 informations
* Entrypoint for transformation from dwarf2 to uniform format
* @param file transform this file
*/
int edfmt_dwarf2_transform(elfshobj_t *file)
{
edfmtdw2info_t *tinfo;
edfmtdw2cu_t *tcu;
PROFILER_IN(__FILE__, __FUNCTION__, __LINE__);
if (!file)
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
"Invalid parameters", -1);
tinfo = (edfmtdw2info_t *) file->debug_format.dwarf2;
if (tinfo == NULL)
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
"No debug information for dwarf2", -1);
tcu = (edfmtdw2cu_t *) tinfo->cu_list;
if (tcu == NULL)
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
"No compile unit information for dwarf2", -1);
if (types_ref.ent == NULL)
hash_init(&types_ref, DWARF2_HNAME_TRANS_TREF, 200, ASPECT_TYPE_UNKNOW);
/* Setup the file */
edfmt_add_init(file);
/* Iterate through compile unit */
while (tcu != NULL)
{
current_cu = tcu;
abbrev_level = 0;
edfmt_dwarf2_transform_abbrev(tcu->info_pos);
tcu = tcu->next;
}
hash_empty(DWARF2_HNAME_TRANS_TREF);
current_cu = NULL;
/* Clean current file context */
edfmt_add_end();
PROFILER_ROUT(__FILE__, __FUNCTION__, __LINE__, 0);
}
int test_hash()
{
int result = 0;
Hash h;
test_msg_start("Test Hash - Prime Number Generator");
if(is_prime(0)) result++;
if(is_prime(1)) result++;
if(!is_prime(2)) result++;
if(!is_prime(3571)) result++;
if(is_prime(3570)) result++;
test_msg_end(result);
test_msg_start("Test Hash - Twin Prime Number Generator");
if(next_twinprime(6) != 7) result++;
if(next_twinprime(72) != 73) result++;
if(next_twinprime(1000) != 1021) result++;
if(next_twinprime(79154) != 79231) result++;
if(next_twinprime(INT_MAX) != -1) result++;
test_msg_end(result);
test_msg_start("Test Hash - Create New Hash");
h = hash_new_prime(100);
if(hash_empty(h) != 0) result++;
if(h.size != 103) result++;
if(h.data == NULL) result++;
test_msg_end(result);
test_msg_start("Test Hash - Insert and Verify Data");
hash_insert(h, "hello", 6);
if(hash_search(h, "hello", 6) == NULL) result++;
if(hash_search(h, "goodbye", 7) != NULL) result++;
if(hash_search(h, "", 0) != NULL) result++;
test_msg_end(result);
test_msg_start("Test Hash - Fill Hash and Clear Data");
/* if(hash_full(h) != 0) result++; */
test_msg_end(result);
test_msg_start("Test Hash - Fill Hash and Remove Specific Data");
test_msg_end(result);
test_msg_start("Test Hash - Insert and Verify Data");
test_msg_end(result);
return result;
}
/**
* Empty a hash table
*/
int cmd_empty()
{
char buf[BUFSIZ];
hash_t *hash;
list_t *list;
int index;
char *name;
PROFILER_IN(__FILE__, __FUNCTION__, __LINE__);
for (index = 0; index < world.curjob->curcmd->argc; index++)
{
name = revm_lookup_key(world.curjob->curcmd->param[index]);
hash = hash_find(name);
if (!hash)
{
list = elist_find(name);
if (!list)
{
snprintf(buf, sizeof(buf), " [W] Unknown list or hash table %s \n\n", name);
revm_output(buf);
continue;
}
snprintf(buf, sizeof(buf), " .:: Empty list %s \n\n", name);
revm_output(buf);
elist_empty(name);
}
else
{
snprintf(buf, sizeof(buf), " .:: Empty hash table %s \n\n", name);
revm_output(buf);
hash_empty(name);
}
}
PROFILER_ROUT(__FILE__, __FUNCTION__, __LINE__, 0);
}
/**
* Return a hash table pointer by its name.
* Overwrite existing table if there was one sharing that name, only
* if both tables have the same elements type
* @param table
* @param name
* @return
*/
int hash_register(hash_t *table, char *name)
{
hash_t *h;
int sz;
PROFILER_IN(__FILE__, __FUNCTION__, __LINE__);
h = hash_get(hash_hash, name);
if (h)
{
if (h->type == ASPECT_TYPE_UNKNOW)
h->type = table->type;
if (h->type != table->type)
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
"Incompatible hash tables", -1);
if (h->elmnbr)
h = hash_empty(name);
hash_merge(h, table);
PROFILER_ROUT(__FILE__, __FUNCTION__, __LINE__, 0);
}
XALLOC(__FILE__, __FUNCTION__, __LINE__, h, sizeof(hash_t), -1);
sz = (table->size > table->elmnbr ? table->size : table->elmnbr);
hash_init(h, name, sz, table->type);
PROFILER_ROUT(__FILE__, __FUNCTION__, __LINE__, 0);
}
/*
// Name: main
// In: argv, the arguments sent to the program.
// argc, the number of arguments sent to the program.
*/
int main (int argc, char **argv) {
char port[6];
char ssl_port[6];
if(!arguments(argv, argc, port, ssl_port)) {
printf("Usage: chat_server [port] [ssl port]\n");
return 0;
}
char topic[MAXTOKENSIZE];
memset(topic, '\0', MAXTOKENSIZE);
// Set the signal handler.
signal(SIGINT, signal_handler);
server_socket = -1;
ssl_socket = -1;
server_socket_fd;
int epoll_fd;
struct epoll_event event, ssl_event;
BIO *sbio;
SSL *ssl;
// Initialize ssl context.
ctx=init_ctx();
memset(&event, 0, sizeof event);
memset(&ssl_event, 0, sizeof event);
printf("Trying to create socket.\n");
server_socket_fd = create_socket("telnet", port);
ssl_socket_fd = create_socket("telnet", ssl_port);
printf("Created socket.\n");
// Check if sockets couldn't be created.
if(server_socket_fd<0 || ssl_socket_fd<0) {
fprintf(stderr, "Socket could not be created!\n");
return -1;
}
// Set the socket to be non-blocking.
server_socket = unblock_socket(server_socket_fd);
ssl_socket = unblock_socket(ssl_socket_fd);
if(server_socket<0 || ssl_socket<0) {
fprintf(stderr, "Could not make socket non blocking.\n");
return -1;
}
printf("Listening...\n");
// Listen for incoming connections.
server_socket = listen(server_socket_fd, NUMBER_PENDING_CONNECTIONS);
ssl_socket = listen(ssl_socket_fd, NUMBER_PENDING_CONNECTIONS);
if(server_socket < 0 || ssl_socket<0) {
fprintf(stderr, "Could not listen to incoming connections.\n");
return -1;
}
epoll_fd = epoll_create1(0);
event.data.fd = server_socket_fd;
// Run as edge-triggered, meaning that epoll_wait will return only on
// new events.
event.events = EPOLLIN | EPOLLET;
// Create epoll control interface for the unsecure socket.
server_socket = epoll_ctl(epoll_fd, EPOLL_CTL_ADD,
server_socket_fd, &event);
ssl_event.data.fd=ssl_socket_fd;
ssl_event.events = EPOLLIN | EPOLLET;
// Create epoll control interface for the secure socket.
ssl_socket = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, ssl_socket_fd, &ssl_event);
if(server_socket<0 || ssl_socket<0) {
fprintf(stderr, "Could not create control interface for polling.\n");
return -1;
}
events = calloc(MAXEVENTS, sizeof event);
// Create hash map for storing connected clients.
clients = hash_empty(MAXCLIENTS);
struct sockaddr client_addr;
socklen_t client_len;
int insocket_fd;
int client_socket;
char host[MAXHOST_LEN], serv[MAXSERV_LEN];
client_len = sizeof client_addr;
// Main loop listening from events generated by epoll.
while(1) {
int n,i;
// Wait for new events.
n = epoll_wait(epoll_fd, events, MAXEVENTS, -1);
for(i=0;i<n;i++) {
if((events[i].events & EPOLLERR) ||
events[i].events & EPOLLHUP ||
(!(events[i].events & EPOLLIN))) {
fprintf(stderr, "An error occured at an event.\n");
clientconn_t *c;
// If the an error-event occured at a connected client.
if((c = hash_get(events[i].data.fd, clients))!=NULL) {
client_close(c);
hash_remove(c, clients);
}
close(events[i].data.fd);
continue;
}
// If an a connection is made on the unsecure socket.
else if(server_socket_fd == events[i].data.fd) {
while(1) {
// Accept connection.
insocket_fd = accept(server_socket_fd,
&client_addr, &client_len);
if(insocket_fd<0) {
if(!(errno == EAGAIN || errno == EWOULDBLOCK)) {
fprintf(stderr, "Could not accept "
"input connection");
break;
} else {
// If the whole handshake could not be made,
// keep trying to accept.
break;
}
}
// The address information.
server_socket = getnameinfo(&client_addr, client_len, host,
sizeof host, serv, sizeof serv,
NI_NUMERICHOST|NI_NUMERICSERV);
if(server_socket==0) {
printf("Connection accepted!\n");
}
// Make client socket non-blocking.
server_socket = unblock_socket(insocket_fd);
if(server_socket <0) {
fprintf(stderr, "Could not make client socket "
"non-blocking\n");
return -1;
}
// Create an epoll interface for the client socket.
event.data.fd = insocket_fd;
event.events = EPOLLIN|EPOLLET;
server_socket = epoll_ctl(epoll_fd, EPOLL_CTL_ADD,
insocket_fd, &event);
if(server_socket<0) {
fprintf(stderr, "Could not create epoll "
"interface for client\n");
return -1;
}
printf("Added client(%d)!\n", insocket_fd);
// Store client in the hash map.
c = create_client(insocket_fd, &client_addr);
hash_insert(c, clients);
}
continue;
}
// If a connection is made on the secure socket.
else if(ssl_socket_fd == events[i].data.fd) {
printf("Someone connected through ssl!\n");
while(1) {
// Accept in the same way as the unsecure socket.
insocket_fd = accept(ssl_socket_fd,
&client_addr, &client_len);
if(insocket_fd<0) {
if(!(errno == EAGAIN || errno == EWOULDBLOCK)) {
fprintf(stderr, "Could not accept input "
"connection\n");
break;
} else {
break;
}
}
ssl_socket = getnameinfo(&client_addr, client_len, host,
sizeof host, serv, sizeof serv,
NI_NUMERICHOST|NI_NUMERICSERV);
if(ssl_socket==0) {
printf("Connection accepted!\n");
}
// Make socket non-blocking
ssl_socket = unblock_socket(insocket_fd);
if(ssl_socket<0){
fprintf(stderr, "Could not make secure client "
"socket non-blocking.\n");
return -1;
}
// Create epoll interface for the secure client connection
ssl_event.data.fd = insocket_fd;
ssl_event.events = EPOLLIN;
ssl_socket = epoll_ctl(epoll_fd, EPOLL_CTL_ADD,
insocket_fd, &ssl_event);
if(ssl_socket<0) {
fprintf(stderr, "Could not create "
"epoll interface for client.\n");
return -1;
}
printf("Added client!(%d)\n", insocket_fd);
c = create_client(insocket_fd, &client_addr);
// Set up ssl.
c->ssl_status=STATUS_HANDSHAKE;
c->ssl = SSL_new(ctx);
SSL_set_fd(c->ssl, insocket_fd);
SSL_set_mode(c->ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
hash_insert(c, clients);
}
continue;
}
// If an incoming message has caused an event.
else {
int done = 0;
while (1) {
ssize_t count;
char buf[MAXBUFSIZE];
memset(buf, '\0', MAXBUFSIZE);
clientconn_t *c = hash_get(events[i].data.fd, clients);
// If the client is trying to make an ssl handshake.
if(c->ssl_status==STATUS_HANDSHAKE) {
int r=1;
r=SSL_accept(c->ssl);
if (r<0) {
if(SSL_get_error(c->ssl, r)!=SSL_ERROR_WANT_READ &&
SSL_get_error(c->ssl, r)!=SSL_ERROR_WANT_WRITE ){
done=1;
printf("Could not accept ssl "
"connection\n");
break;
}
} else {
// Handshake is done.
c->ssl_status=STATUS_ACCEPTED;
}
}
else {
// Read data from client.
int count = client_read(c, buf, sizeof buf);
if(count<0) {
if(errno!=EAGAIN) {
fprintf(stderr, "Could not read"
" from socket!\n");
done=1;
}
break;
}
if(buf[MAXBUFSIZE-1] != '\0') {
write(events[i].data.fd, "* BAD Buffer will "
"overflow\r\n", 28);
break;
}
else if (count==0) {
done=1;
break;
}
if (handle_input(events[i].data.fd,
buf, count, clients, topic)==CLIENTCLOSED) {
done=1;
break;
}
if(server_socket<0) {
fprintf(stderr, "Could get input.\n");
return -1;
}
}
}
// Client connection is done, wants to disconnect.
if(done) {
printf("Closed connection!\n");
clientconn_t *closeclient = hash_get(events[i].data.fd,
clients);
if(closeclient != NULL) {
hash_remove(closeclient, clients);
client_close(closeclient);
}
close(events[i].data.fd);
}
}
}
}
free(events);
close(server_socket_fd);
return 0;
}