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))
{
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);
return 0;
}
@ -268,7 +268,7 @@ struct adc_message* adc_msg_parse(const char* line, size_t 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);
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);
/* hub_log(log_trace, " length=%d", (int) (temp_len)); */
endlen = strlen(end);
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);
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;
}
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 0;
@ -82,7 +82,7 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
data = strip_white_space(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;
}
@ -90,7 +90,7 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
if (!info)
{
hub_log(log_error, "ACL parse error. Out of memory!");
LOG_ERROR("ACL parse error. Out of memory!");
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->status = status;
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 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->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);
}
@ -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)
{
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) ||
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);
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;
}
@ -202,7 +202,7 @@ static int check_cmd_addr(const char* cmd, struct linked_list* list, char* line,
if (!info)
{
hub_log(log_error, "ACL parse error. Out of memory!");
LOG_ERROR("ACL parse error. Out of memory!");
return -1;
}
@ -269,20 +269,16 @@ static int acl_parse_line(char* line, int line_count, void* ptr_data)
if (!*line)
return 0;
#ifdef ACL_DEBUG
hub_log(log_trace, "acl_parse_line(): '%s'", line);
#endif
LOG_DEBUG("acl_parse_line(): '%s'", line);
line = strip_white_space(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;
}
#ifdef ACL_DEBUG
hub_log(log_trace, "acl_parse_line: '%s'", line);
#endif
LOG_DEBUG("acl_parse_line: '%s'", line);
ACL_ADD_USER("bot", handle->users, cred_bot);
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("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;
}
@ -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)
{
hub_log(log_fatal, "acl_initialize: Out of memory");
LOG_FATAL("acl_initialize: Out of memory");
list_destroy(handle->users);
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));
if (!info)
{
hub_log(log_error, "ACL error: Out of memory!");
LOG_ERROR("ACL error: Out of memory!");
return -1;
}
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));
if (!info)
{
hub_log(log_error, "ACL error: Out of memory!");
LOG_ERROR("ACL error: Out of memory!");
return -1;
}
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\
{ \
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; \
} \
TARGET |= 0x80000000; \
@ -65,7 +65,7 @@
errno = 0; \
val = strtol(data, &endptr, 10); \
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; \
} \
TARGET = val; \
@ -103,7 +103,7 @@
#define IGNORED(NAME) \
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; \
} \
@ -304,7 +304,7 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
GET_STR (tls_private_key);
/* Still here -- unknown directive */
hub_log(log_fatal, "Unknown configuration directive: '%s'", key);
LOG_ERROR("Unknown configuration directive: '%s'", key);
return -1;
}
@ -460,13 +460,11 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
if (!*line) return 0;
#ifdef CONFIG_DUMP
hub_log(log_trace, "config_parse_line(): '%s'", line);
#endif
LOG_DUMP("config_parse_line(): '%s'", 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)
@ -486,13 +484,11 @@ static int config_parse_line(char* line, int line_count, void* ptr_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;
}
#ifdef CONFIG_DUMP
hub_log(log_trace, "config_parse_line: '%s' => '%s'", key, data);
#endif
LOG_DUMP("config_parse_line: '%s' => '%s'", key, data);
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)
{
hub_log(log_debug, "Using default configuration.");
LOG_DUMP("Using default configuration.");
}
else
{

4
src/core/eventqueue.c
View File

@ -22,7 +22,7 @@
#ifdef EQ_DEBUG
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
@ -130,7 +130,7 @@ void event_queue_post(struct event_queue* queue, struct event_data* message)
}
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;
#define NETWORK_DUMP_DEBUG 1
int hub_handle_message(struct hub_info* hub, struct user* u, const char* line, size_t length)
{
int ret = 0;
struct adc_message* cmd = 0;
#ifdef NETWORK_DUMP_DEBUG
hub_log(log_protocol, "recv %s: %s", sid_to_string(u->id.sid), line);
#endif
LOG_PROTO("recv %s: %s", sid_to_string(u->id.sid), line);
if (user_is_disconnecting(u))
return -1;
@ -399,7 +395,7 @@ struct hub_info* hub_start_service(struct hub_config* config)
hub = hub_malloc_zero(sizeof(struct hub_info));
if (!hub)
{
hub_log(log_fatal, "Unable to allocate memory for hub");
LOG_FATAL("Unable to allocate memory for hub");
return 0;
}
@ -408,9 +404,9 @@ struct hub_info* hub_start_service(struct hub_config* config)
ipv6_supported = net_is_ipv6_supported();
if (ipv6_supported)
hub_log(log_debug, "IPv6 supported.");
LOG_DEBUG("IPv6 supported.");
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)
{
@ -435,13 +431,13 @@ struct hub_info* hub_start_service(struct hub_config* config)
#endif
if (!hub->evbase)
{
hub_log(log_error, "Unable to initialize libevent.");
LOG_ERROR("Unable to initialize libevent.");
hub_free(hub);
return 0;
}
hub_log(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_INFO("Starting " PRODUCT "/" VERSION ", listening on %s:%d...", address_buf, config->server_port);
LOG_DEBUG("Using libevent %s, backend: %s", event_get_version(), event_get_method());
server_tcp = net_socket_create(af, SOCK_STREAM, IPPROTO_TCP);
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);
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);
hub_free(hub);
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);
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);
hub_free(hub);
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)
{
hub_log(log_trace, "hub_shutdown_service()");
LOG_TRACE("hub_shutdown_service()");
event_queue_shutdown(hub->queue);
event_del(&hub->ev_accept);
@ -903,7 +899,7 @@ void hub_event_loop(struct hub_info* hub)
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)
@ -937,7 +933,7 @@ void hub_disconnect_user(struct hub_info* hub, struct user* user, int reason)
/* stop reading from user */
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);
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* 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)
{
const char* addr = ip_convert_to_string(&u->net.ipaddr);
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)
{
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)
{
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')
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);
}
#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)
{
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);
return 0;
}
@ -344,12 +344,12 @@ static int check_logged_in(struct hub_info* hub, struct user* user, struct adc_m
{
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;
}
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;
}
}

34
src/core/main.c
View File

@ -42,12 +42,12 @@ void hub_handle_signal(int fd, short events, void* arg)
switch (signal)
{
case SIGINT:
hub_log(log_info, "Interrupted. Shutting down...");
LOG_INFO("Interrupted. Shutting down...");
hub->status = hub_status_shutdown;
break;
case SIGTERM:
hub_log(log_info, "Terminated. Shutting down...");
LOG_INFO("Terminated. Shutting down...");
hub->status = hub_status_shutdown;
break;
@ -59,7 +59,7 @@ void hub_handle_signal(int fd, short events, void* arg)
break;
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;
break;
}
@ -84,7 +84,7 @@ void setup_signal_handlers(struct hub_info* hub)
event_base_set(hub->evbase, &signal_events[i]);
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)
{
hub_log(log_info, "Reloading configuration files...");
hub_log(log_debug, "Hub status: %d", (int) hub->status);
LOG_INFO("Reloading configuration files...");
LOG_DEBUG("Hub status: %d", (int) hub->status);
}
if (read_config(arg_config, &configuration, !arg_have_config) == -1)
@ -335,15 +335,15 @@ int drop_privileges()
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;
}
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);
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;
}
gid_ok = 1;
@ -368,25 +368,25 @@ int drop_privileges()
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;
}
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);
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;
}
}
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);
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;
}
}
@ -401,7 +401,7 @@ int pidfile_create()
FILE* pidfile = fopen(arg_pid, "w");
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;
}
@ -440,7 +440,7 @@ int main(int argc, char** argv)
ret = fork();
if (ret == -1)
{
hub_log(log_fatal, "Unable to fork to background!");
LOG_FATAL("Unable to fork to background!");
return -1;
}
else if (ret == 0)
@ -456,7 +456,7 @@ int main(int argc, char** argv)
else
{
/* parent process */
hub_log(log_debug, "Forked to background\n");
LOG_DEBUG("Forked to background\n");
return 0;
}
}

22
src/core/netevent.c
View File

@ -26,27 +26,27 @@ extern struct hub_info* g_hub;
#ifdef DEBUG_SENDQ
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)
{
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)
{
printf("RECV: %d/%d bytes\n", received, (int) max);
LOG_DUMP("RECV: %d/%d bytes\n", received, (int) max);
if (received == -1)
{
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)
{
char* data = hub_malloc_zero(received + 1);
memcpy(data, buffer, received);
printf("RECV: \"%s\"\n", data);
LOG_DUMP("RECV: \"%s\"\n", data);
hub_free(data);
}
}
@ -165,7 +165,7 @@ int handle_net_read(struct user* user)
pos[0] = '\0';
#ifdef DEBUG_SENDQ
printf("PROC: \"%s\" (%d)\n", start, (int) (pos - start));
LOG_DUMP("PROC: \"%s\" (%d)\n", start, (int) (pos - start));
#endif
if (user_flag_get(user, flag_maxbuf))
@ -239,7 +239,7 @@ void net_event(int fd, short ev, void *arg)
int flag_close = 0;
#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
if (ev & EV_TIMEOUT)
@ -315,7 +315,7 @@ void net_on_accept(int server_fd, short ev, void *arg)
}
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;
}
}
@ -323,12 +323,12 @@ void net_on_accept(int server_fd, short ev, void *arg)
addr = ip_convert_to_string(&ipaddr);
/* 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? */
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);
continue;
}
@ -336,7 +336,7 @@ void net_on_accept(int server_fd, short ev, void *arg)
user = user_create(hub, fd);
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);
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
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);
#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;
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));
@ -68,7 +68,7 @@ struct user* user_create(struct hub_info* hub, int sd)
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);
evtimer_del(&user->net.timeout);
@ -173,7 +173,7 @@ static int convert_support_fourcc(int fourcc)
return feature_link;
default:
hub_log(log_debug, "Unknown extension: %x", fourcc);
LOG_DEBUG("Unknown extension: %x", fourcc);
return 0;
}
}
@ -330,7 +330,7 @@ int user_is_registered(struct user* user)
void user_net_io_want_write(struct user* user)
{
#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
if (event_pending(&user->net.event, EV_READ | EV_WRITE, 0) == (EV_READ | EV_WRITE))
return;
@ -342,7 +342,7 @@ void user_net_io_want_write(struct user* user)
void user_net_io_want_read(struct user* user)
{
#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
if (event_pending(&user->net.event, EV_READ | EV_WRITE, 0) == EV_READ)
return;
@ -364,7 +364,7 @@ void user_reset_last_read(struct user* user)
void user_set_timeout(struct user* user, int seconds)
{
#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
struct timeval timeout = { seconds, 0 };
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)
{
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_peak,
(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;
if (WSAStartup(MAKEWORD(2, 2), &wsa) != NO_ERROR)
{
hub_log(log_error, "Unable to initialize winsock.");
LOG_ERROR("Unable to initialize winsock.");
return -1;
}
#endif /* WINSOCK */
hub_log(log_trace, "Initializing network monitor.");
LOG_TRACE("Initializing network monitor.");
net_stats_initialize();
#ifdef SSL_SUPPORT
hub_log(log_trace, "Initializing OpenSSL...");
LOG_TRACE("Initializing OpenSSL...");
SSL_load_error_strings();
SSL_library_init();
OpenSSL_add_all_algorithms();
@ -66,7 +66,7 @@ int net_destroy()
{
if (net_initialized)
{
hub_log(log_trace, "Shutting down network monitor");
LOG_TRACE("Shutting down network monitor");
#ifdef SSL_SUPPORT
/* FIXME: Shutdown OpenSSL here. */
@ -84,7 +84,7 @@ int net_destroy()
static void net_error_out(int fd, const char* func)
{
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()
@ -379,7 +379,7 @@ int net_is_ipv6_supported()
if (net_error() == EAFNOSUPPORT)
#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;
return 0;
}
@ -392,7 +392,7 @@ int net_is_ipv6_supported()
int 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;
}
else
@ -424,7 +424,7 @@ int net_socket_create(int af, int type, int protocol)
int 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

20
src/uhub.h
View File

@ -157,23 +157,25 @@
extern "C" {
#endif
#include "util/memory.h"
#include "util/misc.h"
#include "core/eventid.h"
#include "core/eventqueue.h"
#include "util/ipcalc.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/message.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/hubio.h"
#include "core/auth.h"
#include "util/tiger.h"
#include "core/config.h"
#include "util/log.h"
#include "core/user.h"
#include "core/usermanager.h"
#include "adc/message.h"
#include "core/route.h"
#include "core/hub.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);
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;
}
@ -163,7 +163,7 @@ int ip_convert_address(const char* text_address, int port, struct sockaddr* addr
addr4.sin_port = htons(port);
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;
}
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
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);
#endif
@ -272,7 +272,7 @@ int ip_mask_create_right(int af, int bits, struct ip_addr_encap* result)
#ifdef IP_CALC_DEBUG
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);
#endif
@ -405,7 +405,7 @@ int ip_compare(struct ip_addr_encap* a, struct ip_addr_encap* b)
#ifdef IP_CALC_DEBUG
char* a_str = hub_strdup(ip_convert_to_string(a));
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(b_str);
#endif

25
src/util/log.h
View File

@ -33,6 +33,31 @@ enum log_verbosity {
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
* 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 leak = 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++)
{
@ -55,11 +55,11 @@ void internal_debug_print_leaks()
{
leak += hub_allocs[n].size;
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 */
@ -73,7 +73,7 @@ void* internal_debug_mem_malloc(size_t size, const char* where)
/* Make sure the malloc info struct is initialized */
if (!hub_alloc_count)
{
hub_log(log_memory, "--- start ---");
LOG_MEMORY("--- start ---");
for (n = 0; n < UHUB_MAX_ALLOCS; n++)
{
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_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;
}
}
}
else
{
hub_log(log_memory, "%s *** OOM for %d bytes", where, size);
LOG_MEMORY("%s *** OOM for %d bytes", where, size);
hub_alloc_oom++;
return 0;
}
@ -141,7 +141,7 @@ void internal_debug_mem_free(void* ptr)
hub_allocs[n].size = 0;
hub_allocs[n].stack1 = 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;
free(ptr);
return;
@ -150,7 +150,7 @@ void internal_debug_mem_free(void* ptr)
malloc_slot = -1;
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
free(ptr);
#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);
hub_log(log_trace, "Opening file %s for line reading.", file);
LOG_TRACE("Opening file %s for line reading.", file);
fd = open(file, 0);
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;
}
ret = read(fd, buf, MAX_RECV_BUF);
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);
return -1;
}
else if (ret == 0)
{
close(fd);
hub_log(log_warning, "File is empty.");
LOG_WARN("File is empty.");
return 0;
}
else
@ -212,7 +212,7 @@ int file_read_lines(const char* file, void* data, file_line_handler_t handler)
pos[0] = '\0';
if (*start)
{
hub_log(log_dump, "Line: %s", start);
LOG_DUMP("Line: %s", start);
if (handler(start, line_count+1, data) < 0)
return -1;
}
@ -223,7 +223,7 @@ int file_read_lines(const char* file, void* data, file_line_handler_t handler)
if (*start)
{
buf[strlen(start)] = 0;
hub_log(log_dump, "Line: %s", start);
LOG_DUMP("Line: %s", start);
if (handler(start, line_count+1, data) < 0)
return -1;
}

2
version.h
View File

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