/* input function: DCC CHAT - someone tried to connect to our socket */
static void dcc_chat_listen(DCC_REC *dcc)
{
IPADDR ip;
int handle, port;
g_return_if_fail(dcc != NULL);
/* accept connection */
handle = net_accept(dcc->handle, &ip, &port);
if (handle == -1)
return;
/* TODO: add paranoia check - see dcc-files.c */
g_source_remove(dcc->tagread);
close(dcc->handle);
dcc->starttime = time(NULL);
dcc->handle = handle;
memcpy(&dcc->addr, &ip, sizeof(IPADDR));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_chat_input, dcc);
signal_emit("dcc connected", 1, dcc);
}
/* input function: DCC SERVER - someone tried to connect to our socket */
static void dcc_server_listen(SERVER_DCC_REC *dcc)
{
SERVER_DCC_REC *newdcc;
IPADDR ip;
GIOChannel *handle;
int port;
g_return_if_fail(IS_DCC_SERVER(dcc));
/* accept connection */
handle = net_accept(dcc->handle, &ip, &port);
if (handle == NULL)
return;
/* Create a new DCC SERVER to handle this connection */
newdcc = dcc_server_clone(dcc);
newdcc->starttime = time(NULL);
newdcc->handle = handle;
newdcc->sendbuf = net_sendbuffer_create(handle, 0);
memcpy(&newdcc->addr, &ip, sizeof(IPADDR));
net_ip2host(&newdcc->addr, newdcc->addrstr);
newdcc->port = port;
newdcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_server_input, newdcc);
signal_emit("dcc connected", 1, newdcc);
}
static void server_real_connect(SERVER_REC *server, IPADDR *ip,
const char *unix_socket)
{
GIOChannel *handle;
IPADDR *own_ip = NULL;
const char *errmsg;
char *errmsg2;
char ipaddr[MAX_IP_LEN];
int port, protonum;
g_return_if_fail(ip != NULL || unix_socket != NULL);
signal_emit("server connecting", 2, server, ip);
if (server->connrec->no_connect)
return;
if (ip != NULL) {
own_ip = IPADDR_IS_V6(ip) ? server->connrec->own_ip6 : server->connrec->own_ip4;
port = server->connrec->proxy != NULL ?
server->connrec->proxy_port : server->connrec->port;
protonum = server->connrec->use_sctp ? 132 : 0;
handle = server->connrec->use_ssl ?
net_connect_ip_ssl(ip, port, own_ip, server, protonum) : net_connect_ip(ip, port, own_ip, protonum);
} else {
handle = net_connect_unix(unix_socket);
}
if (handle == NULL) {
/* failed */
errmsg = g_strerror(errno);
errmsg2 = NULL;
if (errno == EADDRNOTAVAIL) {
if (own_ip != NULL) {
/* show the IP which is causing the error */
net_ip2host(own_ip, ipaddr);
errmsg2 = g_strconcat(errmsg, ": ", ipaddr, NULL);
}
server->no_reconnect = TRUE;
}
if (server->connrec->use_ssl && errno == ENOSYS)
server->no_reconnect = TRUE;
server->connection_lost = TRUE;
server_connect_failed(server, errmsg2 ? errmsg2 : errmsg);
g_free(errmsg2);
} else {
server->handle = net_sendbuffer_create(handle, 0);
#ifdef HAVE_OPENSSL
if (server->connrec->use_ssl)
server_connect_callback_init_ssl(server, handle);
else
#endif
server->connect_tag =
g_input_add(handle, G_INPUT_WRITE | G_INPUT_READ,
(GInputFunction)
server_connect_callback_init,
server);
}
}
/* input function: DCC CHAT - someone tried to connect to our socket */
static void dcc_chat_listen(CHAT_DCC_REC *dcc)
{
IPADDR ip;
GIOChannel *handle;
int port;
g_return_if_fail(IS_DCC_CHAT(dcc));
/* accept connection */
handle = net_accept(dcc->handle, &ip, &port);
if (handle == NULL)
return;
/* TODO: add paranoia check - see dcc-files.c */
net_disconnect(dcc->handle);
g_source_remove(dcc->tagconn);
dcc->tagconn = -1;
dcc->starttime = time(NULL);
dcc->handle = handle;
dcc->sendbuf = net_sendbuffer_create(handle, 0);
memcpy(&dcc->addr, &ip, sizeof(IPADDR));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_chat_input, dcc);
signal_emit("dcc connected", 1, dcc);
}
/* input function: DCC SEND - someone tried to connect to our socket */
static void dcc_send_connected(SEND_DCC_REC *dcc)
{
GIOChannel *handle;
IPADDR addr;
int port;
/* accept connection */
handle = net_accept(dcc->handle, &addr, &port);
if (handle == NULL)
return;
/* TODO: some kind of paranoia check would be nice. it would check
that the host of the nick who we sent the request matches the
address who connected us. */
net_disconnect(dcc->handle);
g_source_remove(dcc->tagconn);
dcc->tagconn = -1;
dcc->starttime = time(NULL);
dcc->handle = handle;
memcpy(&dcc->addr, &addr, sizeof(IPADDR));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_send_read_size, dcc);
dcc->tagwrite = g_input_add(handle, G_INPUT_WRITE,
(GInputFunction) dcc_send_data, dcc);
signal_emit("dcc connected", 1, dcc);
}
/* CTCP: DCC SEND */
static void ctcp_msg_dcc_send(IRC_SERVER_REC *server, const char *data,
const char *nick, const char *addr,
const char *target, CHAT_DCC_REC *chat)
{
GET_DCC_REC *dcc;
IPADDR ip;
char **params, *fname;
int paramcount, fileparams;
int port, len, quoted = FALSE;
long size;
/* SEND <file name> <address> <port> <size> [...] */
params = g_strsplit(data, " ", -1);
paramcount = strarray_length(params);
if (paramcount < 4) {
signal_emit("dcc error ctcp", 5, "SEND", data,
nick, addr, target);
g_strfreev(params);
return;
}
fileparams = get_file_params_count(params, paramcount);
dcc_str2ip(params[fileparams], &ip);
port = atoi(params[fileparams+1]);
size = atol(params[fileparams+2]);
params[fileparams] = NULL;
fname = g_strjoinv(" ", params);
g_strfreev(params);
len = strlen(fname);
if (len > 1 && *fname == '"' && fname[len-1] == '"') {
/* "file name" - MIRC sends filenames with spaces like this */
fname[len-1] = '\0';
g_memmove(fname, fname+1, len);
quoted = TRUE;
}
dcc = DCC_GET(dcc_find_request(DCC_GET_TYPE, nick, fname));
if (dcc != NULL) {
/* same DCC request offered again, remove the old one */
dcc_destroy(DCC(dcc));
}
dcc = dcc_get_create(server, chat, nick, fname);
dcc->target = g_strdup(target);
memcpy(&dcc->addr, &ip, sizeof(ip));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->size = size;
dcc->file_quoted = quoted;
signal_emit("dcc request", 2, dcc, addr);
g_free(fname);
}
static void sig_server_connecting(SERVER_REC *server, IPADDR *ip)
{
char ipaddr[MAX_IP_LEN];
g_return_if_fail(server != NULL);
g_return_if_fail(ip != NULL);
net_ip2host(ip, ipaddr);
printformat(server, NULL, MSGLEVEL_CLIENTNOTICE, IRCTXT_CONNECTING,
server->connrec->address, ipaddr, server->connrec->port);
}
void dcc_make_address(IPADDR *ip, char *host)
{
unsigned long addr;
if (is_ipv6_addr(ip)) {
/* IPv6 */
net_ip2host(ip, host);
} else {
memcpy(&addr, &ip->addr, 4);
sprintf(host, "%lu", (unsigned long) htonl(addr));
}
}
NSAPI_PUBLIC char *session_dns_lookup(Session *s, int verify)
{
pb_param *dns = pblock_findkey(pb_key_dns, s->client);
char *hn;
if(!dns) {
char *ip = pblock_findkeyval(pb_key_ip, s->client);
if(!ip || !(hn = net_ip2host(ip, verify))) {
pblock_kvinsert(pb_key_dns, "-none", 5, s->client);
return NULL;
}
dns = pblock_kvinsert(pb_key_dns, hn, strlen(hn), s->client);
}
else if(!strcmp(dns->value, "-none"))
return NULL;
((ClAuth_t *) s->clauth)->cla_dns = dns->value;
return dns->value;
}
/* input function: DCC SEND - someone tried to connect to our socket */
static void dcc_send_init(DCC_REC *dcc)
{
int handle, port;
IPADDR addr;
g_return_if_fail(dcc != NULL);
/* accept connection */
handle = net_accept(dcc->handle, &addr, &port);
if (handle == -1)
return;
/* TODO: some kind of paranoia check would be nice. it would check
that the host of the nick who we sent the request matches the
address who connected us. */
g_source_remove(dcc->tagread);
close(dcc->handle);
dcc->starttime = time(NULL);
dcc->fastsend = settings_get_bool("dcc_fast_send");
dcc->handle = handle;
memcpy(&dcc->addr, &addr, sizeof(IPADDR));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->databufsize = settings_get_int("dcc_block_size");
if (dcc->databufsize <= 0) dcc->databufsize = 2048;
dcc->databuf = g_malloc(dcc->databufsize);
dcc->tagread = g_input_add(handle, G_INPUT_READ,
(GInputFunction) dcc_send_read_size, dcc);
dcc->tagwrite = !dcc->fastsend ? -1 :
g_input_add(handle, G_INPUT_WRITE, (GInputFunction) dcc_send_data, dcc);
signal_emit("dcc connected", 1, dcc);
if (!dcc->fastsend) {
/* send first block */
dcc->gotalldata = TRUE;
dcc_send_data(dcc);
}
}
void dcc_ip2str(IPADDR *ip, char *host)
{
IPADDR temp_ip;
guint32 addr;
if (*settings_get_str("dcc_own_ip") != '\0') {
/* overridden IP address */
net_host2ip(settings_get_str("dcc_own_ip"), &temp_ip);
ip = &temp_ip;
}
if (IPADDR_IS_V6(ip)) {
/* IPv6 */
net_ip2host(ip, host);
} else {
memcpy(&addr, &ip->ip, sizeof(addr));
g_snprintf(host, MAX_IP_LEN, "%lu",
(unsigned long) htonl(addr));
}
}
/* Get name for host, *name should be g_free()'d unless it's NULL.
Return values are the same as with net_gethostbyname() */
int net_gethostbyaddr(IPADDR *ip, char **name)
{
#ifdef HAVE_IPV6
struct addrinfo req, *ai;
char hbuf[NI_MAXHOST];
int host_error;
#else
struct hostent *hp;
#endif
char ipname[MAX_IP_LEN];
g_return_val_if_fail(ip != NULL, -1);
g_return_val_if_fail(name != NULL, -1);
net_ip2host(ip, ipname);
*name = NULL;
#ifdef HAVE_IPV6
memset(&req, 0, sizeof(struct addrinfo));
req.ai_socktype = SOCK_STREAM;
/* save error to host_error for later use */
host_error = getaddrinfo(ipname, NULL, &req, &ai);
if (host_error != 0)
return host_error;
if (getnameinfo(ai->ai_addr, ai->ai_addrlen, hbuf, sizeof(hbuf), NULL, 0, 0))
return 1;
/*FIXME: how does this work? *name = g_strdup(ai->?);*/
freeaddrinfo(ai);
return 1;
#else
hp = gethostbyaddr(ipname, strlen(ipname), AF_INET);
if (hp == NULL) return -1;
*name = g_strdup(hp->h_name);
#endif
return 0;
}
static void sig_listen(LISTEN_REC *listen)
{
CLIENT_REC *rec;
IPADDR ip;
NET_SENDBUF_REC *sendbuf;
GIOChannel *handle;
char host[MAX_IP_LEN];
int port;
g_return_if_fail(listen != NULL);
/* accept connection */
handle = net_accept(listen->handle, &ip, &port);
if (handle == NULL)
return;
net_ip2host(&ip, host);
sendbuf = net_sendbuffer_create(handle, 0);
rec = g_new0(CLIENT_REC, 1);
rec->listen = listen;
rec->handle = sendbuf;
rec->host = g_strdup(host);
rec->port = port;
if (g_strcmp0(listen->ircnet, "*") == 0) {
rec->proxy_address = g_strdup("irc.proxy");
rec->server = servers == NULL ? NULL : IRC_SERVER(servers->data);
} else {
rec->proxy_address = g_strdup_printf("%s.proxy", listen->ircnet);
rec->server = servers == NULL ? NULL :
IRC_SERVER(server_find_chatnet(listen->ircnet));
}
rec->recv_tag = g_input_add(handle, G_INPUT_READ,
(GInputFunction) sig_listen_client, rec);
proxy_clients = g_slist_prepend(proxy_clients, rec);
rec->listen->clients = g_slist_prepend(rec->listen->clients, rec);
signal_emit("proxy client connecting", 1, rec);
printtext(rec->server, NULL, MSGLEVEL_CLIENTNOTICE,
"Proxy: New client %s:%d on port %d (%s)",
rec->host, rec->port, listen->port, listen->ircnet);
}
/* Get name for host, *name should be g_free()'d unless it's NULL.
Return values are the same as with net_gethostbyname() */
int net_gethostbyaddr(IPADDR *ip, char **name)
{
#ifdef HAVE_IPV6
struct addrinfo req, *ai;
int host_error;
#else
struct hostent *hp;
#endif
char ipname[MAX_IP_LEN];
g_return_val_if_fail(ip != NULL, -1);
g_return_val_if_fail(name != NULL, -1);
net_ip2host(ip, ipname);
*name = NULL;
#ifdef HAVE_IPV6
memset(&req, 0, sizeof(struct addrinfo));
req.ai_socktype = SOCK_STREAM;
req.ai_flags = AI_CANONNAME;
/* save error to host_error for later use */
host_error = getaddrinfo(ipname, NULL, &req, &ai);
if (host_error != 0)
return host_error;
*name = g_strdup(ai->ai_canonname);
freeaddrinfo(ai);
#else
hp = gethostbyaddr(ipname, strlen(ipname), AF_INET);
if (hp == NULL) return -1;
*name = g_strdup(hp->h_name);
#endif
return 0;
}
BOT_DOWNLINK_REC *bot_downlink_find(BOTNET_REC *botnet, IPADDR *ip, const char *host)
{
GSList *tmp, *tmp2;
char ipname[MAX_IP_LEN];
g_return_val_if_fail(botnet != NULL, NULL);
g_return_val_if_fail(ip != NULL, NULL);
net_ip2host(ip, ipname);
for (tmp = botnet->downlinks; tmp != NULL; tmp = tmp->next) {
BOT_DOWNLINK_REC *rec = tmp->data;
for (tmp2 = rec->valid_addrs; tmp2 != NULL; tmp2 = tmp2->next) {
if (match_wildcards(tmp2->data, ipname))
return rec;
if (match_wildcards(tmp2->data, host) &&
!is_ip_mask(tmp2->data))
return rec;
}
}
return NULL;
}
static void dcc_get_listen(GET_DCC_REC *dcc)
{
GIOChannel *handle;
IPADDR addr;
int port;
/* accept connection */
handle = net_accept(dcc->handle, &addr, &port);
if (handle == NULL)
return;
net_disconnect(dcc->handle);
g_source_remove(dcc->tagconn);
dcc->tagconn = -1;
dcc->starttime = time(NULL);
dcc->handle = handle;
memcpy(&dcc->addr, &addr, sizeof(IPADDR));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->tagconn = g_input_add(handle, G_INPUT_READ | G_INPUT_WRITE,
(GInputFunction) sig_dccget_connected, dcc);
}
gboolean proxy_init(void)
{
gchar ipaddr[MAX_IP_LEN];
const char *password;
const char *addr;
int port;
proxy_settings_init();
proxy_data = g_new0(PLUGIN_DATA, 1);
password = settings_get_str("proxy_listen_password");
addr = settings_get_str("proxy_listen_addr");
port = settings_get_int("proxy_listen_port");
plug = module_find("proxy");
proxy_data->plugin = plug;
if (*password != '\0')
{
/* args = password */
proxy_data->password = g_strdup(password);
}
if (*addr != '\0')
{
/* specify ip address to listen */
net_host2ip(addr, &proxy_data->ip);
}
if (port != 0)
{
/* specify port to use */
proxy_data->port = port;
}
if (proxy_data->password == NULL)
{
/* no password - bad idea! */
printtext(NULL, NULL, MSGLEVEL_CLIENTNOTICE, "Warning!! Password not specified, everyone can use this proxy! Use /set proxy_listen_password <password> to set it");
}
if (servers == NULL)
{
/* FIXME: not good */
printtext(NULL, NULL, MSGLEVEL_CLIENTERROR, "You need to specify IP address to listen with /set proxy_listen_addr <address>");
deinit();
return FALSE;
}
else
{
SERVER_REC *server;
server = servers->data;
if (net_getsockname(net_sendbuffer_handle(server->handle), &proxy_data->ip, NULL))
{
deinit();
return FALSE;
}
}
net_ip2host(&proxy_data->ip, ipaddr);
printtext(NULL, NULL, MSGLEVEL_CLIENTNOTICE, "Proxy plugin loaded - listening in interface %s port %d", ipaddr, proxy_data->port);
plugin_proxy_listen_init(proxy_data);
proxy_data->loaded = TRUE;
return TRUE;
}
/* Handle incoming DCC CTCP messages */
static void dcc_ctcp_msg(char *data, IRC_SERVER_REC *server, char *sender, char *sendaddr, char *target, DCC_REC *chat)
{
char *params, *type, *arg, *addrstr, *portstr, *sizestr, *str;
const char *cstr;
DCC_REC *dcc;
gulong size;
int port;
g_return_if_fail(data != NULL);
g_return_if_fail(sender != NULL);
params = cmd_get_params(data, 5 | PARAM_FLAG_NOQUOTES,
&type, &arg, &addrstr, &portstr, &sizestr);
if (sscanf(portstr, "%d", &port) != 1) port = 0;
if (sscanf(sizestr, "%lu", &size) != 1) size = 0;
dcc = dcc_create(SWAP_SENDGET(dcc_str2type(type)), -1, sender, arg, server, chat);
dcc_get_address(addrstr, &dcc->addr);
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->size = size;
switch (dcc->type)
{
case DCC_TYPE_GET:
cstr = settings_get_str("dcc_autoget_masks");
/* check that autoget masks match */
if (settings_get_bool("dcc_autoget") && (*cstr == '\0' || irc_masks_match(cstr, sender, sendaddr)) &&
/* check file size limit, FIXME: it's possible to send a bogus file size and then just send what ever sized file.. */
(settings_get_int("dcc_max_autoget_size") <= 0 || (settings_get_int("dcc_max_autoget_size") > 0 && size <= settings_get_int("dcc_max_autoget_size")*1024)))
{
/* automatically get */
str = g_strdup_printf("GET %s %s", dcc->nick, dcc->arg);
signal_emit("command dcc", 2, str, server);
g_free(str);
}
else
{
/* send request */
signal_emit("dcc request", 1, dcc);
}
break;
case DCC_TYPE_CHAT:
cstr = settings_get_str("dcc_autochat_masks");
if (*cstr != '\0' && irc_masks_match(cstr, sender, sendaddr))
{
/* automatically accept chat */
str = g_strdup_printf("CHAT %s", dcc->nick);
signal_emit("command dcc", 2, str, server);
g_free(str);
}
else
{
/* send request */
signal_emit("dcc request", 1, dcc);
}
break;
case DCC_TYPE_RESUME:
case DCC_TYPE_ACCEPT:
/* handle this in dcc-files.c */
dcc_destroy(dcc);
break;
default:
/* unknown DCC command */
signal_emit("dcc unknown ctcp", 3, data, sender, sendaddr);
dcc_destroy(dcc);
break;
}
g_free(params);
}
/* CTCP: DCC CHAT */
static void ctcp_msg_dcc_chat(IRC_SERVER_REC *server, const char *data,
const char *nick, const char *addr,
const char *target, CHAT_DCC_REC *chat)
{
CHAT_DCC_REC *dcc;
char **params;
int paramcount;
int passive, autoallow = FALSE;
/* CHAT <unused> <address> <port> */
/* CHAT <unused> <address> 0 <id> (DCC CHAT passive protocol) */
params = g_strsplit(data, " ", -1);
paramcount = g_strv_length(params);
if (paramcount < 3) {
g_strfreev(params);
return;
}
passive = paramcount == 4 && g_strcmp0(params[2], "0") == 0;
if (nick == NULL)
nick = "";
dcc = DCC_CHAT(dcc_find_request(DCC_CHAT_TYPE, nick, NULL));
if (dcc != NULL) {
if (dcc_is_listening(dcc)) {
/* we requested dcc chat, they requested
dcc chat from us .. allow it. */
dcc_destroy(DCC(dcc));
autoallow = TRUE;
} else if (!dcc_is_passive(dcc)) {
/* we already have one dcc chat request
from this nick, remove it. */
dcc_destroy(DCC(dcc));
} else if (passive) {
if (dcc->pasv_id != atoi(params[3])) {
/* IDs don't match! */
dcc_destroy(DCC(dcc));
} else {
/* IDs are ok! Update address and port and
connect! */
dcc->target = g_strdup(target);
dcc->port = atoi(params[2]);
dcc_str2ip(params[1], &dcc->addr);
net_ip2host(&dcc->addr, dcc->addrstr);
dcc_chat_connect(dcc);
g_strfreev(params);
return;
}
}
}
dcc = dcc_chat_create(server, chat, nick, params[0]);
if (dcc == NULL) {
g_strfreev(params);
g_warn_if_reached();
return;
}
dcc->target = g_strdup(target);
dcc->port = atoi(params[2]);
if (passive)
dcc->pasv_id = atoi(params[3]);
dcc_str2ip(params[1], &dcc->addr);
net_ip2host(&dcc->addr, dcc->addrstr);
signal_emit("dcc request", 2, dcc, addr);
if (autoallow || DCC_CHAT_AUTOACCEPT(dcc, server, nick, addr)) {
if (passive) {
/* Passive DCC... let's set up a listening socket
and send reply back */
dcc_chat_passive(dcc);
} else {
dcc_chat_connect(dcc);
}
}
g_strfreev(params);
}
/* DCC SERVER: text received */
static void dcc_server_msg(SERVER_DCC_REC *dcc, const char *msg)
{
g_return_if_fail(IS_DCC_SERVER(dcc));
g_return_if_fail(msg != NULL);
/* Check for CHAT protocol */
if (g_strncasecmp(msg, "100 ", 4) == 0) {
msg += 4;
/* Check if this server is accepting chat requests.*/
if (dcc->accept_chat) {
/* Connect and start DCC Chat */
char *str;
CHAT_DCC_REC *dccchat = dcc_chat_create(dcc->server, NULL, msg, "chat");
dccchat->starttime = time(NULL);
dccchat->handle = dcc->handle;
dccchat->sendbuf = net_sendbuffer_create(dccchat->handle, 0);
memcpy(&dccchat->addr, &dcc->addr, sizeof(IPADDR));
net_ip2host(&dccchat->addr, dccchat->addrstr);
dccchat->port = dcc->port;
dccchat->tagread = g_input_add(dccchat->handle, G_INPUT_READ,
(GInputFunction) dcc_chat_input, dccchat);
dcc->connection_established = 1;
signal_emit("dcc connected", 1, dccchat);
str = g_strdup_printf("101 %s\n",
(dccchat->server) ? dccchat->server->nick : "??");
net_sendbuffer_send(dccchat->sendbuf, str, strlen(str));
g_free(str);
}
}
/* Check for FSERVE protocol */
if (g_strncasecmp(msg, "110 ", 4) == 0) {
msg += 4;
/* Check if this server is accepting fserve requests.*/
if (dcc->accept_fserve) {
/* TODO - Connect and start DCC Fserve */
}
}
/* Check for SEND protocol */
if (g_strncasecmp(msg, "120 ", 4) == 0) {
msg += 4;
/* Check if this server is accepting send requests.*/
if (dcc->accept_send) {
/* Connect and start DCC Send */
GET_DCC_REC *dccget;
char **params, *fname, *nick;
int paramcount, len, quoted = FALSE;
uoff_t size;
/* 120 clientnickname filesize filename */
params = g_strsplit(msg, " ", -1);
paramcount = strarray_length(params);
if (paramcount < 3) {
g_strfreev(params);
signal_stop();
return;
}
nick = params[0];
size = str_to_uofft(params[1]);
fname = g_strjoinv(" ", ¶ms[2]);
len = strlen(fname);
if (len > 1 && *fname == '"' && fname[len-1] == '"') {
/* "file name" - MIRC sends filenames with spaces like this */
fname[len-1] = '\0';
g_memmove(fname, fname+1, len);
quoted = TRUE;
}
dccget = dcc_get_create(dcc->server, NULL, nick, fname);
dccget->handle = dcc->handle;
dccget->target = g_strdup(dcc->server ? dcc->server->nick : "??");
memcpy(&dccget->addr, &dcc->addr, sizeof(dcc->addr));
if (dccget->addr.family == AF_INET) {
net_ip2host(&dccget->addr, dccget->addrstr);
} else {
/* with IPv6, show it to us as it was sent */
memcpy(dccget->addrstr, dcc->addrstr, sizeof(dccget->addrstr));
}
dccget->port = dcc->port;
dccget->size = size;
dccget->file_quoted = quoted;
dccget->from_dccserver = 1;
dcc->connection_established = 1;
signal_emit("dcc request", 2, dccget, dccget->addrstr);
g_strfreev(params);
g_free(fname);
}
}
signal_stop();
}
/* CTCP: DCC SEND */
static void ctcp_msg_dcc_send(IRC_SERVER_REC *server, const char *data,
const char *nick, const char *addr,
const char *target, CHAT_DCC_REC *chat)
{
GET_DCC_REC *dcc;
SEND_DCC_REC *temp_dcc;
IPADDR ip;
char *address, **params, *fname;
int paramcount, fileparams;
int port, len, quoted = FALSE;
uoff_t size;
int p_id = -1;
int passive = FALSE;
/* SEND <file name> <address> <port> <size> [...] */
/* SEND <file name> <address> 0 <size> <id> (DCC SEND passive protocol) */
params = g_strsplit(data, " ", -1);
paramcount = strarray_length(params);
if (paramcount < 4) {
signal_emit("dcc error ctcp", 5, "SEND", data,
nick, addr, target);
g_strfreev(params);
return;
}
fileparams = get_file_params_count(params, paramcount);
address = g_strdup(params[fileparams]);
dcc_str2ip(address, &ip);
port = atoi(params[fileparams+1]);
size = str_to_uofft(params[fileparams+2]);
/* If this DCC uses passive protocol then store the id for later use. */
if (paramcount == fileparams + 4) {
p_id = atoi(params[fileparams+3]);
passive = TRUE;
}
fname = get_file_name(params, fileparams);
g_strfreev(params);
len = strlen(fname);
if (len > 1 && *fname == '"' && fname[len-1] == '"') {
/* "file name" - MIRC sends filenames with spaces like this */
fname[len-1] = '\0';
g_memmove(fname, fname+1, len);
quoted = TRUE;
}
if (passive && port != 0) {
/* This is NOT a DCC SEND request! This is a reply to our
passive request. We MUST check the IDs and then connect to
the remote host. */
temp_dcc = DCC_SEND(dcc_find_request(DCC_SEND_TYPE, nick, fname));
if (temp_dcc != NULL && p_id == temp_dcc->pasv_id) {
temp_dcc->target = g_strdup(target);
temp_dcc->port = port;
temp_dcc->size = size;
temp_dcc->file_quoted = quoted;
memcpy(&temp_dcc->addr, &ip, sizeof(IPADDR));
if (temp_dcc->addr.family == AF_INET)
net_ip2host(&temp_dcc->addr, temp_dcc->addrstr);
else {
/* with IPv6, show it to us as it was sent */
strocpy(temp_dcc->addrstr, address,
sizeof(temp_dcc->addrstr));
}
/* This new signal is added to let us invoke
dcc_send_connect() which is found in dcc-send.c */
signal_emit("dcc reply send pasv", 1, temp_dcc);
g_free(address);
g_free(fname);
return;
} else if (temp_dcc != NULL && p_id != temp_dcc->pasv_id) {
/* IDs don't match... remove the old DCC SEND and
return */
dcc_destroy(DCC(temp_dcc));
g_free(address);
g_free(fname);
return;
}
}
dcc = DCC_GET(dcc_find_request(DCC_GET_TYPE, nick, fname));
if (dcc != NULL)
dcc_destroy(DCC(dcc)); /* remove the old DCC */
dcc = dcc_get_create(server, chat, nick, fname);
dcc->target = g_strdup(target);
if (passive && port == 0)
dcc->pasv_id = p_id; /* Assign the ID to the DCC */
memcpy(&dcc->addr, &ip, sizeof(ip));
if (dcc->addr.family == AF_INET)
net_ip2host(&dcc->addr, dcc->addrstr);
else {
/* with IPv6, show it to us as it was sent */
strocpy(dcc->addrstr, address, sizeof(dcc->addrstr));
}
dcc->port = port;
dcc->size = size;
dcc->file_quoted = quoted;
signal_emit("dcc request", 2, dcc, addr);
g_free(address);
g_free(fname);
}
/* Handle incoming DCC CTCP messages */
static void dcc_ctcp_msg(char *data, IRC_SERVER_REC *server, char *sender, char *sendaddr, char *target, DCC_REC *chat)
{
char *type, *arg, *addrstr, *portstr, *sizestr, *str;
void *free_arg;
const char *cstr;
DCC_REC *dcc, *olddcc;
long size;
int dcctype, port;
g_return_if_fail(data != NULL);
g_return_if_fail(sender != NULL);
if (!cmd_get_params(data, &free_arg, 5 | PARAM_FLAG_NOQUOTES,
&type, &arg, &addrstr, &portstr, &sizestr))
return;
if (sscanf(portstr, "%d", &port) != 1) port = 0;
if (sscanf(sizestr, "%ld", &size) != 1) size = 0;
dcctype = SWAP_SENDGET(dcc_str2type(type));
olddcc = dcc_find_item(dcctype, sender,
dcctype == DCC_TYPE_CHAT ? NULL : arg);
if (olddcc != NULL) {
/* same DCC request offered again */
if (olddcc->type == DCC_TYPE_CHAT &&
olddcc->handle != -1 && olddcc->starttime == 0) {
/* we requested dcc chat, they requested
dcc chat from us .. allow it. */
dcc_destroy(olddcc);
} else {
/* if the connection isn't open, update the port,
otherwise just ignore */
if (olddcc->handle == -1)
olddcc->port = port;
cmd_params_free(free_arg);
return;
}
}
dcc = dcc_create(dcctype, -1, sender, arg, server, chat);
dcc_get_address(addrstr, &dcc->addr);
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->size = size;
switch (dcc->type)
{
case DCC_TYPE_GET:
cstr = settings_get_str("dcc_autoget_masks");
/* check that autoget masks match */
if (settings_get_bool("dcc_autoget") && (*cstr == '\0' || masks_match(SERVER(server), cstr, sender, sendaddr)) &&
/* check file size limit, FIXME: it's possible to send a bogus file size and then just send what ever sized file.. */
(settings_get_int("dcc_max_autoget_size") <= 0 || (settings_get_int("dcc_max_autoget_size") > 0 && size <= settings_get_int("dcc_max_autoget_size")*1024)))
{
/* automatically get */
str = g_strdup_printf("GET %s %s", dcc->nick, dcc->arg);
signal_emit("command dcc", 2, str, server);
g_free(str);
}
else
{
/* send request */
signal_emit("dcc request", 1, dcc);
}
break;
case DCC_TYPE_CHAT:
cstr = settings_get_str("dcc_autochat_masks");
if (olddcc != NULL ||
(*cstr != '\0' && masks_match(SERVER(server), cstr, sender, sendaddr)))
{
/* automatically accept chat */
str = g_strdup_printf("CHAT %s", dcc->nick);
signal_emit("command dcc", 2, str, server);
g_free(str);
}
else
{
/* send request */
signal_emit("dcc request", 1, dcc);
}
break;
case DCC_TYPE_RESUME:
case DCC_TYPE_ACCEPT:
/* handle this in dcc-files.c */
dcc_destroy(dcc);
break;
default:
/* unknown DCC command */
signal_emit("dcc unknown ctcp", 3, data, sender, sendaddr);
dcc_destroy(dcc);
break;
}
cmd_params_free(free_arg);
}
