pidgin/pidgin

closing merged branch
port-changes-from-branch-2.x.y-to-default
2020-02-03, Gary Kramlich
2f836435c33c
closing merged branch
/**
* purple
*
* Copyright (C) 2004, Timothy T Ringenbach <omarvo@hotmail.com>
* Copyright (C) 2003, Robbert Haarman <purple@inglorion.net>
*
* 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
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#include "internal.h"
#include <purple.h>
#include "irc.h"
struct _IrcXfer {
PurpleXfer parent;
/* receive properties */
gchar *ip;
guint remote_port;
/* send properties */
PurpleNetworkListenData *listen_data;
gint inpa;
gint fd;
guchar *rxqueue;
guint rxlen;
};
G_DEFINE_DYNAMIC_TYPE(IrcXfer, irc_xfer, PURPLE_TYPE_XFER);
/***************************************************************************
* Functions related to receiving files via DCC SEND
***************************************************************************/
/*
* This function is called whenever data is received.
* It sends the acknowledgement (in the form of a total byte count as an
* unsigned 4 byte integer in network byte order)
*/
static void irc_dccsend_recv_ack(PurpleXfer *xfer, const guchar *data, size_t size) {
guint32 l;
gssize result;
if(purple_xfer_get_xfer_type(xfer) != PURPLE_XFER_TYPE_RECEIVE) {
return;
}
l = htonl(purple_xfer_get_bytes_sent(xfer));
result = purple_xfer_write(xfer, (guchar *)&l, sizeof(l));
if (result != sizeof(l)) {
purple_debug_error("irc", "unable to send acknowledgement: %s\n", g_strerror(errno));
/* TODO: We should probably close the connection here or something. */
}
}
static void irc_dccsend_recv_init(PurpleXfer *xfer) {
IrcXfer *xd = IRC_XFER(xfer);
purple_xfer_start(xfer, -1, xd->ip, xd->remote_port);
}
/* This function makes the necessary arrangements for receiving files */
void irc_dccsend_recv(struct irc_conn *irc, const char *from, const char *msg) {
IrcXfer *xfer;
gchar **token;
struct in_addr addr;
GString *filename;
int i = 0;
guint32 nip;
token = g_strsplit(msg, " ", 0);
if (!token[0] || !token[1] || !token[2]) {
g_strfreev(token);
return;
}
filename = g_string_new("");
if (token[0][0] == '"') {
if (!strchr(&(token[0][1]), '"')) {
g_string_append(filename, &(token[0][1]));
for (i = 1; token[i]; i++)
if (!strchr(token[i], '"')) {
g_string_append_printf(filename, " %s", token[i]);
} else {
g_string_append_len(filename, token[i], strlen(token[i]) - 1);
break;
}
} else {
g_string_append_len(filename, &(token[0][1]), strlen(&(token[0][1])) - 1);
}
} else {
g_string_append(filename, token[0]);
}
if (!token[i] || !token[i+1] || !token[i+2]) {
g_strfreev(token);
g_string_free(filename, TRUE);
return;
}
i++;
xfer = g_object_new(
IRC_TYPE_XFER,
"account", irc->account,
"type", PURPLE_XFER_TYPE_RECEIVE,
"remote-user", from,
NULL
);
purple_xfer_set_filename(PURPLE_XFER(xfer), filename->str);
xfer->remote_port = atoi(token[i+1]);
nip = strtoul(token[i], NULL, 10);
if (nip) {
addr.s_addr = htonl(nip);
xfer->ip = g_strdup(inet_ntoa(addr));
} else {
xfer->ip = g_strdup(token[i]);
}
purple_debug(PURPLE_DEBUG_INFO, "irc", "Receiving file (%s) from %s\n",
filename->str, xfer->ip);
purple_xfer_set_size(PURPLE_XFER(xfer), token[i+2] ? atoi(token[i+2]) : 0);
purple_xfer_request(PURPLE_XFER(xfer));
g_strfreev(token);
g_string_free(filename, TRUE);
}
/*******************************************************************
* Functions related to sending files via DCC SEND
*******************************************************************/
/* just in case you were wondering, this is why DCC is crappy */
static void irc_dccsend_send_read(gpointer data, int source, PurpleInputCondition cond)
{
PurpleXfer *xfer = PURPLE_XFER(data);
IrcXfer *xd = IRC_XFER(xfer);
char buffer[64];
int len;
len = read(source, buffer, sizeof(buffer));
if (len < 0 && errno == EAGAIN)
return;
else if (len <= 0) {
/* XXX: Shouldn't this be canceling the transfer? */
purple_input_remove(xd->inpa);
xd->inpa = 0;
return;
}
xd->rxqueue = g_realloc(xd->rxqueue, len + xd->rxlen);
memcpy(xd->rxqueue + xd->rxlen, buffer, len);
xd->rxlen += len;
while (1) {
gint32 val;
size_t acked;
if (xd->rxlen < 4)
break;
memcpy(&val, xd->rxqueue, sizeof(val));
acked = ntohl(val);
xd->rxlen -= 4;
if (xd->rxlen) {
unsigned char *tmp = g_memdup(xd->rxqueue + 4, xd->rxlen);
g_free(xd->rxqueue);
xd->rxqueue = tmp;
} else {
g_free(xd->rxqueue);
xd->rxqueue = NULL;
}
if ((goffset)acked >= purple_xfer_get_size(xfer)) {
purple_input_remove(xd->inpa);
xd->inpa = 0;
purple_xfer_set_completed(xfer, TRUE);
purple_xfer_end(xfer);
return;
}
}
}
static gssize irc_dccsend_send_write(PurpleXfer *xfer, const guchar *buffer, size_t size)
{
gssize s;
gssize ret;
s = MIN((gssize)purple_xfer_get_bytes_remaining(xfer), (gssize)size);
if (!s) {
return 0;
}
ret = PURPLE_XFER_CLASS(irc_xfer_parent_class)->write(xfer, buffer, s);
if (ret < 0 && errno == EAGAIN) {
ret = 0;
}
return ret;
}
static void irc_dccsend_send_connected(gpointer data, int source, PurpleInputCondition cond) {
PurpleXfer *xfer = PURPLE_XFER(data);
IrcXfer *xd = IRC_XFER(xfer);
int conn;
conn = accept(xd->fd, NULL, 0);
if (conn == -1) {
/* Accepting the connection failed. This could just be related
* to the nonblocking nature of the listening socket, so we'll
* just try again next time */
/* Let's print an error message anyway */
purple_debug_warning("irc", "accept: %s\n", g_strerror(errno));
return;
}
purple_input_remove(purple_xfer_get_watcher(xfer));
purple_xfer_set_watcher(xfer, 0);
close(xd->fd);
xd->fd = -1;
_purple_network_set_common_socket_flags(conn);
xd->inpa = purple_input_add(conn, PURPLE_INPUT_READ, irc_dccsend_send_read, xfer);
/* Start the transfer */
purple_xfer_start(xfer, conn, NULL, 0);
}
static void
irc_dccsend_network_listen_cb(int sock, gpointer data)
{
PurpleXfer *xfer = PURPLE_XFER(data);
IrcXfer *xd = IRC_XFER(xfer);
PurpleConnection *gc;
struct irc_conn *irc;
GSocket *gsock;
int fd = -1;
const char *arg[2];
char *tmp;
struct in_addr addr;
unsigned short int port;
/* not sure what the deal is here, but it needs to be here.. gk 20190626 */
xd->listen_data = NULL;
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL
|| purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_REMOTE) {
g_object_unref(xfer);
return;
}
gc = purple_account_get_connection(purple_xfer_get_account(xfer));
irc = purple_connection_get_protocol_data(gc);
if (sock < 0) {
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to open a listening port."),
purple_request_cpar_from_connection(gc));
purple_xfer_cancel_local(xfer);
return;
}
xd->fd = sock;
port = purple_network_get_port_from_fd(sock);
purple_debug_misc("irc", "port is %hu\n", port);
/* Monitor the listening socket */
purple_xfer_set_watcher(
xfer,
purple_input_add(sock, PURPLE_INPUT_READ, irc_dccsend_send_connected, xfer)
);
/* Send the intended recipient the DCC request */
arg[0] = purple_xfer_get_remote_user(xfer);
/* Fetching this fd here assumes it won't be modified */
gsock = g_socket_connection_get_socket(irc->conn);
if (gsock != NULL) {
fd = g_socket_get_fd(gsock);
}
inet_aton(purple_network_get_my_ip(fd), &addr);
arg[1] = tmp = g_strdup_printf(
"\001DCC SEND \"%s\" %u %hu %" G_GOFFSET_FORMAT "\001",
purple_xfer_get_filename(xfer),
ntohl(addr.s_addr),
port,
purple_xfer_get_size(xfer)
);
irc_cmd_privmsg(purple_connection_get_protocol_data(gc), "msg", NULL, arg);
g_free(tmp);
}
/*
* This function is called after the user has selected a file to send.
*/
static void irc_dccsend_send_init(PurpleXfer *xfer) {
IrcXfer *xd = IRC_XFER(xfer);
PurpleConnection *gc = purple_account_get_connection(purple_xfer_get_account(xfer));
purple_xfer_set_filename(xfer, g_path_get_basename(purple_xfer_get_local_filename(xfer)));
/* Create a listening socket */
xd->listen_data = purple_network_listen_range(
0,
0,
AF_UNSPEC,
SOCK_STREAM,
TRUE,
irc_dccsend_network_listen_cb,
xfer
);
if (xd->listen_data == NULL) {
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to open a listening port."),
purple_request_cpar_from_connection(gc));
purple_xfer_cancel_local(xfer);
}
}
PurpleXfer *irc_dccsend_new_xfer(PurpleProtocolXfer *prplxfer, PurpleConnection *gc, const char *who) {
return g_object_new(
IRC_TYPE_XFER,
"account", purple_connection_get_account(gc),
"type", PURPLE_XFER_TYPE_SEND,
"remote-user", who,
NULL
);
}
/**
* Purple calls this function when the user selects Send File from the
* buddy menu
* It sets up the PurpleXfer struct and tells Purple to go ahead
*/
void irc_dccsend_send_file(PurpleProtocolXfer *prplxfer, PurpleConnection *gc, const char *who, const char *file) {
PurpleXfer *xfer = irc_dccsend_new_xfer(prplxfer, gc, who);
/* Perform the request */
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
/******************************************************************************
* PurpleXfer Implementation
*****************************************************************************/
static void
irc_dccsend_init(PurpleXfer *xfer) {
PurpleXferType type = purple_xfer_get_xfer_type(xfer);
if(type == PURPLE_XFER_TYPE_SEND) {
irc_dccsend_send_init(xfer);
} else if(type == PURPLE_XFER_TYPE_RECEIVE) {
irc_dccsend_recv_init(xfer);
}
}
/******************************************************************************
* GObject Implementation
*****************************************************************************/
static void
irc_xfer_init(IrcXfer *xfer) {
xfer->fd = -1;
}
static void
irc_xfer_finalize(GObject *obj) {
IrcXfer *xfer = IRC_XFER(obj);
/* clean up the receiving proprties */
g_free(xfer->ip);
g_free(xfer->rxqueue);
/* clean up the sending properties */
g_clear_pointer(&xfer->listen_data, purple_network_listen_cancel);
if(xfer->inpa > 0) {
purple_input_remove(xfer->inpa);
}
if(xfer->fd != -1) {
close(xfer->fd);
}
G_OBJECT_CLASS(irc_xfer_parent_class)->finalize(obj);
}
static void
irc_xfer_class_finalize(IrcXferClass *klass) {
}
static void
irc_xfer_class_init(IrcXferClass *klass) {
GObjectClass *obj_class = G_OBJECT_CLASS(klass);
PurpleXferClass *xfer_class = PURPLE_XFER_CLASS(klass);
obj_class->finalize = irc_xfer_finalize;
xfer_class->init = irc_dccsend_init;
xfer_class->ack = irc_dccsend_recv_ack;
xfer_class->write = irc_dccsend_send_write;
}
void
irc_xfer_register(GTypeModule *module) {
irc_xfer_register_type(module);
}