void TEST_choose_class() {
char file[] = "../jogar_tenis_normalizada.in";
int size_database=14, quantity_atributes=5;
int size_class_values = 2;
struct database *data = mount_database(file, size_database, quantity_atributes);
assert(data);
data->class_values = (double *)calloc(size_class_values, sizeof(double));
assert(data->class_values);
data->size_class_values = size_class_values;
data->class_values[0] = 1.0;
data->class_values[1] = 0.0;
struct distances *dist = create_distances(data->size_database);
assert(dist);
distance(data, dist, 1);
double class = choose_class(data, dist, 3);
printf("k=3, class:%f\n", class);
free_database(data);
free_distances(dist);
}
void TEST_knn(char *file, int size_database, int quantity_atributes, int k) {
int size_class_values = 2;
struct database *data = mount_database(file, size_database, quantity_atributes);
assert(data);
data->class_values = (double *)calloc(size_class_values, sizeof(double));
assert(data->class_values);
data->size_class_values = size_class_values;
data->class_values[0] = 1.0;
data->class_values[1] = 0.0;
int **confusion_matrix = create_confusion_matrix();
knn(data, k, confusion_matrix);
printf("TP:%d, FN:%d\nFP:%d, TN:%d\n",
confusion_matrix[0][0], confusion_matrix[0][1],
confusion_matrix[1][0], confusion_matrix[1][1]);
double i = (double)(confusion_matrix[0][0] + confusion_matrix[1][1]);
double j = (double)(confusion_matrix[0][0] + confusion_matrix[0][1] +
confusion_matrix[1][0] + confusion_matrix[1][1]);
printf("k:%d\naccuracy: %f\n", k, (double)(i/j));
free_database(data);
free_confusion_matrix(confusion_matrix);
}
void TEST_distance() {
char file[] = "../jogar_tenis_normalizada.in";
int size_database=14, quantity_atributes=5;
int size_class_values = 2;
struct database *data = mount_database(file, size_database, quantity_atributes);
assert(data);
data->class_values = (double *)calloc(size_class_values, sizeof(double));
assert(data->class_values);
data->size_class_values = size_class_values;
data->class_values[0] = 1.0;
data->class_values[1] = 0.0;
struct distances *dist = create_distances(data->size_database);
assert(dist);
distance(data, dist, 1);
int i;
for(i=0; i < dist->size_distances; i++) {
printf("dist:%f, %d\n", dist->distance[i].distance, dist->distance[i].indice);
}
free_database(data);
free_distances(dist);
}
int
conf_read(const char *conf_file_name)
{
dict_t old_conf = conf_db;
if (!(conf_db = parse_database(conf_file_name))) {
goto fail;
}
if (reload_funcs) {
conf_call_reload_funcs();
}
if (old_conf && old_conf != conf_db) {
free_database(old_conf);
}
return 1;
fail:
log_module(MAIN_LOG, LOG_ERROR, "Reverting to previous configuration.");
free_database(conf_db);
conf_db = old_conf;
return 0;
}
static void
finalize (GObject *object)
{
NMSessionMonitor *self = NM_SESSION_MONITOR (object);
if (self->database_monitor != NULL)
g_object_unref (self->database_monitor);
free_database (self);
if (G_OBJECT_CLASS (nm_session_monitor_parent_class)->finalize != NULL)
G_OBJECT_CLASS (nm_session_monitor_parent_class)->finalize (object);
}
static void
on_file_monitor_changed (GFileMonitor * file_monitor,
GFile * file,
GFile * other_file,
GFileMonitorEvent event_type,
gpointer user_data)
{
NMSessionMonitor *self = NM_SESSION_MONITOR (user_data);
/* throw away cache */
free_database (self);
g_signal_emit (self, signals[CHANGED], 0);
}
void TEST_euclidean_distance() {
char file[] = "../jogar_tenis_normalizada.in";
int size_database=14, quantity_atributes=5;
int size_class_values = 2;
struct database *data = mount_database(file, size_database, quantity_atributes);
assert(data);
data->class_values = (double *)calloc(size_class_values, sizeof(double));
assert(data->class_values);
data->size_class_values = size_class_values;
data->class_values[0] = 1.0;
data->class_values[1] = 0.0;
euclidean_distance(data, 1, 2);
free_database(data);
}
/**
* Server Main Loop
* @param server Server Listening Socket
* @return OS Error Code
*/
int server_loop(int server)
{
// Set Running Status
_status = 1;
// Create Empty Status Logfile
update_status();
// Handling Loop
while(_status == 1)
{
// Login Block
{
// Login Result
int loginresult = 0;
// Login Processing Loop
do
{
// Prepare Address Structure
struct sockaddr_in addr;
socklen_t addrlen = sizeof(addr);
memset(&addr, 0, sizeof(addr));
// Accept Login Requests
// loginresult = accept4(server, (struct sockaddr *)&addr, &addrlen, SOCK_NONBLOCK);
// Alternative Accept Approach (some Linux Kernel don't support the accept4 Syscall... wtf?)
loginresult = accept(server, (struct sockaddr *)&addr, &addrlen);
if(loginresult != -1)
{
// Switch Socket into Non-Blocking Mode
change_blocking_mode(loginresult, 1);
}
// Login User (Stream)
if(loginresult != -1) login_user_stream(loginresult, addr.sin_addr.s_addr);
} while(loginresult != -1);
}
// Receive Data from Users
SceNetAdhocctlUserNode * user = _db_user;
while(user != NULL)
{
// Next User (for safe delete)
SceNetAdhocctlUserNode * next = user->next;
// Receive Data from User
int recvresult = recv(user->stream, user->rx + user->rxpos, sizeof(user->rx) - user->rxpos, 0);
// Connection Closed or Timed Out
if(recvresult == 0 || (recvresult == -1 && errno != EAGAIN && errno != EWOULDBLOCK) || get_user_state(user) == USER_STATE_TIMED_OUT)
{
// Logout User
logout_user(user);
}
// Received Data (or leftovers in RX-Buffer)
else if(recvresult > 0 || user->rxpos > 0)
{
// New Incoming Data
if(recvresult > 0)
{
// Move RX Pointer
user->rxpos += recvresult;
// Update Death Clock
user->last_recv = time(NULL);
}
// Waiting for Login Packet
if(get_user_state(user) == USER_STATE_WAITING)
{
// Valid Opcode
if(user->rx[0] == OPCODE_LOGIN)
{
// Enough Data available
if(user->rxpos >= sizeof(SceNetAdhocctlLoginPacketC2S))
{
// Clone Packet
SceNetAdhocctlLoginPacketC2S packet = *(SceNetAdhocctlLoginPacketC2S *)user->rx;
// Remove Packet from RX Buffer
clear_user_rxbuf(user, sizeof(SceNetAdhocctlLoginPacketC2S));
// Login User (Data)
login_user_data(user, &packet);
}
}
// Invalid Opcode
else
{
// Notify User
uint8_t * ip = (uint8_t *)&user->resolver.ip;
printf("Invalid Opcode 0x%02X in Waiting State from %u.%u.%u.%u.\n", user->rx[0], ip[0], ip[1], ip[2], ip[3]);
// Logout User
logout_user(user);
}
}
// Logged-In User
else if(get_user_state(user) == USER_STATE_LOGGED_IN)
{
// Ping Packet
if(user->rx[0] == OPCODE_PING)
{
// Delete Packet from RX Buffer
clear_user_rxbuf(user, 1);
}
// Group Connect Packet
else if(user->rx[0] == OPCODE_CONNECT)
{
// Enough Data available
if(user->rxpos >= sizeof(SceNetAdhocctlConnectPacketC2S))
{
// Cast Packet
SceNetAdhocctlConnectPacketC2S * packet = (SceNetAdhocctlConnectPacketC2S *)user->rx;
// Clone Group Name
SceNetAdhocctlGroupName group = packet->group;
// Remove Packet from RX Buffer
clear_user_rxbuf(user, sizeof(SceNetAdhocctlConnectPacketC2S));
// Change Game Group
connect_user(user, &group);
}
}
// Group Disconnect Packet
else if(user->rx[0] == OPCODE_DISCONNECT)
{
// Remove Packet from RX Buffer
clear_user_rxbuf(user, 1);
// Leave Game Group
disconnect_user(user);
}
// Network Scan Packet
else if(user->rx[0] == OPCODE_SCAN)
{
// Remove Packet from RX Buffer
clear_user_rxbuf(user, 1);
// Send Network List
send_scan_results(user);
}
// Chat Text Packet
else if(user->rx[0] == OPCODE_CHAT)
{
// Enough Data available
if(user->rxpos >= sizeof(SceNetAdhocctlChatPacketC2S))
{
// Cast Packet
SceNetAdhocctlChatPacketC2S * packet = (SceNetAdhocctlChatPacketC2S *)user->rx;
// Clone Buffer for Message
char message[64];
memset(message, 0, sizeof(message));
strncpy(message, packet->message, sizeof(message) - 1);
// Remove Packet from RX Buffer
clear_user_rxbuf(user, sizeof(SceNetAdhocctlChatPacketC2S));
// Spread Chat Message
spread_message(user, message);
}
}
// Invalid Opcode
else
{
// Notify User
uint8_t * ip = (uint8_t *)&user->resolver.ip;
printf("Invalid Opcode 0x%02X in Logged-In State from %s (MAC: %02X:%02X:%02X:%02X:%02X:%02X - IP: %u.%u.%u.%u).\n", user->rx[0], (char *)user->resolver.name.data, user->resolver.mac.data[0], user->resolver.mac.data[1], user->resolver.mac.data[2], user->resolver.mac.data[3], user->resolver.mac.data[4], user->resolver.mac.data[5], ip[0], ip[1], ip[2], ip[3]);
// Logout User
logout_user(user);
}
}
}
// Move Pointer
user = next;
}
// Prevent needless CPU Overload (1ms Sleep)
usleep(1000);
}
// Free User Database Memory
free_database();
// Close Server Socket
close(server);
// Return Success
return 0;
}
static gboolean
reload_database (NMSessionMonitor *self, GError **error)
{
struct stat statbuf;
char **groups = NULL;
gsize len = 0, i;
Session *s;
free_database (self);
errno = 0;
if (stat (CKDB_PATH, &statbuf) != 0) {
g_set_error (error,
NM_SESSION_MONITOR_ERROR,
errno == ENOENT ? NM_SESSION_MONITOR_ERROR_NO_DATABASE : NM_SESSION_MONITOR_ERROR_IO_ERROR,
"Error statting file " CKDB_PATH ": %s",
strerror (errno));
goto error;
}
self->database_mtime = statbuf.st_mtime;
self->database = g_key_file_new ();
if (!g_key_file_load_from_file (self->database, CKDB_PATH, G_KEY_FILE_NONE, error))
goto error;
groups = g_key_file_get_groups (self->database, &len);
if (!groups) {
g_set_error_literal (error,
NM_SESSION_MONITOR_ERROR,
NM_SESSION_MONITOR_ERROR_IO_ERROR,
"Could not load groups from " CKDB_PATH "");
goto error;
}
for (i = 0; i < len; i++) {
Session *found;
if (!g_str_has_prefix (groups[i], "Session "))
continue;
s = session_new (self->database, groups[i], error);
if (!s)
goto error;
found = g_hash_table_lookup (self->sessions_by_user, (gpointer) s->user);
if (found) {
session_merge (s, found);
session_free (s);
} else {
/* Entirely new user */
g_hash_table_insert (self->sessions_by_user, (gpointer) s->user, s);
g_hash_table_insert (self->sessions_by_uid, GUINT_TO_POINTER (s->uid), s);
}
}
g_strfreev (groups);
return TRUE;
error:
if (groups)
g_strfreev (groups);
free_database (self);
return FALSE;
}
void
conf_close(void)
{
free_database(conf_db);
free(reload_funcs);
}
