path: root/irc_cap.c

/********************************************************************\
  * BitlBee -- An IRC to other IM-networks gateway                     *
  *                                                                    *
  * Copyright 2002-2013 Wilmer van der Gaast and others                *
  \********************************************************************/

/* IRCv3 CAP command
 *
 * Specs:
 *  - v3.1: http://ircv3.net/specs/core/capability-negotiation-3.1.html
 *  - v3.2: http://ircv3.net/specs/core/capability-negotiation-3.2.html
 *
 * */

/*
  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 2 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 with
  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
  if not, write to the Free Software Foundation, Inc., 51 Franklin St.,
  Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "bitlbee.h"

typedef struct {
	char *name;
	irc_cap_flag_t flag;
} cap_info_t;

static const cap_info_t supported_caps[] = {
	{"sasl", CAP_SASL},
	{"multi-prefix", CAP_MULTI_PREFIX},
	{"extended-join", CAP_EXTENDED_JOIN},
	{"away-notify", CAP_AWAY_NOTIFY},
	{"userhost-in-names", CAP_USERHOST_IN_NAMES},
	{NULL},
};

static irc_cap_flag_t cap_flag_from_string(char *cap_name)
{
	int i;

	if (!cap_name || !cap_name[0]) {
		return 0;
	}

	if (cap_name[0] == '-') {
		cap_name++;
	}

	for (i = 0; supported_caps[i].name; i++) {
		if (strcmp(supported_caps[i].name, cap_name) == 0) {
			return supported_caps[i].flag;
		}
	}
	return 0;
}

static gboolean irc_cmd_cap_req(irc_t *irc, char *caps)
{
	int i;
	char *lower = NULL;
	char **split = NULL;
	irc_cap_flag_t new_caps = irc->caps;

	if (!caps || !caps[0]) {
		return FALSE;
	}

	lower = g_ascii_strdown(caps, -1);
	split = g_strsplit(lower, " ", -1);
	g_free(lower);

	for (i = 0; split[i]; i++) {
		gboolean remove;
		irc_cap_flag_t flag;

		if (!split[i][0]) {
			continue;   /* skip empty items (consecutive spaces) */
		}

		remove = (split[i][0] == '-');
		flag = cap_flag_from_string(split[i]);
		
		if (!flag || (remove && !(irc->caps & flag))) {
			/* unsupported cap, or removing something that isn't there */
			g_strfreev(split);
			return FALSE;
		}

		if (remove) {
			new_caps &= ~flag;
		} else {
			new_caps |= flag;
		}
	}

	/* if we got here, set the new caps and ack */
	irc->caps = new_caps;

	g_strfreev(split);
	return TRUE;
}

/* version can be 0, 302, 303, or garbage from user input. thanks user input */
static void irc_cmd_cap_ls(irc_t *irc, long version)
{
	int i;
	GString *str = g_string_sized_new(256);

	for (i = 0; supported_caps[i].name; i++) {
		if (i != 0) {
			g_string_append_c(str, ' ');
		}
		g_string_append(str, supported_caps[i].name);

		if (version >= 302 && supported_caps[i].flag == CAP_SASL) {
			g_string_append(str, "=PLAIN");
		}
	}

	irc_send_cap(irc, "LS", str->str);

	g_string_free(str, TRUE);
}

/* this one looks suspiciously similar to cap ls,
 * but cap-3.2 will make them very different */
static void irc_cmd_cap_list(irc_t *irc)
{
	int i;
	gboolean first = TRUE;
	GString *str = g_string_sized_new(256);

	for (i = 0; supported_caps[i].name; i++) {
		if (irc->caps & supported_caps[i].flag) {
			if (!first) {
				g_string_append_c(str, ' ');
			}
			first = FALSE;

			g_string_append(str, supported_caps[i].name);
		}
	}

	irc_send_cap(irc, "LIST", str->str);

	g_string_free(str, TRUE);
}

void irc_cmd_cap(irc_t *irc, char **cmd)
{
	if (!(irc->status & USTATUS_LOGGED_IN)) {
		/* Put registration on hold until CAP END */
		irc->status |= USTATUS_CAP_PENDING;
	}

	if (g_strcasecmp(cmd[1], "LS") == 0) {
		irc_cmd_cap_ls(irc, cmd[2] ? strtol(cmd[2], NULL, 10) : 0);

	} else if (g_strcasecmp(cmd[1], "LIST") == 0) {
		irc_cmd_cap_list(irc);

	} else if (g_strcasecmp(cmd[1], "REQ") == 0) {
		gboolean ack = irc_cmd_cap_req(irc, cmd[2]);

		irc_send_cap(irc, ack ? "ACK" : "NAK", cmd[2] ? : "");

	} else if (g_strcasecmp(cmd[1], "END") == 0) {
		if (!(irc->status & USTATUS_CAP_PENDING)) {
			return;
		}
		irc->status &= ~USTATUS_CAP_PENDING;

		if (irc->status & USTATUS_SASL_PLAIN_PENDING) {
			irc_send_num(irc, 906, ":SASL authentication aborted");
			irc->status &= ~USTATUS_SASL_PLAIN_PENDING;
		}

		irc_check_login(irc);

	} else {
		irc_send_num(irc, 410, "%s :Invalid CAP command", cmd[1]);
	}

}

et(source);
				dup2(new_fd, source);
				closesocket(new_fd);
				phb->fd = source;
				phb->inpa = b_input_add(source, B_EV_IO_WRITE, proxy_connected, phb);
				return FALSE;
			}
		}
		closesocket(source);
		source = -1;
		/* socket is dead, but continue to clean up */
	} else {
		sock_make_blocking(source);
	}

	freeaddrinfo(phb->gai);
	phb->gai = NULL;

	b_event_remove(phb->inpa);
	phb->inpa = 0;

	if (phb->proxy_func) {
		phb->proxy_func(phb->proxy_data, source, B_EV_IO_READ);
	} else {
		phb_connected(phb, source);
	}

	return FALSE;
}

static int proxy_connect_none(const char *host, unsigned short port_, struct PHB *phb)
{
	struct sockaddr_in me;
	int fd = -1;

	if (phb->gai_cur == NULL) {
		int ret;
		char port[6];
		struct addrinfo hints;

		g_snprintf(port, sizeof(port), "%d", port_);

		memset(&hints, 0, sizeof(struct addrinfo));
		hints.ai_family = AF_UNSPEC;
		hints.ai_socktype = SOCK_STREAM;
		hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;

		if (!(ret = getaddrinfo(host, port, &hints, &phb->gai))) {
			phb->gai_cur = phb->gai;
		} else {
			event_debug("gai(): %s\n", gai_strerror(ret));
		}
	}

	for (; phb->gai_cur; phb->gai_cur = phb->gai_cur->ai_next) {
		if ((fd = socket(phb->gai_cur->ai_family, phb->gai_cur->ai_socktype, phb->gai_cur->ai_protocol)) < 0) {
			event_debug("socket failed: %d\n", errno);
			continue;
		}

		sock_make_nonblocking(fd);

		if (global.conf->iface_out) {
			me.sin_family = AF_INET;
			me.sin_port = 0;
			me.sin_addr.s_addr = inet_addr(global.conf->iface_out);

			if (bind(fd, (struct sockaddr *) &me, sizeof(me)) != 0) {
				event_debug("bind( %d, \"%s\" ) failure\n", fd, global.conf->iface_out);
			}
		}

		event_debug("proxy_connect_none( \"%s\", %d ) = %d\n", host, port_, fd);

		if (connect(fd, phb->gai_cur->ai_addr, phb->gai_cur->ai_addrlen) < 0 && !sockerr_again()) {
			event_debug("connect failed: %s\n", strerror(errno));
			closesocket(fd);
			fd = -1;
			continue;
		} else {
			phb->inpa = b_input_add(fd, B_EV_IO_WRITE, proxy_connected, phb);
			phb->fd = fd;

			break;
		}
	}

	if (fd < 0 && host) {
		phb_free(phb, TRUE);
	}

	return fd;
}


/* Connecting to HTTP proxies */

#define HTTP_GOODSTRING "HTTP/1.0 200"
#define HTTP_GOODSTRING2 "HTTP/1.1 200"

static gboolean http_canread(gpointer data, gint source, b_input_condition cond)
{
	int nlc = 0;
	int pos = 0;
	struct PHB *phb = data;
	char inputline[8192];

	b_event_remove(phb->inpa);

	while ((pos < sizeof(inputline) - 1) && (nlc != 2) && (read(source, &inputline[pos++], 1) == 1)) {
		if (inputline[pos - 1] == '\n') {
			nlc++;
		} else if (inputline[pos - 1] != '\r') {
			nlc = 0;
		}
	}
	inputline[pos] = '\0';

	if ((memcmp(HTTP_GOODSTRING, inputline, strlen(HTTP_GOODSTRING)) == 0) ||
	    (memcmp(HTTP_GOODSTRING2, inputline, strlen(HTTP_GOODSTRING2)) == 0)) {
		return phb_connected(phb, source);
	}

	return phb_free(phb, FALSE);
}

static gboolean http_canwrite(gpointer data, gint source, b_input_condition cond)
{
	char cmd[384];
	struct PHB *phb = data;
	socklen_t len;
	int error = ETIMEDOUT;

	if (phb->inpa > 0) {
		b_event_remove(phb->inpa);
	}
	len = sizeof(error);
	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
		return phb_free(phb, FALSE);
	}
	sock_make_blocking(source);

	g_snprintf(cmd, sizeof(cmd), "CONNECT %s:%d HTTP/1.1\r\nHost: %s:%d\r\n", phb->host, phb->port,
	           phb->host, phb->port);
	if (send(source, cmd, strlen(cmd), 0) < 0) {
		return phb_free(phb, FALSE);
	}

	if (strlen(proxyuser) > 0) {
		char *t1, *t2;
		t1 = g_strdup_printf("%s:%s", proxyuser, proxypass);
		t2 = tobase64(t1);
		g_free(t1);
		g_snprintf(cmd, sizeof(cmd), "Proxy-Authorization: Basic %s\r\n", t2);
		g_free(t2);
		if (send(source, cmd, strlen(cmd), 0) < 0) {
			return phb_free(phb, FALSE);
		}
	}

	g_snprintf(cmd, sizeof(cmd), "\r\n");
	if (send(source, cmd, strlen(cmd), 0) < 0) {
		return phb_free(phb, FALSE);
	}

	phb->inpa = b_input_add(source, B_EV_IO_READ, http_canread, phb);

	return FALSE;
}

static int proxy_connect_http(const char *host, unsigned short port, struct PHB *phb)
{
	phb->host = g_strdup(host);
	phb->port = port;
	phb->proxy_func = http_canwrite;
	phb->proxy_data = phb;

	return(proxy_connect_none(proxyhost, proxyport, phb));
}


/* Connecting to SOCKS4 proxies */

static gboolean s4_canread(gpointer data, gint source, b_input_condition cond)
{
	unsigned char packet[12];
	struct PHB *phb = data;

	b_event_remove(phb->inpa);

	memset(packet, 0, sizeof(packet));
	if (read(source, packet, 9) >= 4 && packet[1] == 90) {
		return phb_connected(phb, source);
	}

	return phb_free(phb, FALSE);
}

static gboolean s4_canwrite(gpointer data, gint source, b_input_condition cond)
{
	unsigned char packet[12];
	struct hostent *hp;
	struct PHB *phb = data;
	socklen_t len;
	int error = ETIMEDOUT;
	gboolean is_socks4a = (proxytype == PROXY_SOCKS4A);

	if (phb->inpa > 0) {
		b_event_remove(phb->inpa);
	}
	len = sizeof(error);
	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
		return phb_free(phb, FALSE);
	}
	sock_make_blocking(source);

	if (!is_socks4a && !(hp = gethostbyname(phb->host))) {
		return phb_free(phb, FALSE);
	}

	packet[0] = 4;
	packet[1] = 1;
	packet[2] = phb->port >> 8;
	packet[3] = phb->port & 0xff;
	if (is_socks4a) {
		packet[4] = 0;
		packet[5] = 0;
		packet[6] = 0;
		packet[7] = 1;
	} else {
		packet[4] = (unsigned char) (hp->h_addr_list[0])[0];
		packet[5] = (unsigned char) (hp->h_addr_list[0])[1];
		packet[6] = (unsigned char) (hp->h_addr_list[0])[2];
		packet[7] = (unsigned char) (hp->h_addr_list[0])[3];
	}
	packet[8] = 0;
	if (write(source, packet, 9) != 9) {
		return phb_free(phb, FALSE);
	}

	if (is_socks4a) {
		size_t host_len = strlen(phb->host) + 1; /* include the \0 */

		if (write(source, phb->host, host_len) != host_len) {
			return phb_free(phb, FALSE);
		}
	}

	phb->inpa = b_input_add(source, B_EV_IO_READ, s4_canread, phb);

	return FALSE;
}

static int proxy_connect_socks4(const char *host, unsigned short port, struct PHB *phb)
{
	phb->host = g_strdup(host);
	phb->port = port;
	phb->proxy_func = s4_canwrite;
	phb->proxy_data = phb;

	return(proxy_connect_none(proxyhost, proxyport, phb));
}


/* Connecting to SOCKS5 proxies */

static gboolean s5_canread_again(gpointer data, gint source, b_input_condition cond)
{
	unsigned char buf[512];
	struct PHB *phb = data;

	b_event_remove(phb->inpa);

	if (read(source, buf, 10) < 10) {
		return phb_free(phb, FALSE);
	}
	if ((buf[0] != 0x05) || (buf[1] != 0x00)) {
		return phb_free(phb, FALSE);
	}

	return phb_connected(phb, source);
}

static void s5_sendconnect(gpointer data, gint source)
{
	unsigned char buf[512];
	struct PHB *phb = data;
	int hlen = strlen(phb->host);

	buf[0] = 0x05;
	buf[1] = 0x01;          /* CONNECT */
	buf[2] = 0x00;          /* reserved */
	buf[3] = 0x03;          /* address type -- host name */
	buf[4] = hlen;
	memcpy(buf + 5, phb->host, hlen);
	buf[5 + strlen(phb->host)] = phb->port >> 8;
	buf[5 + strlen(phb->host) + 1] = phb->port & 0xff;

	if (write(source, buf, (5 + strlen(phb->host) + 2)) < (5 + strlen(phb->host) + 2)) {
		phb_free(phb, FALSE);
		return;
	}

	phb->inpa = b_input_add(source, B_EV_IO_READ, s5_canread_again, phb);
}

static gboolean s5_readauth(gpointer data, gint source, b_input_condition cond)
{
	unsigned char buf[512];
	struct PHB *phb = data;

	b_event_remove(phb->inpa);

	if (read(source, buf, 2) < 2) {
		return phb_free(phb, FALSE);
	}

	if ((buf[0] != 0x01) || (buf[1] != 0x00)) {
		return phb_free(phb, FALSE);
	}

	s5_sendconnect(phb, source);

	return FALSE;
}

static gboolean s5_canread(gpointer data, gint source, b_input_condition cond)
{
	unsigned char buf[512];
	struct PHB *phb = data;

	b_event_remove(phb->inpa);

	if (read(source, buf, 2) < 2) {
		return phb_free(phb, FALSE);
	}

	if ((buf[0] != 0x05) || (buf[1] == 0xff)) {
		return phb_free(phb, FALSE);
	}

	if (buf[1] == 0x02) {
		unsigned int i = strlen(proxyuser), j = strlen(proxypass);
		buf[0] = 0x01;  /* version 1 */
		buf[1] = i;
		memcpy(buf + 2, proxyuser, i);
		buf[2 + i] = j;
		memcpy(buf + 2 + i + 1, proxypass, j);
		if (write(source, buf, 3 + i + j) < 3 + i + j) {
			return phb_free(phb, FALSE);
		}

		phb->inpa = b_input_add(source, B_EV_IO_READ, s5_readauth, phb);
	} else {
		s5_sendconnect(phb, source);
	}

	return FALSE;
}

static gboolean s5_canwrite(gpointer data, gint source, b_input_condition cond)
{
	unsigned char buf[512];
	int i;
	struct PHB *phb = data;
	socklen_t len;
	int error = ETIMEDOUT;

	if (phb->inpa > 0) {
		b_event_remove(phb->inpa);
	}
	len = sizeof(error);
	if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
		return phb_free(phb, FALSE);
	}
	sock_make_blocking(source);

	i = 0;
	buf[0] = 0x05;          /* SOCKS version 5 */
	if (proxyuser[0]) {
		buf[1] = 0x02;  /* two methods */
		buf[2] = 0x00;  /* no authentication */
		buf[3] = 0x02;  /* username/password authentication */
		i = 4;
	} else {
		buf[1] = 0x01;
		buf[2] = 0x00;
		i = 3;
	}

	if (write(source, buf, i) < i) {
		return phb_free(phb, FALSE);
	}

	phb->inpa = b_input_add(source, B_EV_IO_READ, s5_canread, phb);

	return FALSE;
}

static int proxy_connect_socks5(const char *host, unsigned short port, struct PHB *phb)
{
	phb->host = g_strdup(host);
	phb->port = port;
	phb->proxy_func = s5_canwrite;
	phb->proxy_data = phb;

	return(proxy_connect_none(proxyhost, proxyport, phb));
}

static const proxy_connect_func proxy_connect_funcs_array[] = {
	proxy_connect_none,   /* PROXY_NONE */
	proxy_connect_http,   /* PROXY_HTTP */
	proxy_connect_socks4, /* PROXY_SOCKS4 */
	proxy_connect_socks5, /* PROXY_SOCKS5 */
	proxy_connect_socks4, /* PROXY_SOCKS4A */
};

/* Export functions */

int proxy_connect(const char *host, int port, b_event_handler func, gpointer data)
{
	struct PHB *phb;
	proxy_connect_func fun;
	int fd;

	if (!phb_hash) {
		phb_hash = g_hash_table_new(g_int_hash, g_int_equal);
	}

	if (!host || port <= 0 || !func || strlen(host) > 128) {
		return -1;
	}

	phb = g_new0(struct PHB, 1);
	phb->func = func;
	phb->data = data;

	if (proxyhost[0] && proxyport > 0 && proxytype >= 0 && proxytype < G_N_ELEMENTS(proxy_connect_funcs_array)) {
		fun = proxy_connect_funcs_array[proxytype];
	} else {
		fun = proxy_connect_none;
	}

	fd = fun(host, port, phb);

	if (fd != -1) {
		g_hash_table_insert(phb_hash, &phb->fd, phb);
	}

	return fd;
}

void proxy_disconnect(int fd)
{
	struct PHB *phb = g_hash_table_lookup(phb_hash, &fd);

	if (!phb) {
		/* not in the early part of the connection - just close the fd */
		closesocket(fd);
		return;
	}

	if (phb->inpa) {
		b_event_remove(phb->inpa);
		phb->inpa = 0;
	}

	/* avoid calling the callback, which might result in double-free */
	phb->func = NULL;

	/* close and free */
	phb_free(phb, FALSE);
}