void sipe_backend_ft_incoming(struct sipe_core_public *sipe_public,
struct sipe_file_transfer *ft,
const gchar *who,
const gchar *file_name,
gsize file_size)
{
struct sipe_backend_private *purple_private = sipe_public->backend_private;
PurpleXfer *xfer;
xfer = purple_xfer_new(purple_private->account,
PURPLE_XFER_RECEIVE,
who);
if (xfer) {
ft->backend_private = (struct sipe_backend_file_transfer *)xfer;
PURPLE_XFER_DATA = ft;
purple_xfer_set_filename(xfer, file_name);
purple_xfer_set_size(xfer, file_size);
purple_xfer_set_init_fnc(xfer, ft_incoming_init);
purple_xfer_set_request_denied_fnc(xfer, ft_request_denied);
purple_xfer_set_cancel_send_fnc(xfer, ft_free_xfer_struct);
purple_xfer_set_cancel_recv_fnc(xfer, ft_free_xfer_struct);
purple_xfer_set_start_fnc(xfer, tftp_incoming_start);
purple_xfer_set_end_fnc(xfer, tftp_incoming_stop);
purple_xfer_set_read_fnc(xfer, tftp_read);
purple_xfer_request(xfer);
}
}
void qq_send_file(PurpleConnection* gc,const char* who,const char* filename)
{
qq_account* ac = purple_connection_get_protocol_data(gc);
if(!(ac->flag&DEBUG_FILE_SEND)){
//purple_notify_warning(gc,NULL,"难题尚未攻破,曙光遥遥无期","请先用离线文件传输");
PurpleXfer* xfer = purple_xfer_new(ac->account,PURPLE_XFER_SEND,who);
purple_xfer_set_init_fnc(xfer,upload_offline_file_init);
purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
purple_xfer_set_cancel_send_fnc(xfer,recv_file_cancel);
if(filename)
purple_xfer_request_accepted(xfer, filename);
else
purple_xfer_request(xfer);
return;
}
PurpleAccount* account = ac->account;
PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_SEND,who);
purple_xfer_set_init_fnc(xfer,upload_file_init);
//purple_xfer_set_init_fnc(xfer,upload_offline_file_init);
//purple_xfer_set_request_denied_fnc(xfer,file_trans_request_denied);
//purple_xfer_set_cancel_send_fnc(xfer,file_trans_cancel);
void** data = s_malloc(sizeof(void*)*3);
data[0] = ac;
xfer->data = data;
purple_xfer_request(xfer);
}
void
purple_pn_xfer_invite(PurpleXfer *xfer)
{
struct pn_peer_link *link;
struct pn_peer_call *call;
char *context;
const char *fn;
const char *fp;
fn = purple_xfer_get_filename(xfer);
fp = purple_xfer_get_local_filename(xfer);
link = xfer->data;
call = pn_peer_call_new(link);
call->init_cb = send_file_cb;
call->end_cb = xfer_end_cb;
call->progress_cb = xfer_progress_cb;
call->cb = xfer_completed_cb;
call->xfer = xfer;
purple_xfer_ref(call->xfer);
call->pending = TRUE;
purple_xfer_set_cancel_send_fnc(xfer, xfer_cancel);
xfer->data = call;
context = gen_context(fn, fp);
pn_sip_send_invite(call, "5D3E02AB-6190-11D3-BBBB-00C04F795683", 2,
context);
g_free(context);
}
PurpleXfer *yahoo_new_xfer(PurpleConnection *gc, const char *who)
{
PurpleXfer *xfer;
struct yahoo_xfer_data *xfer_data;
g_return_val_if_fail(who != NULL, NULL);
xfer_data = g_new0(struct yahoo_xfer_data, 1);
xfer_data->gc = gc;
/* Build the file transfer handle. */
xfer = purple_xfer_new(gc->account, PURPLE_XFER_SEND, who);
if (xfer)
{
xfer->data = xfer_data;
/* Setup our I/O op functions */
purple_xfer_set_init_fnc(xfer, yahoo_xfer_init);
purple_xfer_set_start_fnc(xfer, yahoo_xfer_start);
purple_xfer_set_end_fnc(xfer, yahoo_xfer_end);
purple_xfer_set_cancel_send_fnc(xfer, yahoo_xfer_cancel_send);
purple_xfer_set_cancel_recv_fnc(xfer, yahoo_xfer_cancel_recv);
purple_xfer_set_read_fnc(xfer, yahoo_xfer_read);
purple_xfer_set_write_fnc(xfer, yahoo_xfer_write);
}
return xfer;
}
PurpleXfer *sipe_purple_ft_new_xfer(PurpleConnection *gc, const char *who)
{
PurpleXfer *xfer = NULL;
if (PURPLE_CONNECTION_IS_VALID(gc)) {
xfer = purple_xfer_new(purple_connection_get_account(gc),
PURPLE_XFER_SEND, who);
if (xfer) {
struct sipe_file_transfer *ft = sipe_core_ft_allocate(PURPLE_GC_TO_SIPE_CORE_PUBLIC);
ft->backend_private = (struct sipe_backend_file_transfer *)xfer;
PURPLE_XFER_DATA = ft;
purple_xfer_set_init_fnc(xfer, ft_outgoing_init);
purple_xfer_set_request_denied_fnc(xfer, ft_request_denied);
purple_xfer_set_cancel_send_fnc(xfer, ft_free_xfer_struct);
purple_xfer_set_cancel_recv_fnc(xfer, ft_free_xfer_struct);
purple_xfer_set_start_fnc(xfer, tftp_outgoing_start);
purple_xfer_set_end_fnc(xfer, tftp_outgoing_stop);
purple_xfer_set_write_fnc(xfer, tftp_write);
}
}
return xfer;
}
PurpleXfer *
bonjour_new_xfer(PurpleConnection *gc, const char *who)
{
PurpleXfer *xfer;
XepXfer *xep_xfer;
BonjourData *bd;
if(who == NULL || gc == NULL)
return NULL;
purple_debug_info("bonjour", "Bonjour-new-xfer to %s.\n", who);
bd = (BonjourData*) gc->proto_data;
if(bd == NULL)
return NULL;
/* Build the file transfer handle */
xfer = purple_xfer_new(gc->account, PURPLE_XFER_SEND, who);
xfer->data = xep_xfer = g_new0(XepXfer, 1);
xep_xfer->data = bd;
purple_debug_info("bonjour", "Bonjour-new-xfer bd=%p data=%p.\n", bd, xep_xfer->data);
/* We don't support IBB yet */
/*xep_xfer->mode = XEP_BYTESTREAMS | XEP_IBB;*/
xep_xfer->mode = XEP_BYTESTREAMS;
xep_xfer->sid = NULL;
purple_xfer_set_init_fnc(xfer, bonjour_xfer_init);
purple_xfer_set_cancel_send_fnc(xfer, bonjour_xfer_cancel_send);
purple_xfer_set_end_fnc(xfer, bonjour_xfer_end);
bd->xfer_lists = g_slist_append(bd->xfer_lists, xfer);
return xfer;
}
void qq_send_offline_file(PurpleBlistNode* node)
{
PurpleBuddy* buddy = PURPLE_BUDDY(node);
PurpleAccount* account = purple_buddy_get_account(buddy);
PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_SEND,buddy->name);
purple_xfer_set_init_fnc(xfer,upload_offline_file_init);
purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
purple_xfer_set_cancel_send_fnc(xfer,recv_file_cancel);
purple_xfer_request(xfer);
}
PurpleXfer *tgprpl_new_xfer (PurpleConnection *gc, const char *who) {
debug ("tgprpl_new_xfer()");
PurpleXfer *X = purple_xfer_new (purple_connection_get_account (gc), PURPLE_XFER_SEND, who);
if (X) {
purple_xfer_set_init_fnc (X, tgprpl_xfer_send_init);
purple_xfer_set_cancel_send_fnc (X, tgprpl_xfer_canceled);
tgprpl_xfer_init_data (X, purple_connection_get_protocol_data (gc), NULL);
}
return X;
}
PurpleXfer *mrim_new_xfer(PurpleConnection *gc, const char *who) {
purple_debug_info("mrim-prpl", "[%s]\n", __func__);
PurpleXfer *xfer;
xfer = purple_xfer_new(gc->account, PURPLE_XFER_SEND, who);
g_return_val_if_fail(xfer != NULL, NULL);
MrimFT *data = g_new0(MrimFT, 1);
xfer->data = data;
data->mrim = gc->proto_data;
data->user_name = g_strdup(who);
purple_xfer_set_init_fnc(xfer, mrim_xfer_send_rq);
purple_xfer_set_cancel_send_fnc(xfer, mrim_xfer_cancel);
return xfer;
}
PurpleXfer *silcpurple_ftp_new_xfer(PurpleConnection *gc, const char *name)
{
SilcPurple sg = gc->proto_data;
SilcClient client = sg->client;
SilcClientConnection conn = sg->conn;
SilcClientEntry *clients;
SilcUInt32 clients_count;
SilcPurpleXfer xfer;
char *nickname;
g_return_val_if_fail(name != NULL, NULL);
if (!silc_parse_userfqdn(name, &nickname, NULL))
return NULL;
/* Find client entry */
clients = silc_client_get_clients_local(client, conn, nickname, name,
&clients_count);
if (!clients) {
silc_client_get_clients(client, conn, nickname, NULL,
silcpurple_ftp_send_file_resolved,
strdup(name));
silc_free(nickname);
return NULL;
}
xfer = silc_calloc(1, sizeof(*xfer));
g_return_val_if_fail(xfer != NULL, NULL);
xfer->sg = sg;
xfer->client_entry = clients[0];
xfer->xfer = purple_xfer_new(xfer->sg->account, PURPLE_XFER_SEND,
xfer->client_entry->nickname);
if (!xfer->xfer) {
silc_client_file_close(xfer->sg->client, xfer->sg->conn, xfer->session_id);
g_free(xfer->hostname);
silc_free(xfer);
return NULL;
}
purple_xfer_set_init_fnc(xfer->xfer, silcpurple_ftp_send);
purple_xfer_set_request_denied_fnc(xfer->xfer, silcpurple_ftp_request_denied);
purple_xfer_set_cancel_send_fnc(xfer->xfer, silcpurple_ftp_send_cancel);
xfer->xfer->data = xfer;
silc_free(clients);
silc_free(nickname);
return xfer->xfer;
}
void sipe_backend_ft_deallocate(struct sipe_file_transfer *ft)
{
PurpleXfer *xfer = PURPLE_XFER;
PurpleXferStatusType status = purple_xfer_get_status(xfer);
// If file transfer is not finished, cancel it
if ( status != PURPLE_XFER_STATUS_DONE
&& status != PURPLE_XFER_STATUS_CANCEL_LOCAL
&& status != PURPLE_XFER_STATUS_CANCEL_REMOTE) {
purple_xfer_set_cancel_recv_fnc(xfer, NULL);
purple_xfer_set_cancel_send_fnc(xfer, NULL);
purple_xfer_cancel_remote(xfer);
}
}
void
msn_request_ft(PurpleXfer *xfer)
{
MsnSlpCall *slpcall;
MsnSlpLink *slplink;
char *context;
const char *fn;
const char *fp;
fn = purple_xfer_get_filename(xfer);
fp = purple_xfer_get_local_filename(xfer);
slplink = purple_xfer_get_protocol_data(xfer);
g_return_if_fail(slplink != NULL);
g_return_if_fail(fp != NULL);
slpcall = msn_slpcall_new(slplink);
msn_slpcall_init(slpcall, MSN_SLPCALL_DC);
slpcall->session_init_cb = send_file_cb;
slpcall->end_cb = msn_xfer_end_cb;
slpcall->cb = msn_xfer_completed_cb;
slpcall->xfer = xfer;
g_object_ref(slpcall->xfer);
slpcall->pending = TRUE;
purple_xfer_set_cancel_send_fnc(xfer, msn_xfer_cancel);
purple_xfer_set_read_fnc(xfer, msn_xfer_read);
purple_xfer_set_write_fnc(xfer, msn_xfer_write);
purple_xfer_set_protocol_data(xfer, slpcall);
context = gen_context(xfer, fn, fp);
msn_slpcall_invite(slpcall, MSN_FT_GUID, P2P_APPID_FILE, context);
msn_slplink_unref(slplink);
g_free(context);
}
static PurpleXfer *
yahoo_ft_new_xfer_struct(PurpleConnection *gc, PurpleXferType type, const char *who)
{
PurpleXfer *xfer;
g_return_val_if_fail(gc != NULL, NULL);
g_return_val_if_fail(who != NULL, NULL);
xfer = purple_xfer_new(purple_connection_get_account(gc), type, who);
g_return_val_if_fail(xfer != NULL, NULL);
purple_xfer_set_init_fnc(xfer, yahoo_xfer_init_15);
purple_xfer_set_start_fnc(xfer, yahoo_xfer_start);
purple_xfer_set_end_fnc(xfer, yahoo_xfer_end);
purple_xfer_set_cancel_send_fnc(xfer, yahoo_xfer_cancel_send);
purple_xfer_set_cancel_recv_fnc(xfer, yahoo_xfer_cancel_recv);
purple_xfer_set_request_denied_fnc(xfer, yahoo_xfer_cancel_recv);
return xfer;
}
void qq_send_offline_file(PurpleBlistNode* node)
{
PurpleBuddy* buddy = PURPLE_BUDDY(node);
PurpleAccount* account = purple_buddy_get_account(buddy);
qq_account* ac = purple_connection_get_protocol_data(
purple_account_get_connection(account));
const char* who;
if(ac->qq_use_qqnum){
const char* qqnum = purple_buddy_get_name(buddy);
LwqqBuddy* b = find_buddy_by_qqnumber(ac->qq, qqnum);
if(b == NULL) return;
who = b->uin;
}else{
who = purple_buddy_get_name(buddy);
}
PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_SEND,who);
purple_xfer_set_init_fnc(xfer,upload_offline_file_init);
purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
purple_xfer_set_cancel_send_fnc(xfer,recv_file_cancel);
purple_xfer_request(xfer);
}
/* Send file (used for sending images?) */
static PurpleXfer *waprpl_new_xfer(PurpleConnection * gc, const char *who)
{
purple_debug_info(WHATSAPP_ID, "New file xfer\n");
PurpleXfer *xfer = purple_xfer_new(gc->account, PURPLE_XFER_SEND, who);
g_return_val_if_fail(xfer != NULL, NULL);
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
wa_file_upload *xfer_info = g_new0(wa_file_upload, 1);
memset(xfer_info, 0, sizeof(wa_file_upload));
xfer_info->to = g_strdup(who);
xfer->data = xfer_info;
xfer_info->wconn = wconn;
xfer_info->gc = gc;
purple_xfer_set_init_fnc(xfer, waprpl_xfer_init);
purple_xfer_set_start_fnc(xfer, waprpl_xfer_start);
purple_xfer_set_end_fnc(xfer, waprpl_xfer_end);
purple_xfer_set_cancel_send_fnc(xfer, waprpl_xfer_cancel_send);
return xfer;
}
PurpleXfer * ggp_edisc_xfer_send_new(PurpleConnection *gc, const char *who)
{
PurpleXfer *xfer;
ggp_edisc_xfer *edisc_xfer;
g_return_val_if_fail(gc != NULL, NULL);
g_return_val_if_fail(who != NULL, NULL);
xfer = purple_xfer_new(purple_connection_get_account(gc),
PURPLE_XFER_TYPE_SEND, who);
edisc_xfer = g_new0(ggp_edisc_xfer, 1);
purple_xfer_set_protocol_data(xfer, edisc_xfer);
edisc_xfer->gc = gc;
purple_xfer_set_init_fnc(xfer, ggp_edisc_xfer_send_init);
purple_xfer_set_start_fnc(xfer, ggp_edisc_xfer_send_start);
purple_xfer_set_cancel_send_fnc(xfer, ggp_edisc_xfer_cancel);
return xfer;
}
PurpleXfer *irc_dccsend_new_xfer(PurpleConnection *gc, const char *who) {
PurpleXfer *xfer;
struct irc_xfer_send_data *xd;
/* Build the file transfer handle */
xfer = purple_xfer_new(purple_connection_get_account(gc), PURPLE_XFER_SEND, who);
if (xfer)
{
xd = g_new0(struct irc_xfer_send_data, 1);
xd->fd = -1;
xfer->data = xd;
/* Setup our I/O op functions */
purple_xfer_set_init_fnc(xfer, irc_dccsend_send_init);
purple_xfer_set_write_fnc(xfer, irc_dccsend_send_write);
purple_xfer_set_end_fnc(xfer, irc_dccsend_send_destroy);
purple_xfer_set_request_denied_fnc(xfer, irc_dccsend_send_destroy);
purple_xfer_set_cancel_send_fnc(xfer, irc_dccsend_send_destroy);
}
return xfer;
}
/*------------------------------------------------------------------------
* Create and initialize a new file transfer to a contact.
*
* @param gc The connection object
* @param who The username of the recipient
*/
PurpleXfer* mxit_xfer_new( PurpleConnection* gc, const char* who )
{
struct MXitSession* session = (struct MXitSession*) gc->proto_data;
PurpleXfer* xfer = NULL;
struct mxitxfer* mx = NULL;
/* (reference: "libpurple/ft.h") */
xfer = purple_xfer_new( session->acc, PURPLE_XFER_SEND, who );
/* create file info and attach it to the file transfer */
mx = g_new0( struct mxitxfer, 1 );
mx->session = session;
xfer->data = mx;
/* configure callbacks (reference: "libpurple/ft.h") */
purple_xfer_set_init_fnc( xfer, mxit_xfer_init );
purple_xfer_set_start_fnc( xfer, mxit_xfer_start );
purple_xfer_set_end_fnc( xfer, mxit_xfer_end );
purple_xfer_set_cancel_send_fnc( xfer, mxit_xfer_cancel_send );
purple_xfer_set_write_fnc( xfer, mxit_xfer_write );
return xfer;
}
PurpleXfer *
skypeweb_new_xfer(PurpleConnection *pc, const char *who)
{
SkypeWebAccount *sa = purple_connection_get_protocol_data(pc);
PurpleXfer *xfer;
SkypeWebFileTransfer *swft;
xfer = purple_xfer_new(sa->account, PURPLE_XFER_SEND, who);
swft = g_new0(SkypeWebFileTransfer, 1);
swft->sa = sa;
swft->from = g_strdup(who);
swft->xfer = xfer;
purple_xfer_set_protocol_data(xfer, swft);
purple_xfer_set_init_fnc(xfer, skypeweb_xfer_send_init);
purple_xfer_set_write_fnc(xfer, skypeweb_xfer_send_write);
purple_xfer_set_end_fnc(xfer, skypeweb_free_xfer);
purple_xfer_set_request_denied_fnc(xfer, skypeweb_free_xfer);
purple_xfer_set_cancel_send_fnc(xfer, skypeweb_free_xfer);
return xfer;
}
void
msn_slplink_request_ft(MsnSlpLink *slplink, PurpleXfer *xfer)
{
MsnSlpCall *slpcall;
char *context;
const char *fn;
const char *fp;
fn = purple_xfer_get_filename(xfer);
fp = purple_xfer_get_local_filename(xfer);
g_return_if_fail(slplink != NULL);
g_return_if_fail(fp != NULL);
slpcall = msn_slp_call_new(slplink);
msn_slp_call_init(slpcall, MSN_SLPCALL_DC);
slpcall->session_init_cb = send_file_cb;
slpcall->end_cb = msn_xfer_end_cb;
slpcall->progress_cb = msn_xfer_progress_cb;
slpcall->cb = msn_xfer_completed_cb;
slpcall->xfer = xfer;
purple_xfer_ref(slpcall->xfer);
slpcall->pending = TRUE;
purple_xfer_set_cancel_send_fnc(xfer, msn_xfer_cancel);
xfer->data = slpcall;
context = gen_context(fn, fp);
msn_slp_call_invite(slpcall, "5D3E02AB-6190-11D3-BBBB-00C04F795683", 2,
context);
g_free(context);
}
void yahoo_process_filetransfer(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *from = NULL;
char *to = NULL;
char *msg = NULL;
char *url = NULL;
char *imv = NULL;
long expires = 0;
PurpleXfer *xfer;
struct yahoo_data *yd;
struct yahoo_xfer_data *xfer_data;
char *service = NULL;
char *filename = NULL;
unsigned long filesize = 0L;
GSList *l;
yd = gc->proto_data;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
if (pair->key == 4)
from = pair->value;
if (pair->key == 5)
to = pair->value;
if (pair->key == 14)
msg = pair->value;
if (pair->key == 20)
url = pair->value;
if (pair->key == 38)
expires = strtol(pair->value, NULL, 10);
if (pair->key == 27)
filename = pair->value;
if (pair->key == 28)
filesize = atol(pair->value);
if (pair->key == 49)
service = pair->value;
if (pair->key == 63)
imv = pair->value;
}
/*
* The remote user has changed their IMVironment. We
* record it for later use.
*/
if (from && imv && service && (strcmp("IMVIRONMENT", service) == 0)) {
g_hash_table_replace(yd->imvironments, g_strdup(from), g_strdup(imv));
return;
}
if (pkt->service == YAHOO_SERVICE_P2PFILEXFER) {
if (service && (strcmp("FILEXFER", service) != 0)) {
purple_debug_misc("yahoo", "unhandled service 0x%02x\n", pkt->service);
return;
}
}
if (msg) {
char *tmp;
tmp = strchr(msg, '\006');
if (tmp)
*tmp = '\0';
}
if (!url || !from)
return;
/* Setup the Yahoo-specific file transfer data */
xfer_data = g_new0(struct yahoo_xfer_data, 1);
xfer_data->gc = gc;
if (!purple_url_parse(url, &(xfer_data->host), &(xfer_data->port), &(xfer_data->path), NULL, NULL)) {
g_free(xfer_data);
return;
}
purple_debug_misc("yahoo_filexfer", "Host is %s, port is %d, path is %s, and the full url was %s.\n",
xfer_data->host, xfer_data->port, xfer_data->path, url);
/* Build the file transfer handle. */
xfer = purple_xfer_new(gc->account, PURPLE_XFER_RECEIVE, from);
if (xfer)
{
xfer->data = xfer_data;
/* Set the info about the incoming file. */
if (filename) {
char *utf8_filename = yahoo_string_decode(gc, filename, TRUE);
purple_xfer_set_filename(xfer, utf8_filename);
g_free(utf8_filename);
} else {
gchar *start, *end;
start = g_strrstr(xfer_data->path, "/");
if (start)
start++;
end = g_strrstr(xfer_data->path, "?");
if (start && *start && end) {
char *utf8_filename;
filename = g_strndup(start, end - start);
utf8_filename = yahoo_string_decode(gc, filename, TRUE);
g_free(filename);
purple_xfer_set_filename(xfer, utf8_filename);
g_free(utf8_filename);
filename = NULL;
}
}
purple_xfer_set_size(xfer, filesize);
/* Setup our I/O op functions */
purple_xfer_set_init_fnc(xfer, yahoo_xfer_init);
purple_xfer_set_start_fnc(xfer, yahoo_xfer_start);
purple_xfer_set_end_fnc(xfer, yahoo_xfer_end);
purple_xfer_set_cancel_send_fnc(xfer, yahoo_xfer_cancel_send);
purple_xfer_set_cancel_recv_fnc(xfer, yahoo_xfer_cancel_recv);
purple_xfer_set_read_fnc(xfer, yahoo_xfer_read);
purple_xfer_set_write_fnc(xfer, yahoo_xfer_write);
/* Now perform the request */
purple_xfer_request(xfer);
}
}
/* This function makes the necessary arrangements for receiving files */
void irc_dccsend_recv(struct irc_conn *irc, const char *from, const char *msg) {
PurpleXfer *xfer;
struct irc_xfer_rx_data *xd;
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 = purple_xfer_new(irc->account, PURPLE_XFER_RECEIVE, from);
if (xfer)
{
xd = g_new0(struct irc_xfer_rx_data, 1);
xfer->data = xd;
purple_xfer_set_filename(xfer, filename->str);
xfer->remote_port = atoi(token[i+1]);
nip = strtoul(token[i], NULL, 10);
if (nip) {
addr.s_addr = htonl(nip);
xd->ip = g_strdup(inet_ntoa(addr));
} else {
xd->ip = g_strdup(token[i]);
}
purple_debug(PURPLE_DEBUG_INFO, "irc", "Receiving file from %s\n",
xd->ip);
purple_xfer_set_size(xfer, token[i+2] ? atoi(token[i+2]) : 0);
purple_xfer_set_init_fnc(xfer, irc_dccsend_recv_init);
purple_xfer_set_ack_fnc(xfer, irc_dccsend_recv_ack);
purple_xfer_set_end_fnc(xfer, irc_dccsend_recv_destroy);
purple_xfer_set_request_denied_fnc(xfer, irc_dccsend_recv_destroy);
purple_xfer_set_cancel_send_fnc(xfer, irc_dccsend_recv_destroy);
purple_xfer_request(xfer);
}
g_strfreev(token);
g_string_free(filename, TRUE);
}
