/*------------------------------------------------------------------------
* 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 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( xfer->type, xfer->account, xfer->who, _( "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 );
}
}
static void tgprpl_xfer_send_init (PurpleXfer *X) {
debug ("tgprpl_xfer_send_init(): sending xfer accepted.");
struct tgp_xfer_send_data *data;
const char *file, *localfile, *who;
tgl_peer_t *P;
data = X->data;
purple_xfer_start (X, -1, NULL, 0);
file = purple_xfer_get_filename (X);
localfile = purple_xfer_get_local_filename (X);
who = purple_xfer_get_remote_user (X);
debug ("xfer_on_init (file=%s, local=%s, who=%s)", file, localfile, who);
P = tgp_blist_lookup_peer_get (data->conn->TLS, who);
g_return_if_fail (P);
if (tgl_get_peer_type (P->id) == TGL_PEER_ENCR_CHAT) {
purple_xfer_error (PURPLE_XFER_SEND, data->conn->pa, who,
_("Sorry, sending documents to encrypted chats not yet supported."));
purple_xfer_cancel_local (X);
return;
}
tgl_do_send_document (data->conn->TLS, P->id, (char*) localfile, NULL, 0,
TGL_SEND_MSG_FLAG_DOCUMENT_AUTO, tgprpl_xfer_send_on_finished, data);
// see comment in tgprpl_xfer_recv_init()
purple_xfer_ref (X);
data->timer = purple_timeout_add (100, tgprpl_xfer_upload_progress, X);
data->loading = TRUE;
}
/*------------------------------------------------------------------------
* 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;
}
}
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);
}
}
void sipe_backend_ft_error(struct sipe_file_transfer *ft,
const char *errmsg)
{
PurpleXfer *xfer = PURPLE_XFER;
purple_xfer_error(purple_xfer_get_type(xfer),
xfer->account, xfer->who,
errmsg);
}
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 recv_file_init(PurpleXfer* xfer)
{
qq_account* ac = purple_connection_get_protocol_data(purple_account_get_connection(xfer->account));
LwqqClient* lc = ac->qq;
LwqqMsgFileMessage* file = xfer->data;
const char* filename = purple_xfer_get_local_filename(xfer);
xfer->start_time = time(NULL);
LwqqAsyncEvent* ev = lwqq_msg_accept_file(lc,file,filename);
if(ev == NULL){
lwqq_puts("file trans error ");
purple_xfer_error(PURPLE_XFER_RECEIVE, ac->account, purple_xfer_get_remote_user(xfer), "接受文件失败");
purple_xfer_cancel_local(xfer);
return;
}
lwqq_async_event_set_progress(ev,file_trans_on_progress,xfer);
lwqq_async_add_event_listener(ev,_C_(p,recv_file_complete,xfer));
}
static void recv_file_init(PurpleXfer* xfer)
{
qq_account* ac = purple_connection_get_protocol_data(purple_account_get_connection(xfer->account));
LwqqClient* lc = ac->qq;
LwqqMsgFileMessage* file = xfer->data;
const char* filename = purple_xfer_get_local_filename(xfer);
xfer->start_time = time(NULL);
LwqqAsyncEvent* ev = lwqq_msg_accept_file(lc,file,filename);
if(ev == NULL){
lwqq_puts("file trans error ");
purple_xfer_error(PURPLE_XFER_RECEIVE, ac->account, purple_xfer_get_remote_user(xfer), _("Receive file failed"));
purple_xfer_cancel_local(xfer);
return;
}
LwqqHttpRequest* req = lwqq_async_event_get_conn(ev);
lwqq_http_on_progress(req, file_trans_on_progress, xfer);
lwqq_http_set_option(req, LWQQ_HTTP_CANCELABLE,1L);
lwqq_async_add_event_listener(ev,_C_(2p,recv_file_complete,xfer,ev));
}
static void
skypeweb_got_file(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text, gsize len, const gchar *error_message)
{
SkypeWebFileTransfer *swft = user_data;
PurpleXfer *xfer = swft->xfer;
SkypeWebAccount *sa = swft->sa;
sa->url_datas = g_slist_remove(sa->url_datas, url_data);
if (error_message) {
purple_xfer_error(purple_xfer_get_type(xfer), sa->account, swft->from, error_message);
purple_xfer_cancel_local(xfer);
} else {
purple_xfer_write_file(xfer, (guchar *)url_text, len);
purple_xfer_set_bytes_sent(xfer, len);
purple_xfer_set_completed(xfer, TRUE);
}
//cleanup
skypeweb_free_xfer(xfer);
}
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);
}
}
