* 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 PurpleNetworkListenData *listen_data; 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) { if(purple_xfer_get_xfer_type(xfer) != PURPLE_XFER_TYPE_RECEIVE) { 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) { token = g_strsplit(msg, " ", 0); if (!token[0] || !token[1] || !token[2]) { 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]); g_string_append_len(filename, token[i], strlen(token[i]) - 1); g_string_append_len(filename, &(token[0][1]), strlen(&(token[0][1])) - 1); g_string_append(filename, token[0]); if (!token[i] || !token[i+1] || !token[i+2]) { g_string_free(filename, TRUE); "type", PURPLE_XFER_TYPE_RECEIVE, purple_xfer_set_filename(PURPLE_XFER(xfer), filename->str); xfer->remote_port = atoi(token[i+1]); nip = strtoul(token[i], NULL, 10); addr.s_addr = htonl(nip); xfer->ip = g_strdup(inet_ntoa(addr)); 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_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); len = read(source, buffer, sizeof(buffer)); if (len < 0 && errno == EAGAIN) /* XXX: Shouldn't this be canceling the transfer? */ purple_input_remove(xd->inpa); xd->rxqueue = g_realloc(xd->rxqueue, len + xd->rxlen); memcpy(xd->rxqueue + xd->rxlen, buffer, len); memcpy(&val, xd->rxqueue, sizeof(val)); unsigned char *tmp = g_memdup(xd->rxqueue + 4, xd->rxlen); if ((goffset)acked >= purple_xfer_get_size(xfer)) { purple_input_remove(xd->inpa); purple_xfer_set_completed(xfer, TRUE); static gssize irc_dccsend_send_write(PurpleXfer *xfer, const guchar *buffer, size_t size) s = MIN((gssize)purple_xfer_get_bytes_remaining(xfer), (gssize)size); ret = PURPLE_XFER_CLASS(irc_xfer_parent_class)->write(xfer, buffer, s); if (ret < 0 && errno == EAGAIN) { static void irc_dccsend_send_connected(gpointer data, int source, PurpleInputCondition cond) { PurpleXfer *xfer = PURPLE_XFER(data); IrcXfer *xd = IRC_XFER(xfer); conn = accept(xd->fd, NULL, 0); /* 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)); purple_input_remove(purple_xfer_get_watcher(xfer)); purple_xfer_set_watcher(xfer, 0); _purple_network_set_common_socket_flags(conn); xd->inpa = purple_input_add(conn, PURPLE_INPUT_READ, irc_dccsend_send_read, xfer); purple_xfer_start(xfer, conn, NULL, 0); irc_dccsend_network_listen_cb(int sock, gpointer data) PurpleXfer *xfer = PURPLE_XFER(data); IrcXfer *xd = IRC_XFER(xfer); /* not sure what the deal is here, but it needs to be here.. gk 20190626 */ if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL || purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_CANCEL_REMOTE) { gc = purple_account_get_connection(purple_xfer_get_account(xfer)); irc = purple_connection_get_protocol_data(gc); 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); port = purple_network_get_port_from_fd(sock); purple_debug_misc("irc", "port is %hu\n", port); /* Monitor the listening socket */ 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); 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), purple_xfer_get_size(xfer) irc_cmd_privmsg(purple_connection_get_protocol_data(gc), "msg", NULL, arg); * 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( irc_dccsend_network_listen_cb, 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) { "account", purple_connection_get_account(gc), "type", PURPLE_XFER_TYPE_SEND, * Purple calls this function when the user selects Send File from the * 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 */ purple_xfer_request_accepted(xfer, file); purple_xfer_request(xfer); /****************************************************************************** * PurpleXfer Implementation *****************************************************************************/ 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); /****************************************************************************** *****************************************************************************/ irc_xfer_init(IrcXfer *xfer) { irc_xfer_finalize(GObject *obj) { IrcXfer *xfer = IRC_XFER(obj); /* clean up the receiving proprties */ /* clean up the sending properties */ g_clear_pointer(&xfer->listen_data, purple_network_listen_cancel); purple_input_remove(xfer->inpa); G_OBJECT_CLASS(irc_xfer_parent_class)->finalize(obj); irc_xfer_class_finalize(IrcXferClass *klass) { 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; irc_xfer_register(GTypeModule *module) { irc_xfer_register_type(module);