external/uhub
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Rework logging code to be able to turn it off completely.

Browse Source
This commit is contained in:
Jan Vidar Krey 2009-07-26 01:38:38 +02:00
parent 5048ff9ae5
commit 6e5d28c2d4
22 changed files with 149 additions and 751 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/adc/message.c
View File

@ -244,7 +244,7 @@ struct adc_message* adc_msg_parse_verify(struct user* u, const char* line, size_
if (command->source && (!u || command->source != u->id.sid)) if (command->source && (!u || command->source != u->id.sid))
{ {
hub_log(log_debug, "Command does not match user's SID (command->source=%d, user->id.sid=%d)", command->source, (u ? u->id.sid : 0)); LOG_DEBUG("Command does not match user's SID (command->source=%d, user->id.sid=%d)", command->source, (u ? u->id.sid : 0));
adc_msg_free(command); adc_msg_free(command);
return 0; return 0;
} }
@ -268,7 +268,7 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
if (!is_printable_utf8(line, length)) if (!is_printable_utf8(line, length))
{ {
hub_log(log_debug, "Dropped message with non-printable UTF-8 characters."); LOG_DEBUG("Dropped message with non-printable UTF-8 characters.");
hub_free(command); hub_free(command);
return NULL; return NULL;
} }
@ -520,7 +520,6 @@ int adc_msg_remove_named_argument(struct adc_message* cmd, const char prefix_[2]
{ {
temp_len = &end[0] - &start[0]; // strlen(start); temp_len = &end[0] - &start[0]; // strlen(start);
/* hub_log(log_trace, " length=%d", (int) (temp_len)); */
endlen = strlen(end); endlen = strlen(end);
memmove(start, end, endlen); memmove(start, end, endlen);

36
src/core/auth.c
View File

@ -55,12 +55,12 @@ static int check_cmd_bool(const char* cmd, struct linked_list* list, char* line,
data = strip_white_space(data); data = strip_white_space(data);
if (!*data) if (!*data)
{ {
hub_log(log_fatal, "ACL parse error on line %d", line_count); LOG_FATAL("ACL parse error on line %d", line_count);
return -1; return -1;
} }
list_append(list, hub_strdup(data)); list_append(list, hub_strdup(data));
hub_log(log_debug, "ACL: Deny access for: '%s' (%s)", data, cmd); LOG_DEBUG("ACL: Deny access for: '%s' (%s)", data, cmd);
return 1; return 1;
} }
return 0; return 0;
@ -82,7 +82,7 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
data = strip_white_space(data); data = strip_white_space(data);
if (!*data) if (!*data)
{ {
hub_log(log_fatal, "ACL parse error on line %d", line_count); LOG_FATAL("ACL parse error on line %d", line_count);
return -1; return -1;
} }
@ -90,7 +90,7 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
if (!info) if (!info)
{ {
hub_log(log_error, "ACL parse error. Out of memory!"); LOG_ERROR("ACL parse error. Out of memory!");
return -1; return -1;
} }
@ -108,7 +108,7 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
info->password = data_extra ? hub_strdup(data_extra) : 0; info->password = data_extra ? hub_strdup(data_extra) : 0;
info->status = status; info->status = status;
list_append(list, info); list_append(list, info);
hub_log(log_debug, "ACL: Added user '%s' (%s)", info->username, get_user_credential_string(info->status)); LOG_DEBUG("ACL: Added user '%s' (%s)", info->username, get_user_credential_string(info->status));
return 1; return 1;
} }
return 0; return 0;
@ -130,7 +130,7 @@ static void add_ip_range(struct linked_list* list, struct ip_ban_record* info)
net_address_to_string(AF_INET6, &info->lo.internal_ip_data.in6, buf1, INET6_ADDRSTRLEN); net_address_to_string(AF_INET6, &info->lo.internal_ip_data.in6, buf1, INET6_ADDRSTRLEN);
net_address_to_string(AF_INET6, &info->hi.internal_ip_data.in6, buf2, INET6_ADDRSTRLEN); net_address_to_string(AF_INET6, &info->hi.internal_ip_data.in6, buf2, INET6_ADDRSTRLEN);
} }
hub_log(log_debug, "ACL: Deny access for: %s-%s", buf1, buf2); LOG_DEBUG("ACL: Deny access for: %s-%s", buf1, buf2);
list_append(list, info); list_append(list, info);
} }
@ -157,7 +157,7 @@ static int check_ip_range(const char* lo, const char* hi, struct ip_ban_record*
static int check_ip_mask(const char* text_addr, int bits, struct ip_ban_record* info) static int check_ip_mask(const char* text_addr, int bits, struct ip_ban_record* info)
{ {
hub_log(log_debug, "ACL: Deny access for: %s/%d", text_addr, bits); LOG_DEBUG("ACL: Deny access for: %s/%d", text_addr, bits);
if (ip_is_valid_ipv4(text_addr) || if (ip_is_valid_ipv4(text_addr) ||
ip_is_valid_ipv6(text_addr)) ip_is_valid_ipv6(text_addr))
@ -194,7 +194,7 @@ static int check_cmd_addr(const char* cmd, struct linked_list* list, char* line,
data1 = strip_white_space(data1); data1 = strip_white_space(data1);
if (!*data1) if (!*data1)
{ {
hub_log(log_fatal, "ACL parse error on line %d", line_count); LOG_FATAL("ACL parse error on line %d", line_count);
return -1; return -1;
} }
@ -202,7 +202,7 @@ static int check_cmd_addr(const char* cmd, struct linked_list* list, char* line,
if (!info) if (!info)
{ {
hub_log(log_error, "ACL parse error. Out of memory!"); LOG_ERROR("ACL parse error. Out of memory!");
return -1; return -1;
} }
@ -269,20 +269,16 @@ static int acl_parse_line(char* line, int line_count, void* ptr_data)
if (!*line) if (!*line)
return 0; return 0;
#ifdef ACL_DEBUG LOG_DEBUG("acl_parse_line(): '%s'", line);
hub_log(log_trace, "acl_parse_line(): '%s'", line);
#endif
line = strip_white_space(line); line = strip_white_space(line);
if (!*line) if (!*line)
{ {
hub_log(log_fatal, "ACL parse error on line %d", line_count); LOG_FATAL("ACL parse error on line %d", line_count);
return -1; return -1;
} }
#ifdef ACL_DEBUG LOG_DEBUG("acl_parse_line: '%s'", line);
hub_log(log_trace, "acl_parse_line: '%s'", line);
#endif
ACL_ADD_USER("bot", handle->users, cred_bot); ACL_ADD_USER("bot", handle->users, cred_bot);
ACL_ADD_USER("user_admin", handle->users, cred_admin); ACL_ADD_USER("user_admin", handle->users, cred_admin);
@ -296,7 +292,7 @@ static int acl_parse_line(char* line, int line_count, void* ptr_data)
ACL_ADD_ADDR("deny_ip", handle->networks); ACL_ADD_ADDR("deny_ip", handle->networks);
ACL_ADD_ADDR("nat_ip", handle->nat_override); ACL_ADD_ADDR("nat_ip", handle->nat_override);
hub_log(log_error, "Unknown ACL command on line %d: '%s'", line_count, line); LOG_ERROR("Unknown ACL command on line %d: '%s'", line_count, line);
return -1; return -1;
} }
@ -315,7 +311,7 @@ int acl_initialize(struct hub_config* config, struct acl_handle* handle)
if (!handle->users || !handle->cids || !handle->networks || !handle->users_denied || !handle->users_banned || !handle->nat_override) if (!handle->users || !handle->cids || !handle->networks || !handle->users_denied || !handle->users_banned || !handle->nat_override)
{ {
hub_log(log_fatal, "acl_initialize: Out of memory"); LOG_FATAL("acl_initialize: Out of memory");
list_destroy(handle->users); list_destroy(handle->users);
list_destroy(handle->users_denied); list_destroy(handle->users_denied);
@ -451,7 +447,7 @@ int acl_user_ban_nick(struct acl_handle* handle, const char* nick)
struct user_access_info* info = hub_malloc_zero(sizeof(struct user_access_info)); struct user_access_info* info = hub_malloc_zero(sizeof(struct user_access_info));
if (!info) if (!info)
{ {
hub_log(log_error, "ACL error: Out of memory!"); LOG_ERROR("ACL error: Out of memory!");
return -1; return -1;
} }
list_append(handle->users_banned, hub_strdup(nick)); list_append(handle->users_banned, hub_strdup(nick));
@ -463,7 +459,7 @@ int acl_user_ban_cid(struct acl_handle* handle, const char* cid)
struct user_access_info* info = hub_malloc_zero(sizeof(struct user_access_info)); struct user_access_info* info = hub_malloc_zero(sizeof(struct user_access_info));
if (!info) if (!info)
{ {
hub_log(log_error, "ACL error: Out of memory!"); LOG_ERROR("ACL error: Out of memory!");
return -1; return -1;
} }
list_append(handle->cids, hub_strdup(cid)); list_append(handle->cids, hub_strdup(cid));

22
src/core/config.c
View File

@ -42,7 +42,7 @@
else if (strncasecmp(data, "off", 3) == 0) TARGET = 0; \ else if (strncasecmp(data, "off", 3) == 0) TARGET = 0; \
else\ else\
{ \ { \
hub_log(log_fatal, "Configuration error on line %d: '%s' must be either '1' or '0'", line_count, key); \ LOG_FATAL("Configuration error on line %d: '%s' must be either '1' or '0'", line_count, key); \
return -1; \ return -1; \
} \ } \
TARGET |= 0x80000000; \ TARGET |= 0x80000000; \
@ -65,7 +65,7 @@
errno = 0; \ errno = 0; \
val = strtol(data, &endptr, 10); \ val = strtol(data, &endptr, 10); \
if (((errno == ERANGE && (val == INT_MAX || val == INT_MIN)) || (errno != 0 && val == 0)) || endptr == data) { \ if (((errno == ERANGE && (val == INT_MAX || val == INT_MIN)) || (errno != 0 && val == 0)) || endptr == data) { \
hub_log(log_fatal, "Configuration error on line %d: '%s' must be a number", line_count, key); \ LOG_FATAL("Configuration error on line %d: '%s' must be a number", line_count, key); \
return -1; \ return -1; \
} \ } \
TARGET = val; \ TARGET = val; \
@ -103,7 +103,7 @@
#define IGNORED(NAME) \ #define IGNORED(NAME) \
if (strcmp(#NAME, key) == 0) \ if (strcmp(#NAME, key) == 0) \
{ \ { \
hub_log(log_warning, "Configuration option %s deprecated and ingnored.", key); \ LOG_WARN("Configuration option %s deprecated and ingnored.", key); \
return 0; \ return 0; \
} \ } \
@ -304,7 +304,7 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
GET_STR (tls_private_key); GET_STR (tls_private_key);
/* Still here -- unknown directive */ /* Still here -- unknown directive */
hub_log(log_fatal, "Unknown configuration directive: '%s'", key); LOG_ERROR("Unknown configuration directive: '%s'", key);
return -1; return -1;
} }
@ -460,13 +460,11 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
if (!*line) return 0; if (!*line) return 0;
#ifdef CONFIG_DUMP LOG_DUMP("config_parse_line(): '%s'", line);
hub_log(log_trace, "config_parse_line(): '%s'", line);
#endif
if (!is_valid_utf8(line)) if (!is_valid_utf8(line))
{ {
hub_log(log_warning, "Invalid utf-8 characters on line %d", line_count); LOG_WARN("Invalid utf-8 characters on line %d", line_count);
} }
if ((pos = strchr(line, '=')) != NULL) if ((pos = strchr(line, '=')) != NULL)
@ -486,13 +484,11 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
if (!*key || !*data) if (!*key || !*data)
{ {
hub_log(log_fatal, "Configuration parse error on line %d", line_count); LOG_FATAL("Configuration parse error on line %d", line_count);
return -1; return -1;
} }
#ifdef CONFIG_DUMP LOG_DUMP("config_parse_line: '%s' => '%s'", key, data);
hub_log(log_trace, "config_parse_line: '%s' => '%s'", key, data);
#endif
return apply_config(config, key, data, line_count); return apply_config(config, key, data, line_count);
} }
@ -509,7 +505,7 @@ int read_config(const char* file, struct hub_config* config, int allow_missing)
{ {
if (allow_missing && ret == -2) if (allow_missing && ret == -2)
{ {
hub_log(log_debug, "Using default configuration."); LOG_DUMP("Using default configuration.");
} }
else else
{ {

4
src/core/eventqueue.c
View File

@ -22,7 +22,7 @@
#ifdef EQ_DEBUG #ifdef EQ_DEBUG
static void eq_debug(const char* prefix, struct event_data* data) static void eq_debug(const char* prefix, struct event_data* data)
{ {
printf(">>> %s: %p, id: %x, flags=%d\n", prefix, data, data->id, data->flags); LOG_DUMP(">>> %s: %p, id: %x, flags=%d\n", prefix, data, data->id, data->flags);
} }
#endif #endif
@ -130,7 +130,7 @@ void event_queue_post(struct event_queue* queue, struct event_data* message)
} }
else else
{ {
hub_log(log_error, "event_queue_post: OUT OF MEMORY"); LOG_ERROR("event_queue_post: OUT OF MEMORY");
} }
} }

28
src/core/hub.c
View File

@ -21,16 +21,12 @@
struct hub_info* g_hub = 0; struct hub_info* g_hub = 0;
#define NETWORK_DUMP_DEBUG 1
int hub_handle_message(struct hub_info* hub, struct user* u, const char* line, size_t length) int hub_handle_message(struct hub_info* hub, struct user* u, const char* line, size_t length)
{ {
int ret = 0; int ret = 0;
struct adc_message* cmd = 0; struct adc_message* cmd = 0;
#ifdef NETWORK_DUMP_DEBUG LOG_PROTO("recv %s: %s", sid_to_string(u->id.sid), line);
hub_log(log_protocol, "recv %s: %s", sid_to_string(u->id.sid), line);
#endif
if (user_is_disconnecting(u)) if (user_is_disconnecting(u))
return -1; return -1;
@ -399,7 +395,7 @@ struct hub_info* hub_start_service(struct hub_config* config)
hub = hub_malloc_zero(sizeof(struct hub_info)); hub = hub_malloc_zero(sizeof(struct hub_info));
if (!hub) if (!hub)
{ {
hub_log(log_fatal, "Unable to allocate memory for hub"); LOG_FATAL("Unable to allocate memory for hub");
return 0; return 0;
} }
@ -408,9 +404,9 @@ struct hub_info* hub_start_service(struct hub_config* config)
ipv6_supported = net_is_ipv6_supported(); ipv6_supported = net_is_ipv6_supported();
if (ipv6_supported) if (ipv6_supported)
hub_log(log_debug, "IPv6 supported."); LOG_DEBUG("IPv6 supported.");
else else
hub_log(log_debug, "IPv6 not supported."); LOG_DEBUG("IPv6 not supported.");
if (ip_convert_address(config->server_bind_addr, config->server_port, (struct sockaddr*) &addr, &sockaddr_size) == -1) if (ip_convert_address(config->server_bind_addr, config->server_port, (struct sockaddr*) &addr, &sockaddr_size) == -1)
{ {
@ -435,13 +431,13 @@ struct hub_info* hub_start_service(struct hub_config* config)
#endif #endif
if (!hub->evbase) if (!hub->evbase)
{ {
hub_log(log_error, "Unable to initialize libevent."); LOG_ERROR("Unable to initialize libevent.");
hub_free(hub); hub_free(hub);
return 0; return 0;
} }
hub_log(log_info, "Starting " PRODUCT "/" VERSION ", listening on %s:%d...", address_buf, config->server_port); LOG_INFO("Starting " PRODUCT "/" VERSION ", listening on %s:%d...", address_buf, config->server_port);
hub_log(log_debug, "Using libevent %s, backend: %s", event_get_version(), event_get_method()); LOG_DEBUG("Using libevent %s, backend: %s", event_get_version(), event_get_method());
server_tcp = net_socket_create(af, SOCK_STREAM, IPPROTO_TCP); server_tcp = net_socket_create(af, SOCK_STREAM, IPPROTO_TCP);
if (server_tcp == -1) if (server_tcp == -1)
@ -472,7 +468,7 @@ struct hub_info* hub_start_service(struct hub_config* config)
ret = net_bind(server_tcp, (struct sockaddr*) &addr, sockaddr_size); ret = net_bind(server_tcp, (struct sockaddr*) &addr, sockaddr_size);
if (ret == -1) if (ret == -1)
{ {
hub_log(log_fatal, "hub_start_service(): Unable to bind to TCP local address. errno=%d, str=%s", net_error(), net_error_string(net_error())); LOG_FATAL("hub_start_service(): Unable to bind to TCP local address. errno=%d, str=%s", net_error(), net_error_string(net_error()));
event_base_free(hub->evbase); event_base_free(hub->evbase);
hub_free(hub); hub_free(hub);
net_close(server_tcp); net_close(server_tcp);
@ -482,7 +478,7 @@ struct hub_info* hub_start_service(struct hub_config* config)
ret = net_listen(server_tcp, SERVER_BACKLOG); ret = net_listen(server_tcp, SERVER_BACKLOG);
if (ret == -1) if (ret == -1)
{ {
hub_log(log_fatal, "hub_start_service(): Unable to listen to socket"); LOG_FATAL("hub_start_service(): Unable to listen to socket");
event_base_free(hub->evbase); event_base_free(hub->evbase);
hub_free(hub); hub_free(hub);
net_close(server_tcp); net_close(server_tcp);
@ -539,7 +535,7 @@ struct hub_info* hub_start_service(struct hub_config* config)
void hub_shutdown_service(struct hub_info* hub) void hub_shutdown_service(struct hub_info* hub)
{ {
hub_log(log_trace, "hub_shutdown_service()"); LOG_TRACE("hub_shutdown_service()");
event_queue_shutdown(hub->queue); event_queue_shutdown(hub->queue);
event_del(&hub->ev_accept); event_del(&hub->ev_accept);
@ -903,7 +899,7 @@ void hub_event_loop(struct hub_info* hub)
if (ret != 0) if (ret != 0)
{ {
hub_log(log_debug, "event_base_loop returned: %d", (int) ret); LOG_DEBUG("event_base_loop returned: %d", (int) ret);
} }
if (ret < 0) if (ret < 0)
@ -937,7 +933,7 @@ void hub_disconnect_user(struct hub_info* hub, struct user* user, int reason)
/* stop reading from user */ /* stop reading from user */
net_shutdown_r(user->net.sd); net_shutdown_r(user->net.sd);
hub_log(log_trace, "hub_disconnect_user(), user=%p, reason=%d, state=%d", user, reason, user->state); LOG_TRACE("hub_disconnect_user(), user=%p, reason=%d, state=%d", user, reason, user->state);
need_notify = user_is_logged_in(user); need_notify = user_is_logged_in(user);
user->quit_reason = reason; user->quit_reason = reason;

8
src/core/hubevent.c
View File

@ -23,26 +23,26 @@ static void log_user_login(struct user* u)
{ {
const char* cred = get_user_credential_string(u->credentials); const char* cred = get_user_credential_string(u->credentials);
const char* addr = ip_convert_to_string(&u->net.ipaddr); const char* addr = ip_convert_to_string(&u->net.ipaddr);
hub_log(log_user, "LoginOK %s/%s %s \"%s\" (%s) \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, cred, u->user_agent); LOG_USER("LoginOK %s/%s %s \"%s\" (%s) \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, cred, u->user_agent);
} }
static void log_user_login_error(struct user* u, enum status_message msg) static void log_user_login_error(struct user* u, enum status_message msg)
{ {
const char* addr = ip_convert_to_string(&u->net.ipaddr); const char* addr = ip_convert_to_string(&u->net.ipaddr);
const char* message = hub_get_status_message_log(u->hub, msg); const char* message = hub_get_status_message_log(u->hub, msg);
hub_log(log_user, "LoginError %s/%s %s \"%s\" (%s) \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, message, u->user_agent); LOG_USER("LoginError %s/%s %s \"%s\" (%s) \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, message, u->user_agent);
} }
static void log_user_logout(struct user* u, const char* message) static void log_user_logout(struct user* u, const char* message)
{ {
const char* addr = ip_convert_to_string(&u->net.ipaddr); const char* addr = ip_convert_to_string(&u->net.ipaddr);
hub_log(log_user, "Logout %s/%s %s \"%s\" (%s)", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, message); LOG_USER("Logout %s/%s %s \"%s\" (%s)", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, message);
} }
static void log_user_nick_change(struct user* u, const char* nick) static void log_user_nick_change(struct user* u, const char* nick)
{ {
const char* addr = ip_convert_to_string(&u->net.ipaddr); const char* addr = ip_convert_to_string(&u->net.ipaddr);
hub_log(log_user, "NickChange %s/%s %s \"%s\" -> \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, nick); LOG_USER("NickChange %s/%s %s \"%s\" -> \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, nick);
} }

2
src/core/hubio.c
View File

@ -35,7 +35,7 @@ static void debug_msg(const char* prefix, struct adc_message* msg)
if (buf[n] == '\r' || buf[n] == '\n') if (buf[n] == '\r' || buf[n] == '\n')
buf[n] = '_'; buf[n] = '_';
} }
hub_log(log_trace, "%s: [%s] (%d bytes)", prefix, buf, (int) msg->length); LOG_TRACE("%s: [%s] (%d bytes)", prefix, buf, (int) msg->length);
free(buf); free(buf);
} }
#endif #endif

6
src/core/inf.c
View File

@ -336,7 +336,7 @@ static int check_logged_in(struct hub_info* hub, struct user* user, struct adc_m
{ {
if (lookup1 == lookup2) if (lookup1 == lookup2)
{ {
hub_log(log_debug, "check_logged_in: exact same user is logged in: %s", user->id.nick); LOG_DEBUG("check_logged_in: exact same user is logged in: %s", user->id.nick);
hub_disconnect_user(hub, lookup1, quit_ghost_timeout); hub_disconnect_user(hub, lookup1, quit_ghost_timeout);
return 0; return 0;
} }
@ -344,12 +344,12 @@ static int check_logged_in(struct hub_info* hub, struct user* user, struct adc_m
{ {
if (lookup1) if (lookup1)
{ {
hub_log(log_debug, "check_logged_in: nickname is in use: %s", user->id.nick); LOG_DEBUG("check_logged_in: nickname is in use: %s", user->id.nick);
return status_msg_inf_error_nick_taken; return status_msg_inf_error_nick_taken;
} }
else else
{ {
hub_log(log_debug, "check_logged_in: CID is in use: %s", user->id.cid); LOG_DEBUG("check_logged_in: CID is in use: %s", user->id.cid);
return status_msg_inf_error_cid_taken; return status_msg_inf_error_cid_taken;
} }
} }

34
src/core/main.c
View File

@ -42,12 +42,12 @@ void hub_handle_signal(int fd, short events, void* arg)
switch (signal) switch (signal)
{ {
case SIGINT: case SIGINT:
hub_log(log_info, "Interrupted. Shutting down..."); LOG_INFO("Interrupted. Shutting down...");
hub->status = hub_status_shutdown; hub->status = hub_status_shutdown;
break; break;
case SIGTERM: case SIGTERM:
hub_log(log_info, "Terminated. Shutting down..."); LOG_INFO("Terminated. Shutting down...");
hub->status = hub_status_shutdown; hub->status = hub_status_shutdown;
break; break;
@ -59,7 +59,7 @@ void hub_handle_signal(int fd, short events, void* arg)
break; break;
default: default:
hub_log(log_trace, "hub_handle_signal(): caught unknown signal: %d", signal); LOG_TRACE("hub_handle_signal(): caught unknown signal: %d", signal);
hub->status = hub_status_shutdown; hub->status = hub_status_shutdown;
break; break;
} }
@ -84,7 +84,7 @@ void setup_signal_handlers(struct hub_info* hub)
event_base_set(hub->evbase, &signal_events[i]); event_base_set(hub->evbase, &signal_events[i]);
if (signal_add(&signal_events[i], NULL)) if (signal_add(&signal_events[i], NULL))
{ {
hub_log(log_error, "Error setting signal handler %d", signals[i]); LOG_ERROR("Error setting signal handler %d", signals[i]);
} }
} }
} }
@ -114,8 +114,8 @@ int main_loop()
{ {
if (hub) if (hub)
{ {
hub_log(log_info, "Reloading configuration files..."); LOG_INFO("Reloading configuration files...");
hub_log(log_debug, "Hub status: %d", (int) hub->status); LOG_DEBUG("Hub status: %d", (int) hub->status);
} }
if (read_config(arg_config, &configuration, !arg_have_config) == -1) if (read_config(arg_config, &configuration, !arg_have_config) == -1)
@ -335,15 +335,15 @@ int drop_privileges()
if (!ret) if (!ret)
{ {
hub_log(log_fatal, "Unable to determine group id, check group name."); LOG_FATAL("Unable to determine group id, check group name.");
return -1; return -1;
} }
hub_log(log_trace, "Setting group id %d (%s)", (int) perm_gid, arg_gid); LOG_TRACE("Setting group id %d (%s)", (int) perm_gid, arg_gid);
ret = setgid(perm_gid); ret = setgid(perm_gid);
if (ret == -1) if (ret == -1)
{ {
hub_log(log_fatal, "Unable to change group id, permission denied."); LOG_FATAL("Unable to change group id, permission denied.");
return -1; return -1;
} }
gid_ok = 1; gid_ok = 1;
@ -368,25 +368,25 @@ int drop_privileges()
if (!ret) if (!ret)
{ {
hub_log(log_fatal, "Unable to determine user id, check user name."); LOG_FATAL("Unable to determine user id, check user name.");
return -1; return -1;
} }
if (!gid_ok) { if (!gid_ok) {
hub_log(log_trace, "Setting group id %d (%s)", (int) perm_gid, arg_gid); LOG_TRACE("Setting group id %d (%s)", (int) perm_gid, arg_gid);
ret = setgid(perm_gid); ret = setgid(perm_gid);
if (ret == -1) if (ret == -1)
{ {
hub_log(log_fatal, "Unable to change group id, permission denied."); LOG_FATAL("Unable to change group id, permission denied.");
return -1; return -1;
} }
} }
hub_log(log_trace, "Setting user id %d (%s)", (int) perm_uid, arg_uid); LOG_TRACE("Setting user id %d (%s)", (int) perm_uid, arg_uid);
ret = setuid(perm_uid); ret = setuid(perm_uid);
if (ret == -1) if (ret == -1)
{ {
hub_log(log_fatal, "Unable to change user id, permission denied."); LOG_FATAL("Unable to change user id, permission denied.");
return -1; return -1;
} }
} }
@ -401,7 +401,7 @@ int pidfile_create()
FILE* pidfile = fopen(arg_pid, "w"); FILE* pidfile = fopen(arg_pid, "w");
if (!pidfile) if (!pidfile)
{ {
hub_log(log_fatal, "Unable to write pid file: %s\n", arg_pid); LOG_FATAL("Unable to write pid file: %s\n", arg_pid);
return -1; return -1;
} }
@ -440,7 +440,7 @@ int main(int argc, char** argv)
ret = fork(); ret = fork();
if (ret == -1) if (ret == -1)
{ {
hub_log(log_fatal, "Unable to fork to background!"); LOG_FATAL("Unable to fork to background!");
return -1; return -1;
} }
else if (ret == 0) else if (ret == 0)
@ -456,7 +456,7 @@ int main(int argc, char** argv)
else else
{ {
/* parent process */ /* parent process */
hub_log(log_debug, "Forked to background\n"); LOG_DEBUG("Forked to background\n");
return 0; return 0;
} }
} }

22
src/core/netevent.c
View File

@ -26,27 +26,27 @@ extern struct hub_info* g_hub;
#ifdef DEBUG_SENDQ #ifdef DEBUG_SENDQ
void debug_sendq_send(struct user* user, int sent, int total) void debug_sendq_send(struct user* user, int sent, int total)
{ {
printf("SEND: sd=%d, %d/%d bytes\n", user->net.sd, sent, total); LOG_DUMP("SEND: sd=%d, %d/%d bytes\n", user->net.sd, sent, total);
if (sent == -1) if (sent == -1)
{ {
int err = net_error(); int err = net_error();
printf(" errno: %d - %s\n", err, net_error_string(err)); LOG_DUMP(" errno: %d - %s\n", err, net_error_string(err));
} }
} }
void debug_sendq_recv(struct user* user, int received, int max, const char* buffer) void debug_sendq_recv(struct user* user, int received, int max, const char* buffer)
{ {
printf("RECV: %d/%d bytes\n", received, (int) max); LOG_DUMP("RECV: %d/%d bytes\n", received, (int) max);
if (received == -1) if (received == -1)
{ {
int err = net_error(); int err = net_error();
printf(" errno: %d - %s\n", err, net_error_string(err)); LOG_DUMP(" errno: %d - %s\n", err, net_error_string(err));
} }
else if (received > 0) else if (received > 0)
{ {
char* data = hub_malloc_zero(received + 1); char* data = hub_malloc_zero(received + 1);
memcpy(data, buffer, received); memcpy(data, buffer, received);
printf("RECV: \"%s\"\n", data); LOG_DUMP("RECV: \"%s\"\n", data);
hub_free(data); hub_free(data);
} }
} }
@ -165,7 +165,7 @@ int handle_net_read(struct user* user)
pos[0] = '\0'; pos[0] = '\0';
#ifdef DEBUG_SENDQ #ifdef DEBUG_SENDQ
printf("PROC: \"%s\" (%d)\n", start, (int) (pos - start)); LOG_DUMP("PROC: \"%s\" (%d)\n", start, (int) (pos - start));
#endif #endif
if (user_flag_get(user, flag_maxbuf)) if (user_flag_get(user, flag_maxbuf))
@ -239,7 +239,7 @@ void net_event(int fd, short ev, void *arg)
int flag_close = 0; int flag_close = 0;
#ifdef DEBUG_SENDQ #ifdef DEBUG_SENDQ
hub_log(log_trace, "net_on_read() : fd=%d, ev=%d, arg=%p", fd, (int) ev, arg); LOG_TRACE("net_on_read() : fd=%d, ev=%d, arg=%p", fd, (int) ev, arg);
#endif #endif
if (ev & EV_TIMEOUT) if (ev & EV_TIMEOUT)
@ -315,7 +315,7 @@ void net_on_accept(int server_fd, short ev, void *arg)
} }
else else
{ {
hub_log(log_error, "Accept error: %d %s", net_error(), strerror(net_error())); LOG_ERROR("Accept error: %d %s", net_error(), strerror(net_error()));
break; break;
} }
} }
@ -323,12 +323,12 @@ void net_on_accept(int server_fd, short ev, void *arg)
addr = ip_convert_to_string(&ipaddr); addr = ip_convert_to_string(&ipaddr);
/* FIXME: Should have a plugin log this */ /* FIXME: Should have a plugin log this */
hub_log(log_trace, "Got connection from %s", addr); LOG_TRACE("Got connection from %s", addr);
/* FIXME: A plugin should perform this check: is IP banned? */ /* FIXME: A plugin should perform this check: is IP banned? */
if (acl_is_ip_banned(hub->acl, addr)) if (acl_is_ip_banned(hub->acl, addr))
{ {
hub_log(log_info, "Denied [%s] (IP banned)", addr); LOG_INFO("Denied [%s] (IP banned)", addr);
net_close(fd); net_close(fd);
continue; continue;
} }
@ -336,7 +336,7 @@ void net_on_accept(int server_fd, short ev, void *arg)
user = user_create(hub, fd); user = user_create(hub, fd);
if (!user) if (!user)
{ {
hub_log(log_error, "Unable to create user after socket accepted. Out of memory?"); LOG_ERROR("Unable to create user after socket accepted. Out of memory?");
net_close(fd); net_close(fd);
break; break;
} }

2
src/core/route.c
View File

@ -93,7 +93,7 @@ int route_to_user(struct hub_info* hub, struct user* user, struct adc_message* m
{ {
#ifdef DEBUG_SENDQ #ifdef DEBUG_SENDQ
char* data = strndup(msg->cache, msg->length-1); char* data = strndup(msg->cache, msg->length-1);
hub_log(log_protocol, "send %s: \"%s\"", sid_to_string(user->id.sid), data); LOG_PROTO("send %s: \"%s\"", sid_to_string(user->id.sid), data);
free(data); free(data);
#endif #endif

12
src/core/user.c
View File

@ -39,7 +39,7 @@ struct user* user_create(struct hub_info* hub, int sd)
{ {
struct user* user = NULL; struct user* user = NULL;
hub_log(log_trace, "user_create(), hub=%p, sd=%d", hub, sd); LOG_TRACE("user_create(), hub=%p, sd=%d", hub, sd);
user = (struct user*) hub_malloc_zero(sizeof(struct user)); user = (struct user*) hub_malloc_zero(sizeof(struct user));
@ -68,7 +68,7 @@ struct user* user_create(struct hub_info* hub, int sd)
void user_destroy(struct user* user) void user_destroy(struct user* user)
{ {
hub_log(log_trace, "user_destroy(), user=%p", user); LOG_TRACE("user_destroy(), user=%p", user);
event_del(&user->net.event); event_del(&user->net.event);
evtimer_del(&user->net.timeout); evtimer_del(&user->net.timeout);
@ -173,7 +173,7 @@ static int convert_support_fourcc(int fourcc)
return feature_link; return feature_link;
default: default:
hub_log(log_debug, "Unknown extension: %x", fourcc); LOG_DEBUG("Unknown extension: %x", fourcc);
return 0; return 0;
} }
} }
@ -330,7 +330,7 @@ int user_is_registered(struct user* user)
void user_net_io_want_write(struct user* user) void user_net_io_want_write(struct user* user)
{ {
#ifdef DEBUG_SENDQ #ifdef DEBUG_SENDQ
hub_log(log_trace, "user_net_io_want_write: %s (pending: %d)", user_log_str(user), event_pending(&user->net.event, EV_READ | EV_WRITE, 0)); LOG_TRACE("user_net_io_want_write: %s (pending: %d)", user_log_str(user), event_pending(&user->net.event, EV_READ | EV_WRITE, 0));
#endif #endif
if (event_pending(&user->net.event, EV_READ | EV_WRITE, 0) == (EV_READ | EV_WRITE)) if (event_pending(&user->net.event, EV_READ | EV_WRITE, 0) == (EV_READ | EV_WRITE))
return; return;
@ -342,7 +342,7 @@ void user_net_io_want_write(struct user* user)
void user_net_io_want_read(struct user* user) void user_net_io_want_read(struct user* user)
{ {
#ifdef DEBUG_SENDQ #ifdef DEBUG_SENDQ
hub_log(log_trace, "user_net_io_want_read: %s (pending: %d)", user_log_str(user), event_pending(&user->net.event, EV_READ | EV_WRITE, 0)); LOG_TRACE("user_net_io_want_read: %s (pending: %d)", user_log_str(user), event_pending(&user->net.event, EV_READ | EV_WRITE, 0));
#endif #endif
if (event_pending(&user->net.event, EV_READ | EV_WRITE, 0) == EV_READ) if (event_pending(&user->net.event, EV_READ | EV_WRITE, 0) == EV_READ)
return; return;
@ -364,7 +364,7 @@ void user_reset_last_read(struct user* user)
void user_set_timeout(struct user* user, int seconds) void user_set_timeout(struct user* user, int seconds)
{ {
#ifdef DEBUG_SENDQ #ifdef DEBUG_SENDQ
hub_log(log_trace, "user_set_timeout to %d seconds: %s", seconds, user_log_str(user)); LOG_TRACE("user_set_timeout to %d seconds: %s", seconds, user_log_str(user));
#endif #endif
struct timeval timeout = { seconds, 0 }; struct timeval timeout = { seconds, 0 };
evtimer_add(&user->net.timeout, &timeout); evtimer_add(&user->net.timeout, &timeout);

2
src/core/usermanager.c
View File

@ -61,7 +61,7 @@ void uman_update_stats(struct hub_info* hub)
void uman_print_stats(struct hub_info* hub) void uman_print_stats(struct hub_info* hub)
{ {
hub_log(log_info, "Statistics users=%zu (peak_users=%zu), net_tx=%d KB/s, net_rx=%d KB/s (peak_tx=%d KB/s, peak_rx=%d KB/s)", LOG_INFO("Statistics users=%zu (peak_users=%zu), net_tx=%d KB/s, net_rx=%d KB/s (peak_tx=%d KB/s, peak_rx=%d KB/s)",
hub->users->count, hub->users->count,
hub->users->count_peak, hub->users->count_peak,
(int) hub->stats.net_tx / 1024, (int) hub->stats.net_tx / 1024,

326
src/network/network-epoll.c
View File

@ -1,326 +0,0 @@
/*
* uhub - A tiny ADC p2p connection hub
* Copyright (C) 2007, Jan Vidar Krey
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "uhub.h"
#ifdef HAVE_EPOLL
// #define DEBUG_EPOLL
static struct epoll_event* events = 0;
static int epfd = -1;
#ifdef DEBUG_EPOLL
static void dump_listeners()
{
int i;
struct net_event_listener* listener;
hub_log(log_dump, "listeners: number=%d", num_connections);
for (i = 0; i < num_connections; i++)
{
listener = &listeners[i];
if (listener)
{
if (listener->fd != -1)
{
hub_log(log_dump, "epoll_dump_listeners: pos=%d/%d fd=%d, ptr=%p", i, num_connections, listeners->fd, listeners);
}
else
{
hub_log(log_dump, "epoll_dump_listeners: pos=%d/%d (unused)", i, num_connections);
}
listener = 0;
}
}
getc(stdin);
}
#endif
static void set_poll_events(struct epoll_event* handle, short trigger)
{
memset(handle, 0, sizeof(struct epoll_event));
if (trigger & evt_accept || trigger & evt_read || trigger & evt_close)
handle->events |= EPOLLIN;
if (trigger & evt_write)
handle->events |= EPOLLOUT;
if (trigger & evt_urgent)
handle->events |= EPOLLPRI;
#ifdef EPOLLRDHUP
if (triggers & evt_close)
handle->events |= EPOLLRDHUP;
#endif
}
static short get_poll_events(struct epoll_event* handle)
{
short trig = handle->events;
short evt = 0;
if (trig & EPOLLIN)
evt |= evt_read;
if (trig & EPOLLPRI)
evt |= evt_urgent;
if (trig & EPOLLOUT)
evt |= evt_write;
if (trig & EPOLLHUP)
evt |= evt_close;
if (trig & EPOLLERR)
evt |= evt_error;
#ifdef EPOLLRDHUP
if (trig & EPOLLRDHUP)
evt |= evt_close;
#endif
return evt;
}
int net_initialize(int capacity)
{
int i;
max_connections = capacity;
num_connections = 0;
epfd = epoll_create(max_connections);
if (epfd == -1)
{
hub_log(log_error, "net_initialize(): epoll_create failed");
return -1;
}
events = hub_malloc_zero(sizeof(struct epoll_event) * max_connections);
if (!events)
{
hub_log(log_error, "net_initialize(): hub_malloc failed");
return -1;
}
monitor_allocate((size_t) capacity);
#ifdef DEBUG_EPOLL
dump_listeners();
#endif
net_stats_initialize();
return 0;
}
int net_shutdown()
{
hub_log(log_trace, "Shutting down network monitor");
if (epfd != -1)
{
close(epfd);
}
hub_free(events);
hub_free(listeners);
return 0;
}
#ifdef DEBUG_EPOLL
uint64_t get_time_difference_in_msec(struct timeval before, struct timeval after)
{
uint64_t seconds = (after.tv_sec - before.tv_sec);
uint64_t out = seconds*1000;
if (seconds > 0)
out += ((after.tv_usec / 1000) + (1000 - (before.tv_usec / 1000)));
else
out += ((after.tv_usec - before.tv_usec) / 1000);
return out;
}
#endif
int net_wait(int timeout_ms)
{
int fired, n, max, ret;
struct net_event_listener* listener;
#ifdef DEBUG_EPOLL
struct timeval tm_before;
struct timeval tm_after;
gettimeofday(&tm_before, NULL);
dump_listeners();
#endif
fired = epoll_wait(epfd, events, num_connections, timeout_ms);
if (fired == -1) {
if (errno != EINTR)
{
hub_log(log_error, "net_wait(): epoll_wait failed");
}
return -1;
}
for (n = 0; n < fired; n++)
{
listener = (struct net_event_listener*) events[n].data.ptr;
listener->revents = get_poll_events(&events[n]);
hub_log(log_dump, "net_wait(): epoll event detected (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
}
max = num_connections;
for (n = 0; n < max; n++)
{
listener = &listeners[n];
if (listener && listener->fd != -1 && listener->revents)
{
hub_log(log_dump, "net_wait(): epoll trigger call (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
ret = listener->handler(listener);
listener->revents = 0;
}
#ifdef DEBUG_EPOLL
else
{
if (listener)
hub_log(log_dump, "net_wait(): epoll trigger ignore (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
}
#endif
}
#ifdef DEBUG_EPOLL
gettimeofday(&tm_after, NULL);
size_t diff = (size_t) get_time_difference_in_msec(tm_before, tm_after);
dump_listeners();
hub_log(log_debug, "net_wait(): time=%dms, triggered=%d", diff, fired);
#endif
return 0;
}
int net_add(int fd, short events, void* data, net_event_handler_t handler)
{
struct epoll_event ev;
struct net_event_listener* listener = monitor_get_free_listener();
hub_log(log_trace, "net_add(): adding socket (fd=%d, pos=%d)", fd, pos);
if (!listener)
{
hub_log(log_error, "net_add(): unable to poll more sockets");
return -1;
}
net_event_listener_set(listener, fd, events, data, handler);
set_poll_events(&ev, events);
ev.data.ptr = listener;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) < 0)
{
hub_log(log_error, "net_add(): epoll_ctl error while adding socket (fd=%d)", fd);
net_event_listener_clear(listener);
return -1;
}
num_connections++;
#ifdef DEBUG_EPOLL
dump_listeners();
#endif
return 0;
}
int net_modify(int fd, short events)
{
struct epoll_event ev;
struct net_event_listener* listener = monitor_get_listener(fd);
hub_log(log_trace, "net_modify(): modifying socket events (fd=%d)", fd);
if (!listener)
{
hub_log(log_error, "net_modify(): unable to find socket.");
return -1;
}
listener->events = events;
set_poll_events(&ev, events);
ev.data.ptr = listener;
if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) < 0)
{
hub_log(log_error, "net_add(): epoll_ctl error while modifying socket (fd=%d)", fd);
return -1;
}
#ifdef DEBUG_EPOLL
dump_listeners();
#endif
return 0;
}
int net_remove(int fd)
{
struct epoll_event ev;
struct net_event_listener* listener = monitor_get_listener(fd);
hub_log(log_trace, "net_remove(): removing socket (fd=%d, pos=%d)", fd, pos);
if (!listener)
{
/* The socket is not being monitored */
hub_log(log_error, "net_remove(): unable to remove socket (fd=%d)", fd);
return -1;
}
net_event_listener_clear(listener);
if (epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev) < 0)
{
hub_log(log_error, "net_remove(): epoll_ctl error while removing socket (fd=%d)", fd);
return -1;
}
num_connections--;
#ifdef DEBUG_EPOLL
dump_listeners();
#endif
return 0;
}
#endif /* HAVE_EPOLL */

290
src/network/network-kqueue.c
View File

@ -1,290 +0,0 @@
/*
* uhub - A tiny ADC p2p connection hub
* Copyright (C) 2007-2009, Jan Vidar Krey
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "uhub.h"
#ifdef HAVE_KQUEUE
static struct kevent* events = 0;
static struct kevent* change = 0;
static int kfd = -1;
static void set_poll_events(struct kevent* handle, short trigger)
{
if (!handle) {
hub_log(log_error, "OOOPS!!");
return;
}
memset(handle, 0, sizeof(struct kevent));
if (trigger & evt_accept || trigger & evt_read || trigger & evt_close)
handle->filter |= EVFILT_READ;
if (trigger & evt_write /* || trigger & evt_accept*/)
handle->filter |= EVFILT_WRITE;
}
static short get_poll_events(struct kevent* handle)
{
short trig = handle->flags;
short evt = 0;
if (trig & EVFILT_READ)
evt |= evt_read;
if (trig & EVFILT_WRITE)
evt |= evt_write;
if (trig & EV_EOF)
{
evt |= evt_close;
if (handle->fflags)
evt |= evt_error;
}
if (handle->filter == -1)
{
evt |= evt_error;
}
if (handle->data)
{
evt |= evt_accept;
}
if (evt)
{
hub_log(log_error, "Evt: fd=%d, filter=%d, flags=%d, fflags=%d, data=%d evt=%#x", handle->ident, handle->filter, handle->flags, handle->fflags, (int) handle->data, evt);
}
return evt;
}
int net_initialize(int capacity)
{
int i;
max_connections = capacity;
num_connections = 0;
kfd = kqueue();
if (kfd == -1)
{
hub_log(log_error, "net_initialize(): kqueue failed");
return -1;
}
events = (void*) hub_malloc_zero(sizeof(struct kevent) * max_connections);
if (!events)
{
hub_log(log_error, "net_initialize(): hub_malloc failed");
return -1;
}
change = (void*) hub_malloc_zero(sizeof(struct kevent) * max_connections);
if (!events)
{
hub_log(log_error, "net_initialize(): hub_malloc failed");
hub_free(events);
return -1;
}
listeners = (void*) hub_malloc_zero(sizeof(struct net_event_listener) * max_connections);
if (!listeners)
{
hub_log(log_error, "net_initialize(): hub_malloc failed");
hub_free(change);
hub_free(events);
return -1;
}
for (i = 0; i < max_connections; i++)
{
listeners[i].fd = -1;
}
net_stats_initialize();
return 0;
}
int net_shutdown()
{
if (kfd != -1) {
return close(kfd);
}
hub_free(events);
hub_free(change);
hub_free(listeners);
return 0;
}
int net_wait(int timeout_ms)
{
int fired, n, max, ret;
struct net_event_listener* listener;
struct timespec timeout = { (timeout_ms / 1000), (timeout_ms % 1000) * 1000 };
fired = kevent(kfd, events, num_connections, change, num_connections, &timeout);
if (fired == -1) {
if (errno != EINTR)
{
hub_log(log_error, "net_wait(): kevent failed");
}
return -1;
}
for (n = 0; n < fired; n++)
{
listener = (struct net_event_listener*) events[n].udata;
if (listener)
{
listener->revents = get_poll_events(&events[n]);
hub_log(log_dump, "net_wait(): kqueue event detected (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
}
}
max = num_connections;
for (n = 0; n < max; n++)
{
listener = &listeners[n];
if (listener && listener->fd != -1 && listener->revents != 0)
{
hub_log(log_dump, "net_wait(): kqueue trigger call (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
ret = listener->handler(listener);
listener->revents = 0;
}
}
return 0;
}
int net_add(int fd, short events_, void* data, net_event_handler_t handler)
{
struct kevent* event;
struct net_event_listener* listener = monitor_get_listener(fd);
hub_log(log_trace, "net_add(): adding socket (fd=%d)", fd);
if (listener)
{
/* Already added! */
return -1;
}
listener = monitor_get_free_listener();
if (!listener)
{
hub_log(log_error, "net_add(): unable to poll more sockets");
return -1;
}
net_event_listener_set(listener, fd, events_, data, handler);
event = &events[pos];
set_poll_events(event, events_);
event->ident = fd;
event->flags |= EV_ADD;
event->flags |= EV_ONESHOT;
#ifdef __APPLE__
event->flags |= EV_ENABLE;
#endif
event->udata = listener;
num_connections++;
return 0;
}
int net_modify(int fd, short events_)
{
struct kevent* event;
struct net_event_listener* listener = monitor_get_listener(fd);
hub_log(log_trace, "net_modify(): modifying socket (fd=%d)", fd);
if (!listener)
{
/* The socket is not being monitored */
hub_log(log_error, "net_modify(): unable to find socket (fd=%d)", fd);
return -1;
}
event = &events[pos];
// set_poll_events(event, events_);
event->ident = fd;
event->flags |= EV_ADD;
event->flags |= EV_ONESHOT;
#ifdef __APPLE__
event->flags |= EV_ENABLE;
#endif
return 0;
}
int net_remove(int fd)
{
struct kevent* event;
struct net_event_listener* listener = monitor_get_listener(fd);
hub_log(log_trace, "net_remove(): removing socket (fd=%d)", fd);
if (!listener)
{
/* The socket is not being monitored */
hub_log(log_error, "net_remove(): unable to remove socket (fd=%d)", fd);
return -1;
}
net_event_listener_clear(listener);
event = &events[pos];
event->ident = fd;
event->filter = 0;
event->flags = EV_DELETE;
#ifdef __APPLE__
event->flasg |= EV_DISABLE;
#endif
event->fflags = 0;
event->data = 0;
event->udata = 0;
num_connections--;
return 0;
}
#endif /* HAVE_KQUEUE */

16
src/network/network.c
View File

@ -40,16 +40,16 @@ int net_initialize()
struct WSAData wsa; struct WSAData wsa;
if (WSAStartup(MAKEWORD(2, 2), &wsa) != NO_ERROR) if (WSAStartup(MAKEWORD(2, 2), &wsa) != NO_ERROR)
{ {
hub_log(log_error, "Unable to initialize winsock."); LOG_ERROR("Unable to initialize winsock.");
return -1; return -1;
} }
#endif /* WINSOCK */ #endif /* WINSOCK */
hub_log(log_trace, "Initializing network monitor."); LOG_TRACE("Initializing network monitor.");
net_stats_initialize(); net_stats_initialize();
#ifdef SSL_SUPPORT #ifdef SSL_SUPPORT
hub_log(log_trace, "Initializing OpenSSL..."); LOG_TRACE("Initializing OpenSSL...");
SSL_load_error_strings(); SSL_load_error_strings();
SSL_library_init(); SSL_library_init();
OpenSSL_add_all_algorithms(); OpenSSL_add_all_algorithms();
@ -66,7 +66,7 @@ int net_destroy()
{ {
if (net_initialized) if (net_initialized)
{ {
hub_log(log_trace, "Shutting down network monitor"); LOG_TRACE("Shutting down network monitor");
#ifdef SSL_SUPPORT #ifdef SSL_SUPPORT
/* FIXME: Shutdown OpenSSL here. */ /* FIXME: Shutdown OpenSSL here. */
@ -84,7 +84,7 @@ int net_destroy()
static void net_error_out(int fd, const char* func) static void net_error_out(int fd, const char* func)
{ {
int err = net_error(); int err = net_error();
hub_log(log_error, "%s, fd=%d: %s (%d)", func, fd, net_error_string(err), err); LOG_ERROR("%s, fd=%d: %s (%d)", func, fd, net_error_string(err), err);
} }
int net_error() int net_error()
@ -379,7 +379,7 @@ int net_is_ipv6_supported()
if (net_error() == EAFNOSUPPORT) if (net_error() == EAFNOSUPPORT)
#endif #endif
{ {
hub_log(log_trace, "net_is_ipv6_supported(): IPv6 is not supported on this system."); LOG_TRACE("net_is_ipv6_supported(): IPv6 is not supported on this system.");
is_ipv6_supported = 0; is_ipv6_supported = 0;
return 0; return 0;
} }
@ -392,7 +392,7 @@ int net_is_ipv6_supported()
int off = 0; int off = 0;
if (net_setsockopt(ret, IPPROTO_IPV6, SOCK_DUAL_STACK_OPT, (char*) &off, sizeof(off)) < 0) if (net_setsockopt(ret, IPPROTO_IPV6, SOCK_DUAL_STACK_OPT, (char*) &off, sizeof(off)) < 0)
{ {
hub_log(log_error, "net_socket_create(): Dual stack IPv6/IPv4 is not supported."); LOG_ERROR("net_socket_create(): Dual stack IPv6/IPv4 is not supported.");
is_ipv6_supported = 0; is_ipv6_supported = 0;
} }
else else
@ -424,7 +424,7 @@ int net_socket_create(int af, int type, int protocol)
int off = 0; int off = 0;
if (net_setsockopt(sd, IPPROTO_IPV6, SOCK_DUAL_STACK_OPT, (char*) &off, sizeof(off)) < 0) if (net_setsockopt(sd, IPPROTO_IPV6, SOCK_DUAL_STACK_OPT, (char*) &off, sizeof(off)) < 0)
{ {
hub_log(log_error, "net_socket_create(): Cannot set socket to dual stack mode IPv6/IPv4 (%d - %s).", net_error(), net_error_string(net_error())); LOG_ERROR("net_socket_create(): Cannot set socket to dual stack mode IPv6/IPv4 (%d - %s).", net_error(), net_error_string(net_error()));
} }
} }
#endif #endif

20
src/uhub.h
View File

@ -157,23 +157,25 @@
extern "C" { extern "C" {
#endif #endif
#include "util/memory.h"
#include "util/misc.h"
#include "core/eventid.h"
#include "core/eventqueue.h"
#include "util/ipcalc.h" #include "util/ipcalc.h"
#include "util/list.h" #include "util/list.h"
#include "util/log.h"
#include "util/memory.h"
#include "util/misc.h"
#include "util/tiger.h"
#include "adc/sid.h" #include "adc/sid.h"
#include "adc/message.h"
#include "network/network.h" #include "network/network.h"
#include "core/auth.h"
#include "core/config.h"
#include "core/eventid.h"
#include "core/eventqueue.h"
#include "core/netevent.h" #include "core/netevent.h"
#include "core/hubio.h" #include "core/hubio.h"
#include "core/auth.h"
#include "util/tiger.h"
#include "core/config.h"
#include "util/log.h"
#include "core/user.h" #include "core/user.h"
#include "core/usermanager.h" #include "core/usermanager.h"
#include "adc/message.h"
#include "core/route.h" #include "core/route.h"
#include "core/hub.h" #include "core/hub.h"
#include "core/commands.h" #include "core/commands.h"

10
src/util/ipcalc.c
View File

@ -147,7 +147,7 @@ int ip_convert_address(const char* text_address, int port, struct sockaddr* addr
addr6.sin6_port = htons(port); addr6.sin6_port = htons(port);
if (net_string_to_address(AF_INET6, taddr, &addr6.sin6_addr) <= 0) if (net_string_to_address(AF_INET6, taddr, &addr6.sin6_addr) <= 0)
{ {
hub_log(log_fatal, "Unable to convert socket address (ipv6)"); LOG_ERROR("Unable to convert socket address (ipv6)");
return 0; return 0;
} }
@ -163,7 +163,7 @@ int ip_convert_address(const char* text_address, int port, struct sockaddr* addr
addr4.sin_port = htons(port); addr4.sin_port = htons(port);
if (net_string_to_address(AF_INET, taddr, &addr4.sin_addr) <= 0) if (net_string_to_address(AF_INET, taddr, &addr4.sin_addr) <= 0)
{ {
hub_log(log_fatal, "Unable to convert socket address (ipv4)"); LOG_ERROR("Unable to convert socket address (ipv4)");
return 0; return 0;
} }
memcpy(addr, &addr4, sockaddr_size); memcpy(addr, &addr4, sockaddr_size);
@ -219,7 +219,7 @@ int ip_mask_create_left(int af, int bits, struct ip_addr_encap* result)
#ifdef IP_CALC_DEBUG #ifdef IP_CALC_DEBUG
char* r_str = hub_strdup(ip_convert_to_string(result)); char* r_str = hub_strdup(ip_convert_to_string(result));
hub_log(log_debug, "Created left mask: %s", r_str); LOG_DUMP("Created left mask: %s", r_str);
hub_free(r_str); hub_free(r_str);
#endif #endif
@ -272,7 +272,7 @@ int ip_mask_create_right(int af, int bits, struct ip_addr_encap* result)
#ifdef IP_CALC_DEBUG #ifdef IP_CALC_DEBUG
char* r_str = hub_strdup(ip_convert_to_string(result)); char* r_str = hub_strdup(ip_convert_to_string(result));
hub_log(log_debug, "Created right mask: %s", r_str); LOG_DUMP("Created right mask: %s", r_str);
hub_free(r_str); hub_free(r_str);
#endif #endif
@ -405,7 +405,7 @@ int ip_compare(struct ip_addr_encap* a, struct ip_addr_encap* b)
#ifdef IP_CALC_DEBUG #ifdef IP_CALC_DEBUG
char* a_str = hub_strdup(ip_convert_to_string(a)); char* a_str = hub_strdup(ip_convert_to_string(a));
char* b_str = hub_strdup(ip_convert_to_string(b)); char* b_str = hub_strdup(ip_convert_to_string(b));
hub_log(log_debug, "Comparing IPs '%s' AND '%s' => %d", a_str, b_str, ret); LOG_DUMP("Comparing IPs '%s' AND '%s' => %d", a_str, b_str, ret);
hub_free(a_str); hub_free(a_str);
hub_free(b_str); hub_free(b_str);
#endif #endif

25
src/util/log.h
View File

@ -33,6 +33,31 @@ enum log_verbosity {
log_protocol = 9, log_protocol = 9,
}; };
#define LOG_FATAL(format, ...) hub_log(log_fatal, format, ## __VA_ARGS__)
#define LOG_ERROR(format, ...) hub_log(log_error, format, ## __VA_ARGS__)
#define LOG_WARN(format, ...) hub_log(log_warning, format, ## __VA_ARGS__)
#define LOG_USER(format, ...) hub_log(log_user, format, ## __VA_ARGS__)
#define LOG_INFO(format, ...) hub_log(log_info, format, ## __VA_ARGS__)
#ifdef DEBUG
# define LOG_DEBUG(format, ...) hub_log(log_debug, format, ## __VA_ARGS__)
# define LOG_TRACE(format, ...) hub_log(log_trace, format, ## __VA_ARGS__)
#else
# define LOG_DEBUG(format, ...) do { } while(0)
# define LOG_TRACE(format, ...) do { } while(0)
#endif
#ifdef LOWLEVEL_DEBUG
# define LOG_DUMP(format, ...) hub_log(log_dump, format, ## __VA_ARGS__)
# define LOG_MEMORY(format, ...) hub_log(log_memory, format, ## __VA_ARGS__)
# define LOG_PROTO(format, ...) hub_log(log_protocol, format, ## __VA_ARGS__)
#else
# define LOG_DUMP(format, ...) do { } while(0)
# define LOG_MEMORY(format, ...) do { } while(0)
# define LOG_PROTO(format, ...) do { } while(0)
#endif
/** /**
* Specify a minimum log verbosity for what messages should * Specify a minimum log verbosity for what messages should
* be printed in the log. * be printed in the log.

16
src/util/memory.c
View File

@ -47,7 +47,7 @@ void internal_debug_print_leaks()
size_t n = 0; size_t n = 0;
size_t leak = 0; size_t leak = 0;
size_t count = 0; size_t count = 0;
hub_log(log_memory, "--- exit (allocs: %d, size: %zu) ---", hub_alloc_count, hub_alloc_size); LOG_MEMORY("--- exit (allocs: %d, size: %zu) ---", hub_alloc_count, hub_alloc_size);
for (; n < UHUB_MAX_ALLOCS; n++) for (; n < UHUB_MAX_ALLOCS; n++)
{ {
@ -55,11 +55,11 @@ void internal_debug_print_leaks()
{ {
leak += hub_allocs[n].size; leak += hub_allocs[n].size;
count++; count++;
hub_log(log_memory, "leak %p size: %zu (bt: %p %p)", hub_allocs[n].ptr, hub_allocs[n].size, hub_allocs[n].stack1, hub_allocs[n].stack2); LOG_MEMORY("leak %p size: %zu (bt: %p %p)", hub_allocs[n].ptr, hub_allocs[n].size, hub_allocs[n].stack1, hub_allocs[n].stack2);
} }
} }
hub_log(log_memory, "--- done (allocs: %d, size: %zu, peak: %d/%zu, oom: %zu) ---", count, leak, hub_alloc_peak_count, hub_alloc_peak_size, hub_alloc_oom); LOG_MEMORY("--- done (allocs: %d, size: %zu, peak: %d/%zu, oom: %zu) ---", count, leak, hub_alloc_peak_count, hub_alloc_peak_size, hub_alloc_oom);
} }
#endif /* REALTIME_MALLOC_TRACKING */ #endif /* REALTIME_MALLOC_TRACKING */
@ -73,7 +73,7 @@ void* internal_debug_mem_malloc(size_t size, const char* where)
/* Make sure the malloc info struct is initialized */ /* Make sure the malloc info struct is initialized */
if (!hub_alloc_count) if (!hub_alloc_count)
{ {
hub_log(log_memory, "--- start ---"); LOG_MEMORY("--- start ---");
for (n = 0; n < UHUB_MAX_ALLOCS; n++) for (n = 0; n < UHUB_MAX_ALLOCS; n++)
{ {
hub_allocs[n].ptr = 0; hub_allocs[n].ptr = 0;
@ -107,14 +107,14 @@ void* internal_debug_mem_malloc(size_t size, const char* where)
hub_alloc_peak_count = MAX(hub_alloc_count, hub_alloc_peak_count); hub_alloc_peak_count = MAX(hub_alloc_count, hub_alloc_peak_count);
hub_alloc_peak_size = MAX(hub_alloc_size, hub_alloc_peak_size); hub_alloc_peak_size = MAX(hub_alloc_size, hub_alloc_peak_size);
hub_log(log_memory, "%s %p (%d bytes) (bt: %p %p) {allocs: %d, size: %zu}", where, ptr, (int) size, hub_allocs[n].stack1, hub_allocs[n].stack2, hub_alloc_count, hub_alloc_size); LOG_MEMORY("%s %p (%d bytes) (bt: %p %p) {allocs: %d, size: %zu}", where, ptr, (int) size, hub_allocs[n].stack1, hub_allocs[n].stack2, hub_alloc_count, hub_alloc_size);
break; break;
} }
} }
} }
else else
{ {
hub_log(log_memory, "%s *** OOM for %d bytes", where, size); LOG_MEMORY("%s *** OOM for %d bytes", where, size);
hub_alloc_oom++; hub_alloc_oom++;
return 0; return 0;
} }
@ -141,7 +141,7 @@ void internal_debug_mem_free(void* ptr)
hub_allocs[n].size = 0; hub_allocs[n].size = 0;
hub_allocs[n].stack1 = 0; hub_allocs[n].stack1 = 0;
hub_allocs[n].stack2 = 0; hub_allocs[n].stack2 = 0;
hub_log(log_memory, "free %p (bt: %p %p) {allocs: %d, size: %zu}", ptr, stack1, stack2, hub_alloc_count, hub_alloc_size); LOG_MEMORY("free %p (bt: %p %p) {allocs: %d, size: %zu}", ptr, stack1, stack2, hub_alloc_count, hub_alloc_size);
malloc_slot = n; malloc_slot = n;
free(ptr); free(ptr);
return; return;
@ -150,7 +150,7 @@ void internal_debug_mem_free(void* ptr)
malloc_slot = -1; malloc_slot = -1;
abort(); abort();
hub_log(log_memory, "free %p *** NOT ALLOCATED *** (bt: %p %p)", ptr, stack1, stack2); LOG_MEMORY("free %p *** NOT ALLOCATED *** (bt: %p %p)", ptr, stack1, stack2);
#else #else
free(ptr); free(ptr);
#endif /* REALTIME_MALLOC_TRACKING */ #endif /* REALTIME_MALLOC_TRACKING */

12
src/util/misc.c
View File

@ -179,26 +179,26 @@ int file_read_lines(const char* file, void* data, file_line_handler_t handler)
memset(buf, 0, MAX_RECV_BUF); memset(buf, 0, MAX_RECV_BUF);
hub_log(log_trace, "Opening file %s for line reading.", file); LOG_TRACE("Opening file %s for line reading.", file);
fd = open(file, 0); fd = open(file, 0);
if (fd == -1) if (fd == -1)
{ {
hub_log(log_error, "Unable to open file %s: %s", file, strerror(errno)); LOG_ERROR("Unable to open file %s: %s", file, strerror(errno));
return -2; return -2;
} }
ret = read(fd, buf, MAX_RECV_BUF); ret = read(fd, buf, MAX_RECV_BUF);
if (ret < 0) if (ret < 0)
{ {
hub_log(log_error, "Unable to read from file %s: %s", file, strerror(errno)); LOG_ERROR("Unable to read from file %s: %s", file, strerror(errno));
close(fd); close(fd);
return -1; return -1;
} }
else if (ret == 0) else if (ret == 0)
{ {
close(fd); close(fd);
hub_log(log_warning, "File is empty."); LOG_WARN("File is empty.");
return 0; return 0;
} }
else else
@ -212,7 +212,7 @@ int file_read_lines(const char* file, void* data, file_line_handler_t handler)
pos[0] = '\0'; pos[0] = '\0';
if (*start) if (*start)
{ {
hub_log(log_dump, "Line: %s", start); LOG_DUMP("Line: %s", start);
if (handler(start, line_count+1, data) < 0) if (handler(start, line_count+1, data) < 0)
return -1; return -1;
} }
@ -223,7 +223,7 @@ int file_read_lines(const char* file, void* data, file_line_handler_t handler)
if (*start) if (*start)
{ {
buf[strlen(start)] = 0; buf[strlen(start)] = 0;
hub_log(log_dump, "Line: %s", start); LOG_DUMP("Line: %s", start);
if (handler(start, line_count+1, data) < 0) if (handler(start, line_count+1, data) < 0)
return -1; return -1;
} }

2
version.h
View File

@ -9,7 +9,7 @@
#endif #endif
#ifndef VERSION #ifndef VERSION
#define VERSION "0.3.0-rc3" REVISION #define VERSION "0.3.0-rc4" REVISION
#endif #endif
#ifndef COPYRIGHT #ifndef COPYRIGHT