/*------------------------------------------------------------------------
* Start the file transfer.
*
* @param xfer The file transfer object
*/
static void mxit_xfer_start( PurpleXfer* xfer )
{
goffset filesize;
unsigned char* buffer;
int wrote;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_start\n" );
if ( purple_xfer_get_type( xfer ) == PURPLE_XFER_SEND ) {
/*
* the user wants to send a file to one of his contacts. we need to create
* a buffer and copy the file data into memory and then we can send it to
* the contact. we will send the whole file with one go.
*/
filesize = purple_xfer_get_bytes_remaining( xfer );
buffer = g_malloc( filesize );
if ( fread( buffer, filesize, 1, xfer->dest_fp ) > 0 ) {
/* send data */
wrote = purple_xfer_write( xfer, buffer, filesize );
if ( wrote > 0 )
purple_xfer_set_bytes_sent( xfer, wrote );
}
else {
/* file read error */
purple_xfer_error( purple_xfer_get_type( xfer ), purple_xfer_get_account( xfer ), purple_xfer_get_remote_user( xfer ), _( "Unable to access the local file" ) );
purple_xfer_cancel_local( xfer );
}
/* free the buffer */
g_free( buffer );
buffer = NULL;
}
}
void tgprpl_xfer_free_all (connection_data *conn) {
GList *xfers = purple_xfers_get_all ();
while (xfers) {
PurpleXfer *xfer = xfers->data;
if (purple_xfer_get_account (xfer) == conn->pa) {
debug ("xfer: %s", xfer->filename);
// cancel all non-completed file tranfsers to avoid them from being called
// in future sessions, as they still contain references to already freed data.
if (! purple_xfer_is_canceled (xfer) && ! purple_xfer_is_completed (xfer)) {
purple_xfer_cancel_local (xfer);
}
// if a file transfer is still running while going offline, it will be canceled when
// cleaning up libtgl memory. Since canceled file transfers are being kept (see
// tgprpl_xfer_canceled() and tgprpl_xfer_recv_init()) those need to be freed now.
struct tgp_xfer_send_data *data = xfer->data;
if (data) {
if (data->loading) {
tgprpl_xfer_free_data (data);
xfer->data = NULL;
purple_xfer_unref (xfer);
} else {
g_warn_if_reached();
}
}
}
xfers = g_list_next(xfers);
}
}
static void yahoo_receivefile_connected(gpointer data, gint source, const gchar *error_message)
{
PurpleXfer *xfer;
struct yahoo_xfer_data *xd;
purple_debug(PURPLE_DEBUG_INFO, "yahoo",
"AAA - in yahoo_receivefile_connected\n");
if (!(xfer = data))
return;
if (!(xd = xfer->data))
return;
if ((source < 0) || (xd->path == NULL) || (xd->host == NULL)) {
purple_xfer_error(PURPLE_XFER_RECEIVE, purple_xfer_get_account(xfer),
xfer->who, _("Unable to connect."));
purple_xfer_cancel_remote(xfer);
return;
}
xfer->fd = source;
/* The first time we get here, assemble the tx buffer */
if (xd->txbuflen == 0) {
xd->txbuf = g_strdup_printf("GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n",
xd->path, xd->host);
xd->txbuflen = strlen(xd->txbuf);
xd->txbuf_written = 0;
}
if (!xd->tx_handler)
{
xd->tx_handler = purple_input_add(source, PURPLE_INPUT_WRITE,
yahoo_receivefile_send_cb, xfer);
yahoo_receivefile_send_cb(xfer, source, PURPLE_INPUT_WRITE);
}
}
/*------------------------------------------------------------------------
* A file has been received from the MXit server.
*
* @param session The MXit session object
* @param fileid A unique ID that identifies this file
* @param data The file data
* @param datalen The size of the data
*/
void mxit_xfer_rx_file( struct MXitSession* session, const char* fileid, const char* data, int datalen )
{
PurpleXfer* xfer = NULL;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_rx_file: (size=%i)\n", datalen );
/* find the file-transfer object */
xfer = find_mxit_xfer( session, fileid );
if ( xfer ) {
/* this is the transfer we have been looking for */
purple_xfer_ref( xfer );
purple_xfer_start( xfer, -1, NULL, 0 );
if ( fwrite( data, datalen, 1, xfer->dest_fp ) > 0 ) {
purple_xfer_unref( xfer );
purple_xfer_set_completed( xfer, TRUE );
purple_xfer_end( xfer );
/* inform MXit that file was successfully received */
mxit_send_file_received( session, fileid, RECV_STATUS_SUCCESS );
}
else {
/* file write error */
purple_xfer_error( purple_xfer_get_type( xfer ), purple_xfer_get_account( xfer ), purple_xfer_get_remote_user( xfer ), _( "Unable to save the file" ) );
purple_xfer_cancel_local( xfer );
}
}
else {
/* file transfer not found */
mxit_send_file_received( session, fileid, RECV_STATUS_BAD_ID );
}
}
static void
bonjour_xfer_init(PurpleXfer *xfer)
{
PurpleBuddy *buddy;
BonjourBuddy *bb;
XepXfer *xf;
xf = purple_xfer_get_protocol_data(xfer);
if(xf == NULL)
return;
purple_debug_info("bonjour", "Bonjour-xfer-init.\n");
buddy = purple_blist_find_buddy(purple_xfer_get_account(xfer), purple_xfer_get_remote_user(xfer));
/* this buddy is offline. */
if (buddy == NULL || (bb = purple_buddy_get_protocol_data(buddy)) == NULL)
return;
/* Assume it is the first IP. We could do something like keep track of which one is in use or something. */
if (bb->ips)
xf->buddy_ip = g_strdup(bb->ips->data);
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_SEND) {
/* initiate file transfer, send SI offer. */
purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_TYPE_SEND.\n");
xep_ft_si_offer(xfer, purple_xfer_get_remote_user(xfer));
} else {
/* accept file transfer request, send SI result. */
xep_ft_si_result(xfer, purple_xfer_get_remote_user(xfer));
purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_TYPE_RECEIVE.\n");
}
}
static void purple_xfer_show_file_error(PurpleXfer *xfer, const char *filename)
{
int err = errno;
gchar *msg = NULL, *utf8;
PurpleXferType xfer_type = purple_xfer_get_type(xfer);
PurpleAccount *account = purple_xfer_get_account(xfer);
utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
switch(xfer_type) {
case PURPLE_XFER_SEND:
msg = g_strdup_printf(_("Error reading %s: \n%s.\n"),
utf8, g_strerror(err));
break;
case PURPLE_XFER_RECEIVE:
msg = g_strdup_printf(_("Error writing %s: \n%s.\n"),
utf8, g_strerror(err));
break;
default:
msg = g_strdup_printf(_("Error accessing %s: \n%s.\n"),
utf8, g_strerror(err));
break;
}
g_free(utf8);
purple_xfer_conversation_write(xfer, msg, TRUE);
purple_xfer_error(xfer_type, account, xfer->who, msg);
g_free(msg);
}
/*------------------------------------------------------------------------
* Initialise a new file transfer.
*
* @param xfer The file transfer object
*/
static void mxit_xfer_init( PurpleXfer* xfer )
{
struct mxitxfer* mx = (struct mxitxfer*) xfer->data;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_xfer_init\n" );
if ( purple_xfer_get_type( xfer ) == PURPLE_XFER_SEND ) {
/* we are trying to send a file to MXit */
if ( purple_xfer_get_size( xfer ) > CP_MAX_FILESIZE ) {
/* the file is too big */
purple_xfer_error( purple_xfer_get_type( xfer ), purple_xfer_get_account( xfer ), purple_xfer_get_remote_user( xfer ), _( "The file you are trying to send is too large!" ) );
purple_xfer_cancel_local( xfer );
return;
}
/* start the file transfer */
purple_xfer_start( xfer, -1, NULL, 0 );
}
else {
/*
* we have just accepted a file transfer request from MXit. send a confirmation
* to the MXit server so that can send us the file
*/
mxit_send_file_accept( mx->session, mx->fileid, purple_xfer_get_size( xfer ), 0 );
}
}
/*------------------------------------------------------------------------
* Return the libPurple file-transfer object associated with a MXit transfer
*
* @param session The MXit session object
* @param fileid A unique ID that identifies this file
*/
static PurpleXfer* find_mxit_xfer( struct MXitSession* session, const char* fileid )
{
GList* item = NULL;
PurpleXfer* xfer = NULL;
item = purple_xfers_get_all(); /* list of all active transfers */
while ( item ) {
xfer = item->data;
if ( purple_xfer_get_account( xfer ) == session->acc ) {
/* transfer is associated with this MXit account */
struct mxitxfer* mx = xfer->data;
/* does the fileid match? */
if ( ( mx ) && ( memcmp( mx->fileid, fileid, MXIT_CHUNK_FILEID_LEN ) == 0 ) )
break;
}
item = g_list_next( item );
}
if ( item )
return item->data;
else
return NULL;
}
static void
irc_dccsend_network_listen_cb(int sock, gpointer data)
{
PurpleXfer *xfer = data;
struct irc_xfer_send_data *xd;
PurpleConnection *gc;
struct irc_conn *irc;
const char *arg[2];
char *tmp;
struct in_addr addr;
unsigned short int port;
xd = purple_xfer_get_protocol_data(xfer);
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;
}
xd = purple_xfer_get_protocol_data(xfer);
gc = purple_account_get_connection(purple_xfer_get_account(xfer));
irc = purple_connection_get_protocol_data(gc);
g_object_unref(xfer);
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);
inet_aton(purple_network_get_my_ip(irc->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);
}
static int
purple_xfer_choose_file(PurpleXfer *xfer)
{
purple_request_file(xfer, NULL, purple_xfer_get_filename(xfer),
(purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE),
G_CALLBACK(purple_xfer_choose_file_ok_cb),
G_CALLBACK(purple_xfer_choose_file_cancel_cb),
purple_xfer_get_account(xfer), xfer->who, NULL,
xfer);
return 0;
}
static void ggp_edisc_xfer_error(PurpleXfer *xfer, const gchar *msg)
{
if (purple_xfer_is_cancelled(xfer))
g_return_if_reached();
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE);
purple_xfer_conversation_write(xfer, msg, TRUE);
purple_xfer_error(
purple_xfer_get_xfer_type(xfer),
purple_xfer_get_account(xfer),
purple_xfer_get_remote_user(xfer),
msg);
ggp_edisc_xfer_free(xfer);
purple_xfer_end(xfer);
}
static void
skypeweb_xfer_send_init(PurpleXfer *xfer)
{
PurpleConnection *pc = purple_account_get_connection(purple_xfer_get_account(xfer));
SkypeWebAccount *sa = purple_connection_get_protocol_data(pc);
gchar *basename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
gchar *id, *post, *headers;
SkypeWebFileTransfer *swft = purple_xfer_get_protocol_data(xfer);
JsonObject *obj = json_object_new();
JsonObject *permissions = json_object_new();
JsonArray *userpermissions = json_array_new();
purple_xfer_set_filename(xfer, basename);
purple_xfer_ref(xfer);
json_object_set_string_member(obj, "type", "sharing/file");
json_object_set_string_member(obj, "filename", basename);
if (SKYPEWEB_BUDDY_IS_MSN(swft->from)) {
id = g_strconcat("1:", swft->from, NULL);
} else {
id = g_strconcat("8:", swft->from, NULL);
}
json_array_add_string_element(userpermissions, "read");
json_object_set_array_member(permissions, id, userpermissions);
json_object_set_object_member(obj, "permissions", permissions);
post = skypeweb_jsonobj_to_string(obj);
//POST to api.asm.skype.com /v1/objects
//{"type":"sharing/file","permissions":{"8:eionrobb":["read"]},"filename":"GiantLobsterMoose.txt"}
headers = g_strdup_printf("POST /v1/objects HTTP/1.0\r\n"
"Connection: close\r\n"
"Authorization: skype_token %s\r\n" //slightly different to normal!
"Host: " SKYPEWEB_XFER_HOST "\r\n"
"Content-Length: %d\r\n"
"Content-Type: application/json\r\n"
"\r\n\r\n%s",
sa->skype_token,
strlen(post), post);
skypeweb_fetch_url_request(sa, "https://" SKYPEWEB_XFER_HOST, TRUE, NULL, FALSE, headers, FALSE, -1, skypeweb_got_object_for_file, swft);
g_free(post);
json_object_unref(obj);
g_free(id);
g_free(basename);
}
void
purple_xfer_set_completed(PurpleXfer *xfer, gboolean completed)
{
PurpleXferUiOps *ui_ops;
g_return_if_fail(xfer != NULL);
if (completed == TRUE) {
char *msg = NULL;
PurpleConversation *conv;
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_DONE);
if (purple_xfer_get_filename(xfer) != NULL)
{
char *filename = g_markup_escape_text(purple_xfer_get_filename(xfer), -1);
if (purple_xfer_get_local_filename(xfer)
&& purple_xfer_get_type(xfer) == PURPLE_XFER_RECEIVE)
{
char *local = g_markup_escape_text(purple_xfer_get_local_filename(xfer), -1);
msg = g_strdup_printf(_("Transfer of file <A HREF=\"file://%s\">%s</A> complete"),
local, filename);
g_free(local);
}
else
msg = g_strdup_printf(_("Transfer of file %s complete"),
filename);
g_free(filename);
}
else
msg = g_strdup(_("File transfer complete"));
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, xfer->who,
purple_xfer_get_account(xfer));
if (conv != NULL)
purple_conversation_write(conv, NULL, msg, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(msg);
}
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->update_progress != NULL)
ui_ops->update_progress(xfer, purple_xfer_get_progress(xfer));
}
/*
* This function is called after the user has selected a file to send.
*/
static void irc_dccsend_send_init(PurpleXfer *xfer) {
PurpleConnection *gc = purple_account_get_connection(purple_xfer_get_account(xfer));
struct irc_xfer_send_data *xd = xfer->data;
xfer->filename = g_path_get_basename(xfer->local_filename);
purple_xfer_ref(xfer);
/* Create a listening socket */
xd->listen_data = purple_network_listen_range(0, 0, SOCK_STREAM,
irc_dccsend_network_listen_cb, xfer);
if (xd->listen_data == NULL) {
purple_xfer_unref(xfer);
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Could not open a listening port."));
purple_xfer_cancel_local(xfer);
}
}
static void
purple_xfer_conversation_write_internal(PurpleXfer *xfer,
const char *message, gboolean is_error, gboolean print_thumbnail)
{
PurpleConversation *conv = NULL;
PurpleMessageFlags flags = PURPLE_MESSAGE_SYSTEM;
char *escaped;
gconstpointer thumbnail_data;
gsize size;
g_return_if_fail(xfer != NULL);
g_return_if_fail(message != NULL);
thumbnail_data = purple_xfer_get_thumbnail(xfer, &size);
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, xfer->who,
purple_xfer_get_account(xfer));
if (conv == NULL)
return;
escaped = g_markup_escape_text(message, -1);
if (is_error)
flags |= PURPLE_MESSAGE_ERROR;
if (print_thumbnail && thumbnail_data) {
gchar *message_with_img;
gpointer data = g_memdup(thumbnail_data, size);
int id = purple_imgstore_add_with_id(data, size, NULL);
message_with_img =
g_strdup_printf("<img id='%d'> %s", id, escaped);
purple_conversation_write(conv, NULL, message_with_img, flags,
time(NULL));
purple_imgstore_unref_by_id(id);
g_free(message_with_img);
} else {
purple_conversation_write(conv, NULL, escaped, flags, time(NULL));
}
g_free(escaped);
}
/*
* This function is called after the user has selected a file to send.
*/
static void irc_dccsend_send_init(PurpleXfer *xfer) {
PurpleConnection *gc = purple_account_get_connection(purple_xfer_get_account(xfer));
struct irc_xfer_send_data *xd = purple_xfer_get_protocol_data(xfer);
purple_xfer_set_filename(xfer, g_path_get_basename(purple_xfer_get_local_filename(xfer)));
g_object_ref(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) {
g_object_unref(xfer);
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);
}
}
void purple_xfer_conversation_write(PurpleXfer *xfer, char *message, gboolean is_error)
{
PurpleConversation *conv = NULL;
PurpleMessageFlags flags = PURPLE_MESSAGE_SYSTEM;
char *escaped;
g_return_if_fail(xfer != NULL);
g_return_if_fail(message != NULL);
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, xfer->who,
purple_xfer_get_account(xfer));
if (conv == NULL)
return;
escaped = g_markup_escape_text(message, -1);
if (is_error)
flags = PURPLE_MESSAGE_ERROR;
purple_conversation_write(conv, NULL, escaped, flags, time(NULL));
g_free(escaped);
}
void
purple_xfer_request_accepted(PurpleXfer *xfer, const char *filename)
{
PurpleXferType type;
struct stat st;
char *msg, *utf8, *base;
PurpleAccount *account;
PurpleBuddy *buddy;
if (xfer == NULL)
return;
type = purple_xfer_get_type(xfer);
account = purple_xfer_get_account(xfer);
purple_debug_misc("xfer", "request accepted for %p\n", xfer);
if (!filename && type == PURPLE_XFER_RECEIVE) {
xfer->status = PURPLE_XFER_STATUS_ACCEPTED;
xfer->ops.init(xfer);
return;
}
buddy = purple_find_buddy(account, xfer->who);
if (type == PURPLE_XFER_SEND) {
/* Sending a file */
/* Check the filename. */
PurpleXferUiOps *ui_ops;
ui_ops = purple_xfer_get_ui_ops(xfer);
#ifdef _WIN32
if (g_strrstr(filename, "../") || g_strrstr(filename, "..\\"))
#else
if (g_strrstr(filename, "../"))
#endif
{
utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
msg = g_strdup_printf(_("%s is not a valid filename.\n"), utf8);
purple_xfer_error(type, account, xfer->who, msg);
g_free(utf8);
g_free(msg);
purple_xfer_unref(xfer);
return;
}
if (ui_ops == NULL || (ui_ops->ui_read == NULL && ui_ops->ui_write == NULL)) {
if (g_stat(filename, &st) == -1) {
purple_xfer_show_file_error(xfer, filename);
purple_xfer_unref(xfer);
return;
}
purple_xfer_set_local_filename(xfer, filename);
purple_xfer_set_size(xfer, st.st_size);
} else {
utf8 = g_strdup(filename);
purple_xfer_set_local_filename(xfer, filename);
}
base = g_path_get_basename(filename);
utf8 = g_filename_to_utf8(base, -1, NULL, NULL, NULL);
g_free(base);
purple_xfer_set_filename(xfer, utf8);
msg = g_strdup_printf(_("Offering to send %s to %s"),
utf8, buddy ? purple_buddy_get_alias(buddy) : xfer->who);
g_free(utf8);
purple_xfer_conversation_write(xfer, msg, FALSE);
g_free(msg);
}
else {
/* Receiving a file */
xfer->status = PURPLE_XFER_STATUS_ACCEPTED;
purple_xfer_set_local_filename(xfer, filename);
msg = g_strdup_printf(_("Starting transfer of %s from %s"),
xfer->filename, buddy ? purple_buddy_get_alias(buddy) : xfer->who);
purple_xfer_conversation_write(xfer, msg, FALSE);
g_free(msg);
}
purple_xfer_add(xfer);
xfer->ops.init(xfer);
}
void
purple_xfer_cancel_remote(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
gchar *msg;
PurpleAccount *account;
PurpleBuddy *buddy;
g_return_if_fail(xfer != NULL);
purple_request_close_with_handle(xfer);
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE);
xfer->end_time = time(NULL);
account = purple_xfer_get_account(xfer);
buddy = purple_find_buddy(account, xfer->who);
if (purple_xfer_get_filename(xfer) != NULL)
{
msg = g_strdup_printf(_("%s cancelled the transfer of %s"),
buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer));
}
else
{
msg = g_strdup_printf(_("%s cancelled the file transfer"),
buddy ? purple_buddy_get_alias(buddy) : xfer->who);
}
purple_xfer_conversation_write(xfer, msg, TRUE);
purple_xfer_error(purple_xfer_get_type(xfer), account, xfer->who, msg);
g_free(msg);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND)
{
if (xfer->ops.cancel_send != NULL)
xfer->ops.cancel_send(xfer);
}
else
{
if (xfer->ops.cancel_recv != NULL)
xfer->ops.cancel_recv(xfer);
}
if (xfer->watcher != 0) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
if (xfer->fd != -1)
close(xfer->fd);
if (xfer->dest_fp != NULL) {
fclose(xfer->dest_fp);
xfer->dest_fp = NULL;
}
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->cancel_remote != NULL)
ui_ops->cancel_remote(xfer);
xfer->bytes_remaining = 0;
purple_xfer_unref(xfer);
}
static void yahoo_sendfile_connected(gpointer data, gint source, const gchar *error_message)
{
PurpleXfer *xfer;
struct yahoo_xfer_data *xd;
struct yahoo_packet *pkt;
gchar *size, *filename, *encoded_filename, *header;
guchar *pkt_buf;
const char *host;
int port;
size_t content_length, header_len, pkt_buf_len;
PurpleConnection *gc;
PurpleAccount *account;
struct yahoo_data *yd;
purple_debug(PURPLE_DEBUG_INFO, "yahoo",
"AAA - in yahoo_sendfile_connected\n");
if (!(xfer = data))
return;
if (!(xd = xfer->data))
return;
if (source < 0) {
purple_xfer_error(PURPLE_XFER_RECEIVE, purple_xfer_get_account(xfer),
xfer->who, _("Unable to connect."));
purple_xfer_cancel_remote(xfer);
return;
}
xfer->fd = source;
/* Assemble the tx buffer */
gc = xd->gc;
account = purple_connection_get_account(gc);
yd = gc->proto_data;
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANSFER,
YAHOO_STATUS_AVAILABLE, yd->session_id);
size = g_strdup_printf("%" G_GSIZE_FORMAT, purple_xfer_get_size(xfer));
filename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
encoded_filename = yahoo_string_encode(gc, filename, NULL);
yahoo_packet_hash(pkt, "sssss", 0, purple_connection_get_display_name(gc),
5, xfer->who, 14, "", 27, encoded_filename, 28, size);
g_free(size);
g_free(encoded_filename);
g_free(filename);
content_length = YAHOO_PACKET_HDRLEN + yahoo_packet_length(pkt);
pkt_buf_len = yahoo_packet_build(pkt, 8, FALSE, yd->jp, &pkt_buf);
yahoo_packet_free(pkt);
host = purple_account_get_string(account, "xfer_host", YAHOO_XFER_HOST);
port = purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT);
header = g_strdup_printf(
"POST http://%s:%d/notifyft HTTP/1.0\r\n"
"Content-length: %" G_GSIZE_FORMAT "\r\n"
"Host: %s:%d\r\n"
"Cookie: Y=%s; T=%s\r\n"
"\r\n",
host, port, content_length + 4 + purple_xfer_get_size(xfer),
host, port, yd->cookie_y, yd->cookie_t);
header_len = strlen(header);
xd->txbuflen = header_len + pkt_buf_len + 4;
xd->txbuf = g_malloc(xd->txbuflen);
memcpy(xd->txbuf, header, header_len);
g_free(header);
memcpy(xd->txbuf + header_len, pkt_buf, pkt_buf_len);
g_free(pkt_buf);
memcpy(xd->txbuf + header_len + pkt_buf_len, "29\xc0\x80", 4);
xd->txbuf_written = 0;
if (xd->tx_handler == 0)
{
xd->tx_handler = purple_input_add(source, PURPLE_INPUT_WRITE,
yahoo_sendfile_send_cb, xfer);
yahoo_sendfile_send_cb(xfer, source, PURPLE_INPUT_WRITE);
}
}
