diff options
Diffstat (limited to 'src/protocols/irc/irc-server.c')
| -rw-r--r-- | src/protocols/irc/irc-server.c | 2415 |
1 files changed, 2415 insertions, 0 deletions
diff --git a/src/protocols/irc/irc-server.c b/src/protocols/irc/irc-server.c new file mode 100644 index 000000000..0c119ceb1 --- /dev/null +++ b/src/protocols/irc/irc-server.c @@ -0,0 +1,2415 @@ +/* + * Copyright (c) 2003-2007 by FlashCode <flashcode@flashtux.org> + * See README for License detail, AUTHORS for developers list. + * + * 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/>. + */ + +/* irc-server.c: connection and communication with IRC server */ + + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdlib.h> +#include <unistd.h> +#include <errno.h> +#include <signal.h> +#include <stdio.h> +#include <stdarg.h> +#include <string.h> +#include <pwd.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <netdb.h> + +#ifdef HAVE_GNUTLS +#include <gnutls/gnutls.h> +#endif + +#include "../../common/weechat.h" +#include "irc.h" +#include "../../common/log.h" +#include "../../common/util.h" +#include "../../common/weeconfig.h" +#include "../../gui/gui.h" + +#ifdef PLUGINS +#include "../../plugins/plugins.h" +#endif + + +t_irc_server *irc_servers = NULL; +t_irc_server *last_irc_server = NULL; + +t_irc_message *irc_recv_msgq = NULL; +t_irc_message *irc_msgq_last_msg = NULL; + +int irc_check_away = 0; + +#ifdef HAVE_GNUTLS +const int gnutls_cert_type_prio[] = { GNUTLS_CRT_X509, GNUTLS_CRT_OPENPGP, 0 }; +#if LIBGNUTLS_VERSION_NUMBER >= 0x010700 + const int gnutls_prot_prio[] = { GNUTLS_TLS1_2, GNUTLS_TLS1_1, + GNUTLS_TLS1_0, GNUTLS_SSL3, 0 }; +#else + const int gnutls_prot_prio[] = { GNUTLS_TLS1_1, GNUTLS_TLS1_0, + GNUTLS_SSL3, 0 }; +#endif +#endif + + +/* + * irc_server_init: init server struct with default values + */ + +void +irc_server_init (t_irc_server *server) +{ + /* user choices */ + server->name = NULL; + server->autoconnect = 0; + server->autoreconnect = 1; + server->autoreconnect_delay = 30; + server->temp_server = 0; + server->address = NULL; + server->port = -1; + server->ipv6 = 0; + server->ssl = 0; + server->password = NULL; + server->nick1 = NULL; + server->nick2 = NULL; + server->nick3 = NULL; + server->username = NULL; + server->realname = NULL; + server->hostname = NULL; + server->command = NULL; + server->command_delay = 1; + server->autojoin = NULL; + server->autorejoin = 0; + server->notify_levels = NULL; + + /* internal vars */ + server->child_pid = 0; + server->child_read = -1; + server->child_write = -1; + server->sock = -1; + server->is_connected = 0; + server->ssl_connected = 0; + server->unterminated_message = NULL; + server->nick = NULL; + server->nick_modes = NULL; + server->prefix = NULL; + server->reconnect_start = 0; + server->command_time = 0; + server->reconnect_join = 0; + server->disable_autojoin = 0; + server->is_away = 0; + server->away_message = NULL; + server->away_time = 0; + server->lag = 0; + server->lag_check_time.tv_sec = 0; + server->lag_check_time.tv_usec = 0; + server->lag_next_check = time (NULL) + cfg_irc_lag_check; + server->cmd_list_regexp = NULL; + server->queue_msg = 0; + server->last_user_message = 0; + server->outqueue = NULL; + server->last_outqueue = NULL; + server->buffer = NULL; + server->saved_buffer = NULL; + server->channels = NULL; + server->last_channel = NULL; +} + +/* + * irc_server_init_with_url: init a server with url of this form: + * irc://nick:pass@irc.toto.org:6667 + * returns: 0 = ok + * -1 = invalid syntax + */ + +int +irc_server_init_with_url (char *irc_url, t_irc_server *server) +{ + char *url, *pos_server, *pos_channel, *pos, *pos2; + int ipv6, ssl; + struct passwd *my_passwd; + + irc_server_init (server); + ipv6 = 0; + ssl = 0; + if (strncasecmp (irc_url, "irc6://", 7) == 0) + { + pos = irc_url + 7; + ipv6 = 1; + } + else if (strncasecmp (irc_url, "ircs://", 7) == 0) + { + pos = irc_url + 7; + ssl = 1; + } + else if ((strncasecmp (irc_url, "irc6s://", 8) == 0) + || (strncasecmp (irc_url, "ircs6://", 8) == 0)) + { + pos = irc_url + 8; + ipv6 = 1; + ssl = 1; + } + else if (strncasecmp (irc_url, "irc://", 6) == 0) + { + pos = irc_url + 6; + } + else + return -1; + + url = strdup (pos); + pos_server = strchr (url, '@'); + if (pos_server) + { + pos_server[0] = '\0'; + pos_server++; + if (!pos[0]) + { + free (url); + return -1; + } + pos2 = strchr (url, ':'); + if (pos2) + { + pos2[0] = '\0'; + server->password = strdup (pos2 + 1); + } + server->nick1 = strdup (url); + } + else + { + if ((my_passwd = getpwuid (geteuid ())) != NULL) + server->nick1 = strdup (my_passwd->pw_name); + else + { + weechat_iconv_fprintf (stderr, "%s: %s (%s).", + WEECHAT_WARNING, + _("Unable to get user's name"), + strerror (errno)); + free (url); + return -1; + } + pos_server = url; + } + if (!pos_server[0]) + { + free (url); + return -1; + } + pos_channel = strchr (pos_server, '/'); + if (pos_channel) + { + pos_channel[0] = '\0'; + pos_channel++; + } + pos = strchr (pos_server, ':'); + if (pos) + { + pos[0] = '\0'; + server->port = atoi (pos + 1); + } + server->name = strdup (pos_server); + server->address = strdup (pos_server); + if (pos_channel && pos_channel[0]) + { + if (irc_channel_is_channel (pos_channel)) + server->autojoin = strdup (pos_channel); + else + { + server->autojoin = (char *) malloc (strlen (pos_channel) + 2); + strcpy (server->autojoin, "#"); + strcat (server->autojoin, pos_channel); + } + } + + free (url); + + server->ipv6 = ipv6; + server->ssl = ssl; + + /* some default values */ + if (server->port < 0) + server->port = IRC_DEFAULT_PORT; + server->nick2 = (char *) malloc (strlen (server->nick1) + 2); + strcpy (server->nick2, server->nick1); + server->nick2 = strcat (server->nick2, "1"); + server->nick3 = (char *) malloc (strlen (server->nick1) + 2); + strcpy (server->nick3, server->nick1); + server->nick3 = strcat (server->nick3, "2"); + + return 0; +} + +/* + * irc_server_alloc: allocate a new server and add it to the servers queue + */ + +t_irc_server * +irc_server_alloc () +{ + t_irc_server *new_server; + + /* alloc memory for new server */ + if ((new_server = (t_irc_server *) malloc (sizeof (t_irc_server))) == NULL) + { + weechat_iconv_fprintf (stderr, + _("%s cannot allocate new server\n"), + WEECHAT_ERROR); + return NULL; + } + + /* initialize new server */ + irc_server_init (new_server); + + /* add new server to queue */ + new_server->prev_server = last_irc_server; + new_server->next_server = NULL; + if (irc_servers) + last_irc_server->next_server = new_server; + else + irc_servers = new_server; + last_irc_server = new_server; + + /* all is ok, return address of new server */ + return new_server; +} + +/* + * irc_server_outqueue_add: add a message in out queue + */ + +void +irc_server_outqueue_add (t_irc_server *server, char *msg1, char *msg2, + int modified) +{ + t_irc_outqueue *new_outqueue; + + new_outqueue = (t_irc_outqueue *)malloc (sizeof (t_irc_outqueue)); + if (new_outqueue) + { + new_outqueue->message_before_mod = (msg1) ? strdup (msg1) : NULL; + new_outqueue->message_after_mod = (msg2) ? strdup (msg2) : NULL; + new_outqueue->modified = modified; + + new_outqueue->prev_outqueue = server->last_outqueue; + new_outqueue->next_outqueue = NULL; + if (server->outqueue) + server->last_outqueue->next_outqueue = new_outqueue; + else + server->outqueue = new_outqueue; + server->last_outqueue = new_outqueue; + } +} + +/* + * irc_server_outqueue_free: free a message in out queue + */ + +void +irc_server_outqueue_free (t_irc_server *server, t_irc_outqueue *outqueue) +{ + t_irc_outqueue *new_outqueue; + + /* remove outqueue message */ + if (server->last_outqueue == outqueue) + server->last_outqueue = outqueue->prev_outqueue; + if (outqueue->prev_outqueue) + { + (outqueue->prev_outqueue)->next_outqueue = outqueue->next_outqueue; + new_outqueue = server->outqueue; + } + else + new_outqueue = outqueue->next_outqueue; + + if (outqueue->next_outqueue) + (outqueue->next_outqueue)->prev_outqueue = outqueue->prev_outqueue; + + if (outqueue->message_before_mod) + free (outqueue->message_before_mod); + if (outqueue->message_after_mod) + free (outqueue->message_after_mod); + free (outqueue); + server->outqueue = new_outqueue; +} + +/* + * irc_server_outqueue_free_all: free all outqueued messages + */ + +void +irc_server_outqueue_free_all (t_irc_server *server) +{ + while (server->outqueue) + irc_server_outqueue_free (server, server->outqueue); +} + +/* + * irc_server_destroy: free server data (not struct himself) + */ + +void +irc_server_destroy (t_irc_server *server) +{ + if (!server) + return; + + /* free data */ + if (server->name) + free (server->name); + if (server->address) + free (server->address); + if (server->password) + free (server->password); + if (server->nick1) + free (server->nick1); + if (server->nick2) + free (server->nick2); + if (server->nick3) + free (server->nick3); + if (server->username) + free (server->username); + if (server->realname) + free (server->realname); + if (server->hostname) + free (server->hostname); + if (server->command) + free (server->command); + if (server->autojoin) + free (server->autojoin); + if (server->notify_levels) + free (server->notify_levels); + if (server->unterminated_message) + free (server->unterminated_message); + if (server->nick) + free (server->nick); + if (server->nick_modes) + free (server->nick_modes); + if (server->prefix) + free (server->prefix); + if (server->away_message) + free (server->away_message); + if (server->outqueue) + irc_server_outqueue_free_all (server); + if (server->channels) + irc_channel_free_all (server); +} + +/* + * irc_server_free: free a server and remove it from servers queue + */ + +void +irc_server_free (t_irc_server *server) +{ + t_irc_server *new_irc_servers; + + if (!server) + return; + + /* close any opened channel/private */ + while (server->channels) + irc_channel_free (server, server->channels); + + /* remove server from queue */ + if (last_irc_server == server) + last_irc_server = server->prev_server; + if (server->prev_server) + { + (server->prev_server)->next_server = server->next_server; + new_irc_servers = irc_servers; + } + else + new_irc_servers = server->next_server; + + if (server->next_server) + (server->next_server)->prev_server = server->prev_server; + + irc_server_destroy (server); + free (server); + irc_servers = new_irc_servers; +} + +/* + * irc_server_free_all: free all allocated servers + */ + +void +irc_server_free_all () +{ + /* for each server in memory, remove it */ + while (irc_servers) + irc_server_free (irc_servers); +} + +/* + * irc_server_new: creates a new server, and initialize it + */ + +t_irc_server * +irc_server_new (char *name, int autoconnect, int autoreconnect, + int autoreconnect_delay, int temp_server, char *address, + int port, int ipv6, int ssl, char *password, + char *nick1, char *nick2, char *nick3, char *username, + char *realname, char *hostname, char *command, int command_delay, + char *autojoin, int autorejoin, char *notify_levels) +{ + t_irc_server *new_server; + + if (!name || !address || (port < 0)) + return NULL; + +#ifdef DEBUG + weechat_log_printf ("Creating new server (name:%s, address:%s, port:%d, pwd:%s, " + "nick1:%s, nick2:%s, nick3:%s, username:%s, realname:%s, " + "hostname: %s, command:%s, autojoin:%s, autorejoin:%s, " + "notify_levels:%s)\n", + name, address, port, (password) ? password : "", + (nick1) ? nick1 : "", (nick2) ? nick2 : "", (nick3) ? nick3 : "", + (username) ? username : "", (realname) ? realname : "", + (hostname) ? hostname : "", (command) ? command : "", + (autojoin) ? autojoin : "", (autorejoin) ? "on" : "off", + (notify_levels) ? notify_levels : ""); +#endif + + if ((new_server = irc_server_alloc ())) + { + new_server->name = strdup (name); + new_server->autoconnect = autoconnect; + new_server->autoreconnect = autoreconnect; + new_server->autoreconnect_delay = autoreconnect_delay; + new_server->temp_server = temp_server; + new_server->address = strdup (address); + new_server->port = port; + new_server->ipv6 = ipv6; + new_server->ssl = ssl; + new_server->password = (password) ? strdup (password) : strdup (""); + new_server->nick1 = (nick1) ? strdup (nick1) : strdup ("weechat_user"); + new_server->nick2 = (nick2) ? strdup (nick2) : strdup ("weechat2"); + new_server->nick3 = (nick3) ? strdup (nick3) : strdup ("weechat3"); + new_server->username = + (username) ? strdup (username) : strdup ("weechat"); + new_server->realname = + (realname) ? strdup (realname) : strdup ("realname"); + new_server->hostname = + (hostname) ? strdup (hostname) : NULL; + new_server->command = + (command) ? strdup (command) : NULL; + new_server->command_delay = command_delay; + new_server->autojoin = + (autojoin) ? strdup (autojoin) : NULL; + new_server->autorejoin = autorejoin; + new_server->notify_levels = + (notify_levels) ? strdup (notify_levels) : NULL; + } + else + return NULL; + return new_server; +} + +/* + * irc_server_duplicate: duplicate a server + * return: pointer to new server, NULL if error + */ + +t_irc_server * +irc_server_duplicate (t_irc_server *server, char *new_name) +{ + t_irc_server *new_server; + + /* check if another server exists with this name */ + if (irc_server_search (new_name)) + return 0; + + /* duplicate server */ + new_server = irc_server_new (new_name, + server->autoconnect, + server->autoreconnect, + server->autoreconnect_delay, + server->temp_server, + server->address, + server->port, + server->ipv6, + server->ssl, + server->password, + server->nick1, + server->nick2, + server->nick3, + server->username, + server->realname, + server->hostname, + server->command, + server->command_delay, + server->autojoin, + server->autorejoin, + server->notify_levels); + + return new_server; +} + +/* + * irc_server_rename: rename server (internal name) + * return: 1 if ok, 0 if error + */ + +int +irc_server_rename (t_irc_server *server, char *new_name) +{ + char *str; + + /* check if another server exists with this name */ + if (irc_server_search (new_name)) + return 0; + + /* rename server */ + str = strdup (new_name); + if (str) + { + if (server->name) + free (server->name); + server->name = str; + return 1; + } + return 0; +} + +/* + * irc_server_send: send data to IRC server + * return number of bytes sent, -1 if error + */ + +int +irc_server_send (t_irc_server *server, char *buffer, int size_buf) +{ + if (!server) + return -1; + +#ifdef HAVE_GNUTLS + if (server->ssl_connected) + return gnutls_record_send (server->gnutls_sess, buffer, size_buf); + else +#endif + return send (server->sock, buffer, size_buf, 0); +} + +/* + * irc_server_outqueue_send: send a message from outqueue + */ + +void +irc_server_outqueue_send (t_irc_server *server) +{ + time_t time_now; + char *pos; + + if (server->outqueue) + { + time_now = time (NULL); + if (time_now >= server->last_user_message + cfg_irc_anti_flood) + { + if (server->outqueue->message_before_mod) + { + pos = strchr (server->outqueue->message_before_mod, '\r'); + if (pos) + pos[0] = '\0'; + gui_printf_raw_data (server, 1, 0, + server->outqueue->message_before_mod); + if (pos) + pos[0] = '\r'; + } + if (server->outqueue->message_after_mod) + { + pos = strchr (server->outqueue->message_after_mod, '\r'); + if (pos) + pos[0] = '\0'; + gui_printf_raw_data (server, 1, server->outqueue->modified, + server->outqueue->message_after_mod); + if (pos) + pos[0] = '\r'; + } + if (irc_server_send (server, server->outqueue->message_after_mod, + strlen (server->outqueue->message_after_mod)) <= 0) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, _("%s error sending data to IRC server\n"), + WEECHAT_ERROR); + } + server->last_user_message = time_now; + irc_server_outqueue_free (server, server->outqueue); + } + } +} + +/* + * irc_server_send_one_msg: send one message to IRC server + */ + +int +irc_server_send_one_msg (t_irc_server *server, char *message) +{ + static char buffer[4096]; + char *new_msg, *ptr_msg, *pos; + int rc, queue, first_message; + time_t time_now; + + rc = 1; + +#ifdef DEBUG + gui_printf (server->buffer, "[DEBUG] Sending to server >>> %s\n", message); +#endif +#ifdef PLUGINS + new_msg = plugin_modifier_exec (PLUGIN_MODIFIER_IRC_OUT, + server->name, + message); +#else + new_msg = NULL; +#endif + + /* no changes in new message */ + if (new_msg && (strcmp (buffer, new_msg) == 0)) + { + free (new_msg); + new_msg = NULL; + } + + /* message not dropped? */ + if (!new_msg || new_msg[0]) + { + first_message = 1; + ptr_msg = (new_msg) ? new_msg : message; + + while (rc && ptr_msg && ptr_msg[0]) + { + pos = strchr (ptr_msg, '\n'); + if (pos) + pos[0] = '\0'; + + snprintf (buffer, sizeof (buffer) - 1, "%s\r\n", ptr_msg); + + /* anti-flood: look whether we should queue outgoing message or not */ + time_now = time (NULL); + queue = 0; + if ((server->queue_msg) + && ((server->outqueue) + || ((cfg_irc_anti_flood > 0) + && (time_now - server->last_user_message < cfg_irc_anti_flood)))) + queue = 1; + + /* if queue, then only queue message and send nothing now */ + if (queue) + { + irc_server_outqueue_add (server, + (new_msg && first_message) ? message : NULL, + buffer, + (new_msg) ? 1 : 0); + } + else + { + if (first_message) + gui_printf_raw_data (server, 1, 0, message); + if (new_msg) + gui_printf_raw_data (server, 1, 1, ptr_msg); + if (irc_server_send (server, buffer, strlen (buffer)) <= 0) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, _("%s error sending data to IRC server\n"), + WEECHAT_ERROR); + rc = 0; + } + else + { + if (server->queue_msg) + server->last_user_message = time_now; + } + } + if (pos) + { + pos[0] = '\n'; + ptr_msg = pos + 1; + } + else + ptr_msg = NULL; + + first_message = 0; + } + } + else + gui_printf_raw_data (server, 1, 1, _("(message dropped)")); + if (new_msg) + free (new_msg); + + return rc; +} + +/* + * irc_server_sendf: send formatted data to IRC server + * many messages may be sent, separated by '\n' + */ + +void +irc_server_sendf (t_irc_server *server, char *fmt, ...) +{ + va_list args; + static char buffer[4096]; + char *ptr_buf, *pos; + int rc; + + if (!server) + return; + + va_start (args, fmt); + vsnprintf (buffer, sizeof (buffer) - 1, fmt, args); + va_end (args); + + ptr_buf = buffer; + while (ptr_buf && ptr_buf[0]) + { + pos = strchr (ptr_buf, '\n'); + if (pos) + pos[0] = '\0'; + + rc = irc_server_send_one_msg (server, ptr_buf); + + if (pos) + { + pos[0] = '\n'; + ptr_buf = pos + 1; + } + else + ptr_buf = NULL; + + if (!rc) + ptr_buf = NULL; + } +} + +/* + * irc_server_parse_message: parse IRC message and return pointer to + * host, command and arguments (if any) + */ + +void +irc_server_parse_message (char *message, char **host, char **command, char **args) +{ + char *pos, *pos2; + + *host = NULL; + *command = NULL; + *args = NULL; + + if (message[0] == ':') + { + pos = strchr (message, ' '); + if (pos) + { + *host = strndup (message + 1, pos - (message + 1)); + pos++; + } + else + pos = message; + } + else + pos = message; + + if (pos && pos[0]) + { + while (pos[0] == ' ') + pos++; + pos2 = strchr (pos, ' '); + if (pos2) + { + *command = strndup (pos, pos2 - pos); + pos2++; + while (pos2[0] == ' ') + pos2++; + *args = strdup (pos2); + } + } +} + +/* + * irc_server_msgq_add_msg: add a message to received messages queue (at the end) + */ + +void +irc_server_msgq_add_msg (t_irc_server *server, char *msg) +{ + t_irc_message *message; + + if (!server->unterminated_message && !msg[0]) + return; + + message = (t_irc_message *) malloc (sizeof (t_irc_message)); + if (!message) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s not enough memory for received IRC message\n"), + WEECHAT_ERROR); + return; + } + message->server = server; + if (server->unterminated_message) + { + message->data = (char *) malloc (strlen (server->unterminated_message) + + strlen (msg) + 1); + if (!message->data) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s not enough memory for received IRC message\n"), + WEECHAT_ERROR); + } + else + { + strcpy (message->data, server->unterminated_message); + strcat (message->data, msg); + } + free (server->unterminated_message); + server->unterminated_message = NULL; + } + else + message->data = strdup (msg); + message->next_message = NULL; + + if (irc_msgq_last_msg) + { + irc_msgq_last_msg->next_message = message; + irc_msgq_last_msg = message; + } + else + { + irc_recv_msgq = message; + irc_msgq_last_msg = message; + } +} + +/* + * irc_server_msgq_add_unterminated: add an unterminated message to queue + */ + +void +irc_server_msgq_add_unterminated (t_irc_server *server, char *string) +{ + if (!string[0]) + return; + + if (server->unterminated_message) + { + server->unterminated_message = + (char *) realloc (server->unterminated_message, + strlen (server->unterminated_message) + + strlen (string) + 1); + if (!server->unterminated_message) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s not enough memory for received IRC message\n"), + WEECHAT_ERROR); + } + else + strcat (server->unterminated_message, string); + } + else + { + server->unterminated_message = strdup (string); + if (!server->unterminated_message) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s not enough memory for received IRC message\n"), + WEECHAT_ERROR); + } + } +} + +/* + * irc_server_msgq_add_buffer: explode received buffer, creating queued messages + */ + +void +irc_server_msgq_add_buffer (t_irc_server *server, char *buffer) +{ + char *pos_cr, *pos_lf; + + while (buffer[0]) + { + pos_cr = strchr (buffer, '\r'); + pos_lf = strchr (buffer, '\n'); + + if (!pos_cr && !pos_lf) + { + /* no CR/LF found => add to unterminated and return */ + irc_server_msgq_add_unterminated (server, buffer); + return; + } + + if (pos_cr && ((!pos_lf) || (pos_lf > pos_cr))) + { + /* found '\r' first => ignore this char */ + pos_cr[0] = '\0'; + irc_server_msgq_add_unterminated (server, buffer); + buffer = pos_cr + 1; + } + else + { + /* found: '\n' first => terminate message */ + pos_lf[0] = '\0'; + irc_server_msgq_add_msg (server, buffer); + buffer = pos_lf + 1; + } + } +} + +/* + * irc_server_msgq_flush: flush message queue + */ + +void +irc_server_msgq_flush () +{ + t_irc_message *next; + char *ptr_data, *new_msg, *ptr_msg, *pos; + char *host, *command, *args; + + while (irc_recv_msgq) + { + if (irc_recv_msgq->data) + { +#ifdef DEBUG + gui_printf (gui_current_window->buffer, "[DEBUG] %s\n", irc_recv_msgq->data); +#endif + ptr_data = irc_recv_msgq->data; + while (ptr_data[0] == ' ') + ptr_data++; + + if (ptr_data[0]) + { + gui_printf_raw_data (irc_recv_msgq->server, 0, 0, ptr_data); +#ifdef DEBUG + gui_printf (NULL, "[DEBUG] data received from server: %s\n", ptr_data); +#endif +#ifdef PLUGINS + new_msg = plugin_modifier_exec (PLUGIN_MODIFIER_IRC_IN, + irc_recv_msgq->server->name, + ptr_data); +#else + new_msg = NULL; +#endif + /* no changes in new message */ + if (new_msg && (strcmp (ptr_data, new_msg) == 0)) + { + free (new_msg); + new_msg = NULL; + } + + /* message not dropped? */ + if (!new_msg || new_msg[0]) + { + /* use new message (returned by plugin) */ + ptr_msg = (new_msg) ? new_msg : ptr_data; + + while (ptr_msg && ptr_msg[0]) + { + pos = strchr (ptr_msg, '\n'); + if (pos) + pos[0] = '\0'; + + if (new_msg) + gui_printf_raw_data (irc_recv_msgq->server, 0, 1, ptr_msg); + + irc_server_parse_message (ptr_msg, &host, &command, &args); + + switch (irc_recv_command (irc_recv_msgq->server, ptr_msg, host, command, args)) + { + case -1: + irc_display_prefix (irc_recv_msgq->server, + irc_recv_msgq->server->buffer, GUI_PREFIX_ERROR); + gui_printf (irc_recv_msgq->server->buffer, + _("%s Command \"%s\" failed!\n"), WEECHAT_ERROR, command); + break; + case -2: + irc_display_prefix (irc_recv_msgq->server, + irc_recv_msgq->server->buffer, GUI_PREFIX_ERROR); + gui_printf (irc_recv_msgq->server->buffer, + _("%s No command to execute!\n"), WEECHAT_ERROR); + break; + case -3: + irc_display_prefix (irc_recv_msgq->server, + irc_recv_msgq->server->buffer, GUI_PREFIX_ERROR); + gui_printf (irc_recv_msgq->server->buffer, + _("%s Unknown command: cmd=\"%s\", host=\"%s\", args=\"%s\"\n"), + WEECHAT_WARNING, command, host, args); + break; + } + if (host) + free (host); + if (command) + free (command); + if (args) + free (args); + + if (pos) + { + pos[0] = '\n'; + ptr_msg = pos + 1; + } + else + ptr_msg = NULL; + } + } + else + gui_printf_raw_data (irc_recv_msgq->server, 0, 1, _("(message dropped)")); + if (new_msg) + free (new_msg); + } + free (irc_recv_msgq->data); + } + + next = irc_recv_msgq->next_message; + free (irc_recv_msgq); + irc_recv_msgq = next; + if (irc_recv_msgq == NULL) + irc_msgq_last_msg = NULL; + } +} + +/* + * irc_server_recv: receive data from an irc server + */ + +void +irc_server_recv (t_irc_server *server) +{ + static char buffer[4096 + 2]; + int num_read; + + if (!server) + return; + +#ifdef HAVE_GNUTLS + if (server->ssl_connected) + num_read = gnutls_record_recv (server->gnutls_sess, buffer, sizeof (buffer) - 2); + else +#endif + num_read = recv (server->sock, buffer, sizeof (buffer) - 2, 0); + + if (num_read > 0) + { + buffer[num_read] = '\0'; + irc_server_msgq_add_buffer (server, buffer); + irc_server_msgq_flush (); + } + else + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s cannot read data from socket, disconnecting from server...\n"), + WEECHAT_ERROR); + irc_server_disconnect (server, 1); + } +} + +/* + * irc_server_child_kill: kill child process and close pipe + */ + +void +irc_server_child_kill (t_irc_server *server) +{ + /* kill process */ + if (server->child_pid > 0) + { + kill (server->child_pid, SIGKILL); + waitpid (server->child_pid, NULL, 0); + server->child_pid = 0; + } + + /* close pipe used with child */ + if (server->child_read != -1) + { + close (server->child_read); + server->child_read = -1; + } + if (server->child_write != -1) + { + close (server->child_write); + server->child_write = -1; + } +} + +/* + * irc_server_close_connection: close server connection + * (kill child, close socket/pipes) + */ + +void +irc_server_close_connection (t_irc_server *server) +{ + irc_server_child_kill (server); + + /* close network socket */ + if (server->sock != -1) + { +#ifdef HAVE_GNUTLS + if (server->ssl_connected) + gnutls_bye (server->gnutls_sess, GNUTLS_SHUT_WR); +#endif + close (server->sock); + server->sock = -1; +#ifdef HAVE_GNUTLS + if (server->ssl_connected) + gnutls_deinit (server->gnutls_sess); +#endif + } + + /* free any pending message */ + if (server->unterminated_message) + { + free (server->unterminated_message); + server->unterminated_message = NULL; + } + irc_server_outqueue_free_all (server); + + /* server is now disconnected */ + server->is_connected = 0; + server->ssl_connected = 0; +} + +/* + * irc_server_reconnect_schedule: schedule reconnect for a server + */ + +void +irc_server_reconnect_schedule (t_irc_server *server) +{ + if (server->autoreconnect) + { + server->reconnect_start = time (NULL); + irc_display_prefix (server, server->buffer, GUI_PREFIX_INFO); + gui_printf (server->buffer, _("%s: Reconnecting to server in %d seconds\n"), + PACKAGE_NAME, server->autoreconnect_delay); + } + else + server->reconnect_start = 0; +} + +/* + * irc_server_child_read: read connection progress from child process + */ + +void +irc_server_child_read (t_irc_server *server) +{ + char buffer[1]; + int num_read; + + num_read = read (server->child_read, buffer, sizeof (buffer)); + if (num_read > 0) + { + switch (buffer[0]) + { + /* connection OK */ + case '0': + /* enable SSL if asked */ +#ifdef HAVE_GNUTLS + if (server->ssl_connected) + { + gnutls_transport_set_ptr (server->gnutls_sess, + (gnutls_transport_ptr) ((unsigned long) server->sock)); + if (gnutls_handshake (server->gnutls_sess) < 0) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s gnutls handshake failed\n"), + WEECHAT_ERROR); + irc_server_close_connection (server); + irc_server_reconnect_schedule (server); + return; + } + } +#endif + /* kill child and login to server */ + irc_server_child_kill (server); + irc_send_login (server); + break; + /* adress not found */ + case '1': + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + if (cfg_proxy_use) + gui_printf (server->buffer, + _("%s proxy address \"%s\" not found\n"), + WEECHAT_ERROR, server->address); + else + gui_printf (server->buffer, + _("%s address \"%s\" not found\n"), + WEECHAT_ERROR, server->address); + irc_server_close_connection (server); + irc_server_reconnect_schedule (server); + break; + /* IP address not found */ + case '2': + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + if (cfg_proxy_use) + gui_printf (server->buffer, + _("%s proxy IP address not found\n"), WEECHAT_ERROR); + else + gui_printf (server->buffer, + _("%s IP address not found\n"), WEECHAT_ERROR); + irc_server_close_connection (server); + irc_server_reconnect_schedule (server); + break; + /* connection refused */ + case '3': + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + if (cfg_proxy_use) + gui_printf (server->buffer, + _("%s proxy connection refused\n"), WEECHAT_ERROR); + else + gui_printf (server->buffer, + _("%s connection refused\n"), WEECHAT_ERROR); + irc_server_close_connection (server); + irc_server_reconnect_schedule (server); + break; + /* proxy fails to connect to server */ + case '4': + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s proxy fails to establish connection to " + "server (check username/password if used)\n"), + WEECHAT_ERROR); + irc_server_close_connection (server); + irc_server_reconnect_schedule (server); + break; + /* fails to set local hostname/IP */ + case '5': + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s unable to set local hostname/IP\n"), + WEECHAT_ERROR); + irc_server_close_connection (server); + irc_server_reconnect_schedule (server); + break; + } + } +} + +/* + * irc_server_convbase64_8x3_to_6x4 : convert 3 bytes of 8 bits in 4 bytes of 6 bits + */ + +void +irc_server_convbase64_8x3_to_6x4 (char *from, char* to) +{ + unsigned char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + to[0] = base64_table [ (from[0] & 0xfc) >> 2 ]; + to[1] = base64_table [ ((from[0] & 0x03) << 4) + ((from[1] & 0xf0) >> 4) ]; + to[2] = base64_table [ ((from[1] & 0x0f) << 2) + ((from[2] & 0xc0) >> 6) ]; + to[3] = base64_table [ from[2] & 0x3f ]; +} + +/* + * irc_server_base64encode: encode a string in base64 + */ + +void +irc_server_base64encode (char *from, char *to) +{ + char *f, *t; + int from_len; + + from_len = strlen(from); + + f = from; + t = to; + + while (from_len >= 3) + { + irc_server_convbase64_8x3_to_6x4 (f, t); + f += 3 * sizeof (*f); + t += 4 * sizeof (*t); + from_len -= 3; + } + + if (from_len > 0) + { + char rest[3] = { 0, 0, 0 }; + switch (from_len) + { + case 1 : + rest[0] = f[0]; + irc_server_convbase64_8x3_to_6x4 (rest, t); + t[2] = t[3] = '='; + break; + case 2 : + rest[0] = f[0]; + rest[1] = f[1]; + irc_server_convbase64_8x3_to_6x4 (rest, t); + t[3] = '='; + break; + } + t[4] = 0; + } +} + +/* + * irc_server_pass_httpproxy: establish connection/authentification to an + * http proxy + * return : + * - 0 if connexion throw proxy was successful + * - 1 if connexion fails + */ + +int +irc_server_pass_httpproxy (int sock, char *address, int port) +{ + + char buffer[256]; + char authbuf[128]; + char authbuf_base64[196]; + int n, m; + + if (cfg_proxy_username && cfg_proxy_username[0]) + { + /* authentification */ + snprintf (authbuf, sizeof (authbuf), "%s:%s", + cfg_proxy_username, cfg_proxy_password); + irc_server_base64encode (authbuf, authbuf_base64); + n = snprintf (buffer, sizeof (buffer), + "CONNECT %s:%d HTTP/1.0\r\nProxy-Authorization: Basic %s\r\n\r\n", + address, port, authbuf_base64); + } + else + { + /* no authentification */ + n = snprintf (buffer, sizeof (buffer), + "CONNECT %s:%d HTTP/1.0\r\n\r\n", address, port); + } + + m = send (sock, buffer, n, 0); + if (n != m) + return 1; + + n = recv (sock, buffer, sizeof (buffer), 0); + + /* success result must be like: "HTTP/1.0 200 OK" */ + if (n < 12) + return 1; + + if (memcmp (buffer, "HTTP/", 5) || memcmp (buffer + 9, "200", 3)) + return 1; + + return 0; +} + +/* + * irc_server_resolve: resolve hostname on its IP address + * (works with ipv4 and ipv6) + * return : + * - 0 if resolution was successful + * - 1 if resolution fails + */ + +int +irc_server_resolve (char *hostname, char *ip, int *version) +{ + char ipbuffer[NI_MAXHOST]; + struct addrinfo *res; + + if (version != NULL) + *version = 0; + + res = NULL; + + if (getaddrinfo (hostname, NULL, NULL, &res) != 0) + return 1; + + if (!res) + return 1; + + if (getnameinfo (res->ai_addr, res->ai_addrlen, ipbuffer, sizeof(ipbuffer), NULL, 0, NI_NUMERICHOST) != 0) + { + freeaddrinfo (res); + return 1; + } + + if ((res->ai_family == AF_INET) && (version != NULL)) + *version = 4; + if ((res->ai_family == AF_INET6) && (version != NULL)) + *version = 6; + + strcpy (ip, ipbuffer); + + freeaddrinfo (res); + + return 0; +} + +/* + * irc_server_pass_socks4proxy: establish connection/authentification thru a + * socks4 proxy + * return : + * - 0 if connexion thru proxy was successful + * - 1 if connexion fails + */ + +int +irc_server_pass_socks4proxy (int sock, char *address, int port, char *username) +{ + /* + * socks4 protocol is explained here: + * http://archive.socks.permeo.com/protocol/socks4.protocol + * + */ + + struct s_socks4 + { + char version; /* 1 byte */ /* socks version : 4 or 5 */ + char method; /* 1 byte */ /* socks method : connect (1) or bind (2) */ + unsigned short port; /* 2 bytes */ /* destination port */ + unsigned long address; /* 4 bytes */ /* destination address */ + char user[64]; /* username (64 characters seems to be enought) */ + } socks4; + unsigned char buffer[24]; + char ip_addr[NI_MAXHOST]; + + socks4.version = 4; + socks4.method = 1; + socks4.port = htons (port); + irc_server_resolve (address, ip_addr, NULL); + socks4.address = inet_addr (ip_addr); + strncpy (socks4.user, username, sizeof (socks4.user) - 1); + + send (sock, (char *) &socks4, 8 + strlen (socks4.user) + 1, 0); + recv (sock, buffer, sizeof (buffer), 0); + + if (buffer[0] == 0 && buffer[1] == 90) + return 0; + + return 1; +} + +/* + * irc_server_pass_socks5proxy: establish connection/authentification thru a + * socks5 proxy + * return : + * - 0 if connexion thru proxy was successful + * - 1 if connexion fails + */ + +int +irc_server_pass_socks5proxy (int sock, char *address, int port) +{ + /* + * socks5 protocol is explained in RFC 1928 + * socks5 authentication with username/pass is explained in RFC 1929 + */ + + struct s_sock5 + { + char version; /* 1 byte */ /* socks version : 4 or 5 */ + char nmethods; /* 1 byte */ /* size in byte(s) of field 'method', here 1 byte */ + char method; /* 1-255 bytes */ /* socks method : noauth (0), auth(user/pass) (2), ... */ + } socks5; + unsigned char buffer[288]; + int username_len, password_len, addr_len, addr_buffer_len; + unsigned char *addr_buffer; + + socks5.version = 5; + socks5.nmethods = 1; + + if (cfg_proxy_username && cfg_proxy_username[0]) + socks5.method = 2; /* with authentication */ + else + socks5.method = 0; /* without authentication */ + + send (sock, (char *) &socks5, sizeof(socks5), 0); + /* server socks5 must respond with 2 bytes */ + if (recv (sock, buffer, 2, 0) != 2) + return 1; + + if (cfg_proxy_username && cfg_proxy_username[0]) + { + /* with authentication */ + /* -> socks server must respond with : + * - socks version (buffer[0]) = 5 => socks5 + * - socks method (buffer[1]) = 2 => authentication + */ + + if (buffer[0] != 5 || buffer[1] != 2) + return 1; + + /* authentication as in RFC 1929 */ + username_len = strlen(cfg_proxy_username); + password_len = strlen(cfg_proxy_password); + + /* make username/password buffer */ + buffer[0] = 1; + buffer[1] = (unsigned char) username_len; + memcpy(buffer + 2, cfg_proxy_username, username_len); + buffer[2 + username_len] = (unsigned char) password_len; + memcpy (buffer + 3 + username_len, cfg_proxy_password, password_len); + + send (sock, buffer, 3 + username_len + password_len, 0); + + /* server socks5 must respond with 2 bytes */ + if (recv (sock, buffer, 2, 0) != 2) + return 1; + + /* buffer[1] = auth state, must be 0 for success */ + if (buffer[1] != 0) + return 1; + } + else + { + /* without authentication */ + /* -> socks server must respond with : + * - socks version (buffer[0]) = 5 => socks5 + * - socks method (buffer[1]) = 0 => no authentication + */ + if (!(buffer[0] == 5 && buffer[1] == 0)) + return 1; + } + + /* authentication successful then giving address/port to connect */ + addr_len = strlen(address); + addr_buffer_len = 4 + 1 + addr_len + 2; + addr_buffer = (unsigned char *) malloc (addr_buffer_len * sizeof(*addr_buffer)); + if (!addr_buffer) + return 1; + addr_buffer[0] = 5; /* version 5 */ + addr_buffer[1] = 1; /* command: 1 for connect */ + addr_buffer[2] = 0; /* reserved */ + addr_buffer[3] = 3; /* address type : ipv4 (1), domainname (3), ipv6 (4) */ + addr_buffer[4] = (unsigned char) addr_len; + memcpy (addr_buffer + 5, address, addr_len); /* server address */ + *((unsigned short *) (addr_buffer + 5 + addr_len)) = htons (port); /* server port */ + + send (sock, addr_buffer, addr_buffer_len, 0); + free (addr_buffer); + + /* dialog with proxy server */ + if (recv (sock, buffer, 4, 0) != 4) + return 1; + + if (!(buffer[0] == 5 && buffer[1] == 0)) + return 1; + + /* buffer[3] = address type */ + switch(buffer[3]) + { + case 1 : + /* ipv4 + * server socks return server bound address and port + * address of 4 bytes and port of 2 bytes (= 6 bytes) + */ + if (recv (sock, buffer, 6, 0) != 6) + return 1; + break; + case 3: + /* domainname + * server socks return server bound address and port + */ + /* reading address length */ + if (recv (sock, buffer, 1, 0) != 1) + return 1; + addr_len = buffer[0]; + /* reading address + port = addr_len + 2 */ + if (recv (sock, buffer, addr_len + 2, 0) != (addr_len + 2)) + return 1; + break; + case 4 : + /* ipv6 + * server socks return server bound address and port + * address of 16 bytes and port of 2 bytes (= 18 bytes) + */ + if (recv (sock, buffer, 18, 0) != 18) + return 1; + break; + default: + return 1; + } + + return 0; +} + +/* + * irc_server_pass_proxy: establish connection/authentification to a proxy + * return : + * - 0 if connexion throw proxy was successful + * - 1 if connexion fails + */ + +int +irc_server_pass_proxy (int sock, char *address, int port, char *username) +{ + if (strcmp (cfg_proxy_type_values[cfg_proxy_type], "http") == 0) + return irc_server_pass_httpproxy (sock, address, port); + if (strcmp (cfg_proxy_type_values[cfg_proxy_type], "socks4") == 0) + return irc_server_pass_socks4proxy (sock, address, port, username); + if (strcmp (cfg_proxy_type_values[cfg_proxy_type], "socks5") == 0) + return irc_server_pass_socks5proxy (sock, address, port); + + return 1; +} + +/* + * irc_server_child: child process trying to connect to server + */ + +int +irc_server_child (t_irc_server *server) +{ + struct addrinfo hints, *res, *res_local; + int rc; + + res = NULL; + res_local = NULL; + + if (cfg_proxy_use) + { + /* get info about server */ + memset (&hints, 0, sizeof (hints)); + hints.ai_family = (cfg_proxy_ipv6) ? AF_INET6 : AF_INET; + hints.ai_socktype = SOCK_STREAM; + if (getaddrinfo (cfg_proxy_address, NULL, &hints, &res) !=0) + { + write(server->child_write, "1", 1); + return 0; + } + if (!res) + { + write(server->child_write, "1", 1); + return 0; + } + if ((cfg_proxy_ipv6 && (res->ai_family != AF_INET6)) + || ((!cfg_proxy_ipv6 && (res->ai_family != AF_INET)))) + { + write (server->child_write, "2", 1); + freeaddrinfo (res); + return 0; + } + + if (cfg_proxy_ipv6) + ((struct sockaddr_in6 *)(res->ai_addr))->sin6_port = htons (cfg_proxy_port); + else + ((struct sockaddr_in *)(res->ai_addr))->sin_port = htons (cfg_proxy_port); + + /* connect to server */ + if (connect (server->sock, res->ai_addr, res->ai_addrlen) != 0) + { + write(server->child_write, "3", 1); + freeaddrinfo (res); + return 0; + } + + if (irc_server_pass_proxy (server->sock, server->address, server->port, server->username)) + { + write(server->child_write, "4", 1); + freeaddrinfo (res); + return 0; + } + } + else + { + /* set local hostname/IP if asked by user */ + if (server->hostname && server->hostname[0]) + { + memset (&hints, 0, sizeof(hints)); + hints.ai_family = (server->ipv6) ? AF_INET6 : AF_INET; + hints.ai_socktype = SOCK_STREAM; + rc = getaddrinfo (server->hostname, NULL, &hints, &res_local); + if ((rc != 0) || !res_local + || (server->ipv6 && (res_local->ai_family != AF_INET6)) + || ((!server->ipv6 && (res_local->ai_family != AF_INET)))) + { + write (server->child_write, "5", 1); + if (res_local) + freeaddrinfo (res_local); + return 0; + } + if (bind (server->sock, res_local->ai_addr, res_local->ai_addrlen) < 0) + { + write (server->child_write, "5", 1); + if (res_local) + freeaddrinfo (res_local); + return 0; + } + } + + /* get info about server */ + memset (&hints, 0, sizeof(hints)); + hints.ai_family = (server->ipv6) ? AF_INET6 : AF_INET; + hints.ai_socktype = SOCK_STREAM; + rc = getaddrinfo (server->address, NULL, &hints, &res); + if ((rc != 0) || !res) + { + write (server->child_write, "1", 1); + if (res) + freeaddrinfo (res); + return 0; + } + if ((server->ipv6 && (res->ai_family != AF_INET6)) + || ((!server->ipv6 && (res->ai_family != AF_INET)))) + { + write (server->child_write, "2", 1); + if (res) + freeaddrinfo (res); + if (res_local) + freeaddrinfo (res_local); + return 0; + } + + /* connect to server */ + if (server->ipv6) + ((struct sockaddr_in6 *)(res->ai_addr))->sin6_port = htons (server->port); + else + ((struct sockaddr_in *)(res->ai_addr))->sin_port = htons (server->port); + + if (connect (server->sock, res->ai_addr, res->ai_addrlen) != 0) + { + write (server->child_write, "3", 1); + if (res) + freeaddrinfo (res); + if (res_local) + freeaddrinfo (res_local); + return 0; + } + } + + write (server->child_write, "0", 1); + if (res) + freeaddrinfo (res); + if (res_local) + freeaddrinfo (res_local); + return 0; +} + +/* + * irc_server_connect: connect to an IRC server + */ + +int +irc_server_connect (t_irc_server *server, int disable_autojoin) +{ + int child_pipe[2], set; +#ifndef __CYGWIN__ + pid_t pid; +#endif + +#ifndef HAVE_GNUTLS + if (server->ssl) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s cannot connect with SSL since WeeChat was not built " + "with GNUtls support\n"), WEECHAT_ERROR); + return 0; + } +#endif + irc_display_prefix (server, server->buffer, GUI_PREFIX_INFO); + if (cfg_proxy_use) + { + gui_printf (server->buffer, + _("%s: connecting to server %s:%d%s%s via %s proxy %s:%d%s...\n"), + PACKAGE_NAME, server->address, server->port, + (server->ipv6) ? " (IPv6)" : "", + (server->ssl) ? " (SSL)" : "", + cfg_proxy_type_values[cfg_proxy_type], cfg_proxy_address, cfg_proxy_port, + (cfg_proxy_ipv6) ? " (IPv6)" : ""); + weechat_log_printf (_("Connecting to server %s:%d%s%s via %s proxy %s:%d%s...\n"), + server->address, server->port, + (server->ipv6) ? " (IPv6)" : "", + (server->ssl) ? " (SSL)" : "", + cfg_proxy_type_values[cfg_proxy_type], cfg_proxy_address, cfg_proxy_port, + (cfg_proxy_ipv6) ? " (IPv6)" : ""); + } + else + { + gui_printf (server->buffer, + _("%s: connecting to server %s:%d%s%s...\n"), + PACKAGE_NAME, server->address, server->port, + (server->ipv6) ? " (IPv6)" : "", + (server->ssl) ? " (SSL)" : ""); + weechat_log_printf (_("Connecting to server %s:%d%s%s...\n"), + server->address, server->port, + (server->ipv6) ? " (IPv6)" : "", + (server->ssl) ? " (SSL)" : ""); + } + + /* close any opened connection and kill child process if running */ + irc_server_close_connection (server); + + /* init SSL if asked */ + server->ssl_connected = 0; +#ifdef HAVE_GNUTLS + if (server->ssl) + { + if (gnutls_init (&server->gnutls_sess, GNUTLS_CLIENT) != 0) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s gnutls init error\n"), WEECHAT_ERROR); + return 0; + } + gnutls_set_default_priority (server->gnutls_sess); + gnutls_certificate_type_set_priority (server->gnutls_sess, gnutls_cert_type_prio); + gnutls_protocol_set_priority (server->gnutls_sess, gnutls_prot_prio); + gnutls_credentials_set (server->gnutls_sess, GNUTLS_CRD_CERTIFICATE, gnutls_xcred); + server->ssl_connected = 1; + } +#endif + + /* create pipe for child process */ + if (pipe (child_pipe) < 0) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s cannot create pipe\n"), WEECHAT_ERROR); + return 0; + } + server->child_read = child_pipe[0]; + server->child_write = child_pipe[1]; + + /* create socket and set options */ + if (cfg_proxy_use) + server->sock = socket ((cfg_proxy_ipv6) ? AF_INET6 : AF_INET, SOCK_STREAM, 0); + else + server->sock = socket ((server->ipv6) ? AF_INET6 : AF_INET, SOCK_STREAM, 0); + if (server->sock == -1) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s cannot create socket\n"), WEECHAT_ERROR); + return 0; + } + + /* set SO_REUSEADDR option for socket */ + set = 1; + if (setsockopt (server->sock, SOL_SOCKET, SO_REUSEADDR, + (void *) &set, sizeof (set)) == -1) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s cannot set socket option \"SO_REUSEADDR\"\n"), + WEECHAT_WARNING); + } + + /* set SO_KEEPALIVE option for socket */ + set = 1; + if (setsockopt (server->sock, SOL_SOCKET, SO_KEEPALIVE, + (void *) &set, sizeof (set)) == -1) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_ERROR); + gui_printf (server->buffer, + _("%s cannot set socket option \"SO_KEEPALIVE\"\n"), + WEECHAT_WARNING); + } + +#ifdef __CYGWIN__ + /* connection may block under Cygwin, there's no other known way + to do better today, since connect() in child process seems not to work + any suggestion is welcome to improve that! + */ + irc_server_child (server); + server->child_pid = 0; + irc_server_child_read (server); +#else + switch (pid = fork ()) + { + /* fork failed */ + case -1: + irc_server_close_connection (server); + return 0; + /* child process */ + case 0: + setuid (getuid ()); + irc_server_child (server); + _exit (EXIT_SUCCESS); + } + /* parent process */ + server->child_pid = pid; +#endif + + server->disable_autojoin = disable_autojoin; + + return 1; +} + +/* + * irc_server_reconnect: reconnect to a server (after disconnection) + */ + +void +irc_server_reconnect (t_irc_server *server) +{ + irc_display_prefix (server, server->buffer, GUI_PREFIX_INFO); + gui_printf (server->buffer, _("%s: Reconnecting to server...\n"), + PACKAGE_NAME); + server->reconnect_start = 0; + + if (irc_server_connect (server, 0)) + server->reconnect_join = 1; + else + irc_server_reconnect_schedule (server); +} + +/* + * irc_server_auto_connect: auto-connect to servers (called at startup) + */ + +void +irc_server_auto_connect (int auto_connect, int temp_server) +{ + t_irc_server *ptr_server; + + for (ptr_server = irc_servers; ptr_server; + ptr_server = ptr_server->next_server) + { + if ( ((temp_server) && (ptr_server->temp_server)) + || ((!temp_server) && (auto_connect) && (ptr_server->autoconnect)) ) + { + (void) gui_buffer_new (gui_current_window, ptr_server, NULL, + GUI_BUFFER_TYPE_STANDARD, 1); + gui_window_redraw_buffer (gui_current_window->buffer); + if (!irc_server_connect (ptr_server, 0)) + irc_server_reconnect_schedule (ptr_server); + } + } +} + +/* + * irc_server_disconnect: disconnect from an irc server + */ + +void +irc_server_disconnect (t_irc_server *server, int reconnect) +{ + t_irc_channel *ptr_channel; + + if (server->is_connected) + { + /* write disconnection message on each channel/private buffer */ + for (ptr_channel = server->channels; ptr_channel; + ptr_channel = ptr_channel->next_channel) + { + irc_nick_free_all (ptr_channel); + irc_display_prefix (NULL, ptr_channel->buffer, GUI_PREFIX_INFO); + gui_printf (ptr_channel->buffer, _("Disconnected from server!\n")); + gui_nicklist_draw (ptr_channel->buffer, 1, 1); + gui_status_draw (ptr_channel->buffer, 1); + } + } + + irc_server_close_connection (server); + + if (server->buffer) + { + irc_display_prefix (server, server->buffer, GUI_PREFIX_INFO); + gui_printf (server->buffer, _("Disconnected from server!\n")); + } + + if (server->nick_modes) + { + free (server->nick_modes); + server->nick_modes = NULL; + } + if (server->prefix) + { + free (server->prefix); + server->prefix = NULL; + } + server->is_away = 0; + server->away_time = 0; + server->lag = 0; + server->lag_check_time.tv_sec = 0; + server->lag_check_time.tv_usec = 0; + server->lag_next_check = time (NULL) + cfg_irc_lag_check; + + if ((reconnect) && (server->autoreconnect)) + irc_server_reconnect_schedule (server); + else + server->reconnect_start = 0; + + /* discard current nick if no reconnection asked */ + if (!reconnect && server->nick) + { + free (server->nick); + server->nick = NULL; + } + + gui_window_redraw_buffer (gui_current_window->buffer); +} + +/* + * irc_server_disconnect_all: disconnect from all irc servers + */ + +void +irc_server_disconnect_all () +{ + t_irc_server *ptr_server; + + for (ptr_server = irc_servers; ptr_server; ptr_server = ptr_server->next_server) + irc_server_disconnect (ptr_server, 0); +} + +/* + * irc_server_autojoin_channels: autojoin (or rejoin) channels + */ + +void +irc_server_autojoin_channels (t_irc_server *server) +{ + t_irc_channel *ptr_channel; + + /* auto-join after disconnection (only rejoins opened channels) */ + if (!server->disable_autojoin && server->reconnect_join && server->channels) + { + for (ptr_channel = server->channels; ptr_channel; + ptr_channel = ptr_channel->next_channel) + { + if (ptr_channel->type == IRC_CHANNEL_TYPE_CHANNEL) + { + if (ptr_channel->key) + irc_server_sendf (server, "JOIN %s %s", + ptr_channel->name, ptr_channel->key); + else + irc_server_sendf (server, "JOIN %s", + ptr_channel->name); + } + } + server->reconnect_join = 0; + } + else + { + /* auto-join when connecting to server for first time */ + if (!server->disable_autojoin && server->autojoin && server->autojoin[0]) + irc_send_cmd_join (server, NULL, server->autojoin); + } + + server->disable_autojoin = 0; +} + +/* + * irc_server_search: return pointer on a server with a name + */ + +t_irc_server * +irc_server_search (char *servername) +{ + t_irc_server *ptr_server; + + if (!servername) + return NULL; + + for (ptr_server = irc_servers; ptr_server; + ptr_server = ptr_server->next_server) + { + if (strcmp (ptr_server->name, servername) == 0) + return ptr_server; + } + return NULL; +} + +/* + * irc_server_get_number_connected: returns number of connected server + */ + +int +irc_server_get_number_connected () +{ + t_irc_server *ptr_server; + int number; + + number = 0; + for (ptr_server = irc_servers; ptr_server; ptr_server = ptr_server->next_server) + { + if (ptr_server->is_connected) + number++; + } + return number; +} + +/* + * irc_server_get_number_buffer: returns position of a server and total number of + * buffers with a buffer + */ + +void +irc_server_get_number_buffer (t_irc_server *server, + int *server_pos, int *server_total) +{ + t_irc_server *ptr_server; + + *server_pos = 0; + *server_total = 0; + for (ptr_server = irc_servers; ptr_server; + ptr_server = ptr_server->next_server) + { + if (ptr_server->buffer) + { + (*server_total)++; + if (ptr_server == server) + *server_pos = *server_total; + } + } +} + +/* + * irc_server_name_already_exists: return 1 if server name already exists + * otherwise return 0 + */ + +int +irc_server_name_already_exists (char *name) +{ + t_irc_server *ptr_server; + + if (!name) + return 0; + + for (ptr_server = irc_servers; ptr_server; ptr_server = ptr_server->next_server) + { + if (strcmp (ptr_server->name, name) == 0) + return 1; + } + return 0; +} + +/* + * irc_server_get_channel_count: return number of channels for server + */ + +int +irc_server_get_channel_count (t_irc_server *server) +{ + int count; + t_irc_channel *ptr_channel; + + count = 0; + for (ptr_channel = server->channels; ptr_channel; + ptr_channel = ptr_channel->next_channel) + { + if (ptr_channel->type == IRC_CHANNEL_TYPE_CHANNEL) + count++; + } + return count; +} + +/* + * irc_server_get_pv_count: return number of pv for server + */ + +int +irc_server_get_pv_count (t_irc_server *server) +{ + int count; + t_irc_channel *ptr_channel; + + count = 0; + for (ptr_channel = server->channels; ptr_channel; + ptr_channel = ptr_channel->next_channel) + { + if (ptr_channel->type != IRC_CHANNEL_TYPE_CHANNEL) + count++; + } + return count; +} + +/* + * irc_server_remove_away: remove away for all chans/nicks (for all servers) + */ + +void +irc_server_remove_away () +{ + t_irc_server *ptr_server; + t_irc_channel *ptr_channel; + + for (ptr_server = irc_servers; ptr_server; ptr_server = ptr_server->next_server) + { + if (ptr_server->is_connected) + { + for (ptr_channel = ptr_server->channels; ptr_channel; ptr_channel = ptr_channel->next_channel) + { + if (ptr_channel->type == IRC_CHANNEL_TYPE_CHANNEL) + irc_channel_remove_away (ptr_channel); + } + } + } +} + +/* + * irc_server_check_away: check for away on all channels (for all servers) + */ + +void +irc_server_check_away () +{ + t_irc_server *ptr_server; + t_irc_channel *ptr_channel; + + for (ptr_server = irc_servers; ptr_server; ptr_server = ptr_server->next_server) + { + if (ptr_server->is_connected) + { + for (ptr_channel = ptr_server->channels; ptr_channel; ptr_channel = ptr_channel->next_channel) + { + if (ptr_channel->type == IRC_CHANNEL_TYPE_CHANNEL) + irc_channel_check_away (ptr_server, ptr_channel, 0); + } + } + } +} + +/* + * irc_server_set_away: set/unset away status for a server (all channels) + */ + +void +irc_server_set_away (t_irc_server *server, char *nick, int is_away) +{ + t_irc_channel *ptr_channel; + + for (ptr_channel = server->channels; ptr_channel; ptr_channel = ptr_channel->next_channel) + { + if (server->is_connected) + { + if (ptr_channel->type == IRC_CHANNEL_TYPE_CHANNEL) + irc_channel_set_away (ptr_channel, nick, is_away); + } + } +} + +/* + * irc_server_get_default_notify_level: get default notify level for server + */ + +int +irc_server_get_default_notify_level (t_irc_server *server) +{ + int notify, value; + char *pos; + + notify = GUI_NOTIFY_LEVEL_DEFAULT; + + if (!server || !server->notify_levels) + return notify; + + pos = strstr (server->notify_levels, "*:"); + if (pos) + { + pos += 2; + if (pos[0]) + { + value = (int)(pos[0] - '0'); + if ((value >= GUI_NOTIFY_LEVEL_MIN) + && (value <= GUI_NOTIFY_LEVEL_MAX)) + notify = value; + } + } + + return notify; +} + +/* + * irc_server_set_default_notify_level: set default notify level for server + */ + +void +irc_server_set_default_notify_level (t_irc_server *server, int notify) +{ + char level_string[2]; + + if (server) + { + level_string[0] = notify + '0'; + level_string[1] = '\0'; + config_option_list_set (&(server->notify_levels), "*", level_string); + } +} + +/* + * irc_server_print_log: print server infos in log (usually for crash dump) + */ + +void +irc_server_print_log (t_irc_server *server) +{ + weechat_log_printf ("[server %s (addr:0x%X)]\n", server->name, server); + weechat_log_printf (" autoconnect . . . . : %d\n", server->autoconnect); + weechat_log_printf (" autoreconnect . . . : %d\n", server->autoreconnect); + weechat_log_printf (" autoreconnect_delay : %d\n", server->autoreconnect_delay); + weechat_log_printf (" temp_server . . . . : %d\n", server->temp_server); + weechat_log_printf (" address . . . . . . : '%s'\n", server->address); + weechat_log_printf (" port. . . . . . . . : %d\n", server->port); + weechat_log_printf (" ipv6. . . . . . . . : %d\n", server->ipv6); + weechat_log_printf (" ssl . . . . . . . . : %d\n", server->ssl); + weechat_log_printf (" password. . . . . . : '%s'\n", + (server->password && server->password[0]) ? + "(hidden)" : server->password); + weechat_log_printf (" nick1 . . . . . . . : '%s'\n", server->nick1); + weechat_log_printf (" nick2 . . . . . . . : '%s'\n", server->nick2); + weechat_log_printf (" nick3 . . . . . . . : '%s'\n", server->nick3); + weechat_log_printf (" username. . . . . . : '%s'\n", server->username); + weechat_log_printf (" realname. . . . . . : '%s'\n", server->realname); + weechat_log_printf (" command . . . . . . : '%s'\n", + (server->command && server->command[0]) ? + "(hidden)" : server->command); + weechat_log_printf (" command_delay . . . : %d\n", server->command_delay); + weechat_log_printf (" autojoin. . . . . . : '%s'\n", server->autojoin); + weechat_log_printf (" autorejoin. . . . . : %d\n", server->autorejoin); + weechat_log_printf (" notify_levels . . . : %s\n", server->notify_levels); + weechat_log_printf (" child_pid . . . . . : %d\n", server->child_pid); + weechat_log_printf (" child_read . . . . : %d\n", server->child_read); + weechat_log_printf (" child_write . . . . : %d\n", server->child_write); + weechat_log_printf (" sock. . . . . . . . : %d\n", server->sock); + weechat_log_printf (" is_connected. . . . : %d\n", server->is_connected); + weechat_log_printf (" ssl_connected . . . : %d\n", server->ssl_connected); + weechat_log_printf (" unterminated_message: '%s'\n", server->unterminated_message); + weechat_log_printf (" nick. . . . . . . . : '%s'\n", server->nick); + weechat_log_printf (" nick_modes. . . . . : '%s'\n", server->nick_modes); + weechat_log_printf (" prefix. . . . . . . : '%s'\n", server->prefix); + weechat_log_printf (" reconnect_start . . : %ld\n", server->reconnect_start); + weechat_log_printf (" command_time. . . . : %ld\n", server->command_time); + weechat_log_printf (" reconnect_join. . . : %d\n", server->reconnect_join); + weechat_log_printf (" disable_autojoin. . : %d\n", server->disable_autojoin); + weechat_log_printf (" is_away . . . . . . : %d\n", server->is_away); + weechat_log_printf (" away_message. . . . : '%s'\n", server->away_message); + weechat_log_printf (" away_time . . . . . : %ld\n", server->away_time); + weechat_log_printf (" lag . . . . . . . . : %d\n", server->lag); + weechat_log_printf (" lag_check_time. . . : tv_sec:%d, tv_usec:%d\n", + server->lag_check_time.tv_sec, + server->lag_check_time.tv_usec); + weechat_log_printf (" lag_next_check. . . : %ld\n", server->lag_next_check); + weechat_log_printf (" last_user_message . : %ld\n", server->last_user_message); + weechat_log_printf (" outqueue. . . . . . : 0x%X\n", server->outqueue); + weechat_log_printf (" last_outqueue . . . : 0x%X\n", server->last_outqueue); + weechat_log_printf (" buffer. . . . . . . : 0x%X\n", server->buffer); + weechat_log_printf (" channels. . . . . . : 0x%X\n", server->channels); + weechat_log_printf (" last_channel. . . . : 0x%X\n", server->last_channel); + weechat_log_printf (" prev_server . . . . : 0x%X\n", server->prev_server); + weechat_log_printf (" next_server . . . . : 0x%X\n", server->next_server); +} |