zynk/irssi
2
0
Fork 0
mirror of https://github.com/irssi/irssi.git synced 2026-08-10 20:33:46 +02:00
Code Issues Projects Releases Packages Wiki Activity

remove GTimeVal following glib 2.61.2 deprecation

Browse source
This commit is contained in:
ailin-nemui 2019-12-06 10:56:25 +01:00
commit 1cdb4bc311
14 changed files with 74 additions and 69 deletions
Download patch file Download diff file Expand all files Collapse all files

15
src/irc/core/irc-commands.c
View file

@ -528,7 +528,7 @@ static void cmd_whowas(const char *data, IRC_SERVER_REC *server)
/* SYNTAX: PING [<nick> | <channel> | *] */
static void cmd_ping(const char *data, IRC_SERVER_REC *server, WI_ITEM_REC *item)
{
GTimeVal tv;
gint64 tv;
char *str;
CMD_IRC_SERVER(server);
@ -539,9 +539,9 @@ static void cmd_ping(const char *data, IRC_SERVER_REC *server, WI_ITEM_REC *item
data = window_item_get_target(item);
}
g_get_current_time(&tv);
tv = g_get_real_time();
str = g_strdup_printf("%s PING %ld %ld", data, tv.tv_sec, tv.tv_usec);
str = g_strdup_printf("%s PING %ld %ld", data, tv / G_TIME_SPAN_SECOND, tv % G_TIME_SPAN_SECOND);
signal_emit("command ctcp", 3, str, server, item);
g_free(str);
}
@ -616,13 +616,8 @@ static void cmd_wait(const char *data, IRC_SERVER_REC *server)
n = atoi(msecs);
if (server != NULL && n > 0) {
g_get_current_time(&server->wait_cmd);
server->wait_cmd.tv_sec += n/1000;
server->wait_cmd.tv_usec += n%1000;
if (server->wait_cmd.tv_usec >= 1000) {
server->wait_cmd.tv_sec++;
server->wait_cmd.tv_usec -= 1000;
}
server->wait_cmd = g_get_real_time();
server->wait_cmd += n * G_TIME_SPAN_MILLISECOND;
}
cmd_params_free(free_arg);
}

26
src/irc/core/irc-servers.c
View file

@ -294,8 +294,8 @@ static void server_init(IRC_SERVER_REC *server)
/* prevent the queue from sending too early, we have a max cut off of 120 secs */
/* this will reset to 1 sec after we get the 001 event */
g_get_current_time(&server->wait_cmd);
g_time_val_add(&server->wait_cmd, 120 * G_USEC_PER_SEC);
server->wait_cmd = g_get_real_time();
server->wait_cmd += 120 * G_USEC_PER_SEC;
}
SERVER_REC *irc_server_init_connect(SERVER_CONNECT_REC *conn)
@ -559,21 +559,21 @@ void irc_server_send_data(IRC_SERVER_REC *server, const char *data, int len)
return;
}
g_get_current_time(&server->last_cmd);
server->last_cmd = g_get_real_time();
/* A bit kludgy way to do the flood protection. In ircnet, there
actually is 1sec / 100 bytes penalty, but we rather want to deal
with the max. 1000 bytes input buffer problem. If we send more
than that with the burst, we'll get excess flooded. */
if (len < 100 || server->cmd_queue_speed <= 10)
server->wait_cmd.tv_sec = 0;
server->wait_cmd = 0;
else {
memcpy(&server->wait_cmd, &server->last_cmd, sizeof(GTimeVal));
g_time_val_add(&server->wait_cmd, (2 + len/100) * G_USEC_PER_SEC);
server->wait_cmd = server->last_cmd;
server->wait_cmd += (2 + len / 100) * G_USEC_PER_SEC;
}
}
static int server_cmd_timeout(IRC_SERVER_REC *server, GTimeVal *now)
static int server_cmd_timeout(IRC_SERVER_REC *server, gint64 now)
{
REDIRECT_REC *redirect;
GSList *link;
@ -587,10 +587,10 @@ static int server_cmd_timeout(IRC_SERVER_REC *server, GTimeVal *now)
if (server->cmdcount == 0 && server->cmdqueue == NULL)
return 0;
if (g_timeval_cmp(now, &server->wait_cmd) == -1)
if (now < server->wait_cmd)
return 1;
usecs = get_timeval_diff(now, &server->last_cmd);
usecs = (now - server->last_cmd) / G_TIME_SPAN_MILLISECOND;
if (usecs < server->cmd_queue_speed)
return 1;
@ -626,13 +626,13 @@ static int server_cmd_timeout(IRC_SERVER_REC *server, GTimeVal *now)
/* check every now and then if there's data to be sent in command buffer */
static int servers_cmd_timeout(void)
{
GTimeVal now;
gint64 now;
GSList *tmp;
int keep = 0;
g_get_current_time(&now);
now = g_get_real_time();
for (tmp = servers; tmp != NULL; tmp = tmp->next) {
keep |= server_cmd_timeout(tmp->data, &now);
keep |= server_cmd_timeout(tmp->data, now);
}
if (keep)
return 1;
@ -735,7 +735,7 @@ static void event_connected(IRC_SERVER_REC *server, const char *data, const char
server->real_connect_time = time(NULL);
/* let the queue send now that we are identified */
g_get_current_time(&server->wait_cmd);
server->wait_cmd = g_get_real_time();
if (server->connrec->usermode != NULL) {
/* Send the user mode, before the autosendcmd.

4
src/irc/core/irc-servers.h
View file

@ -113,8 +113,8 @@ struct _IRC_SERVER_REC {
how many messages can be sent before starting the
flood control */
GSList *cmdqueue; /* command, redirection, ... */
GTimeVal wait_cmd; /* don't send anything to server before this */
GTimeVal last_cmd; /* last time command was sent to server */
gint64 wait_cmd; /* don't send anything to server before this */
gint64 last_cmd; /* last time command was sent to server */
int max_cmds_at_once; /* How many messages can be sent immediately before timeouting starts */
int cmd_queue_speed; /* Timeout between sending commands */

12
src/irc/core/irc.c
View file

@ -140,15 +140,15 @@ void irc_send_cmd_full(IRC_SERVER_REC *server, const char *cmd,
/* Send command to IRC server */
void irc_send_cmd(IRC_SERVER_REC *server, const char *cmd)
{
GTimeVal now;
gint64 now;
int send_now;
g_get_current_time(&now);
send_now = g_timeval_cmp(&now, &server->wait_cmd) >= 0 &&
(server->cmdcount < server->max_cmds_at_once ||
server->cmd_queue_speed <= 0);
now = g_get_real_time();
send_now = now >= server->wait_cmd &&
(server->cmdcount < server->max_cmds_at_once ||
server->cmd_queue_speed <= 0);
irc_send_cmd_full(server, cmd, send_now, FALSE, FALSE);
irc_send_cmd_full(server, cmd, send_now, FALSE, FALSE);
}
/* Send command to IRC server */

24
src/irc/core/lag.c
View file

@ -30,7 +30,7 @@ static int timeout_tag;
static void lag_get(IRC_SERVER_REC *server)
{
g_get_current_time(&server->lag_sent);
server->lag_sent = g_get_real_time();
server->lag_last_check = time(NULL);
server_redirect_event(server, "ping", 1, NULL, FALSE,
@ -48,18 +48,18 @@ static void lag_ping_error(IRC_SERVER_REC *server)
static void lag_event_pong(IRC_SERVER_REC *server, const char *data,
const char *nick, const char *addr)
{
GTimeVal now;
gint64 now;
g_return_if_fail(data != NULL);
if (server->lag_sent.tv_sec == 0) {
if (server->lag_sent == 0) {
/* not expecting lag reply.. */
return;
}
g_get_current_time(&now);
server->lag = (int) get_timeval_diff(&now, &server->lag_sent);
memset(&server->lag_sent, 0, sizeof(server->lag_sent));
now = g_get_real_time();
server->lag = now - server->lag_sent;
server->lag_sent = 0;
signal_emit("server lag", 1, server);
}
@ -76,8 +76,8 @@ static void sig_unknown_command(IRC_SERVER_REC *server, const char *data)
trying alternative methods to detect lag with these
servers. */
server->disable_lag = TRUE;
server->lag_sent.tv_sec = 0;
server->lag = 0;
server->lag_sent = 0;
server->lag = 0;
}
g_free(params);
}
@ -102,16 +102,16 @@ static int sig_check_lag(void)
if (!IS_IRC_SERVER(rec) || rec->disable_lag)
continue;
if (rec->lag_sent.tv_sec != 0) {
if (rec->lag_sent != 0) {
/* waiting for lag reply */
if (max_lag > 1 && now-rec->lag_sent.tv_sec > max_lag) {
if (max_lag > 1 && now - rec->lag_sent > max_lag * G_TIME_SPAN_SECOND) {
/* too much lag, disconnect */
signal_emit("server lag disconnect", 1, rec);
rec->connection_lost = TRUE;
server_disconnect((SERVER_REC *) rec);
}
} else if (rec->lag_last_check+lag_check_time < now &&
rec->cmdcount == 0 && rec->connected) {
} else if (rec->lag_last_check + lag_check_time < now && rec->cmdcount == 0 &&
rec->connected) {
/* no commands in buffer - get the lag */
lag_get(rec);
}