/* Receiving files (IM->UI): */
static void prpl_xfer_accept(struct file_transfer *ft)
{
struct prpl_xfer_data *px = ft->data;
purple_xfer_request_accepted(px->xfer, NULL);
prpl_xfer_write_request(ft);
}
void qq_send_file(PurpleConnection* gc,const char* who,const char* filename)
{
qq_account* ac = purple_connection_get_protocol_data(gc);
if(!ac->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 mrim_send_file(PurpleConnection *gc, const char *who, const char *file) {
PurpleXfer *xfer = mrim_new_xfer(gc, who);
if (file) {
purple_xfer_request_accepted(xfer, file);
} else {
purple_xfer_request(xfer);
}
}
/**
* 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(PurpleConnection *gc, const char *who, const char *file) {
PurpleXfer *xfer = irc_dccsend_new_xfer(gc, who);
/* Perform the request */
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
/*------------------------------------------------------------------------
* The user has initiated a file transfer to a contact.
*
* @param gc The connection object
* @param who The username of the contact
* @param filename The filename (is NULL if request has not been accepted yet)
*/
void mxit_xfer_tx( PurpleConnection* gc, const char* who, const char* filename )
{
PurpleXfer *xfer = mxit_xfer_new( gc, who );
if ( filename )
purple_xfer_request_accepted( xfer, filename );
else
purple_xfer_request( xfer );
}
void
skypeweb_send_file(PurpleConnection *pc, const gchar *who, const gchar *filename)
{
PurpleXfer *xfer = skypeweb_new_xfer(pc, who);
if (filename && *filename)
purple_xfer_request_accepted(xfer, filename);
else
purple_xfer_request(xfer);
}
void tgprpl_send_file (PurpleConnection * gc, const char *who, const char *file) {
debug ("tgprpl_send_file()");
PurpleXfer *X = tgprpl_new_xfer (gc, who);
if (file) {
purple_xfer_request_accepted (X, file);
debug ("starting xfer...");
} else {
purple_xfer_request (X);
}
}
void FiletransferRepeater::handleFTSendBytestream(Bytestream *bs, const std::string &filename) {
Log("SendFileStraight", "new!");
purple_xfer_request_accepted(m_xfer, NULL);
if (filename.empty())
m_resender = new SendFileStraight(bs, 0, this);
else {
User *user = m_main->userManager()->getUserByJID(bs->initiator().bare());
m_resender = new SendFile(bs, 0, filename, user, this);
}
purple_timeout_add_seconds(3,&ui_got_data,m_xfer);
}
static void waprpl_send_file(PurpleConnection * gc, const char *who, const char *file)
{
purple_debug_info(WHATSAPP_ID, "Send file called\n");
PurpleXfer *xfer = waprpl_new_xfer(gc, who);
if (file) {
purple_xfer_request_accepted(xfer, file);
purple_debug_info(WHATSAPP_ID, "Accepted transfer of file %s\n", file);
} else
purple_xfer_request(xfer);
}
void silcpurple_ftp_send_file(PurpleConnection *gc, const char *name, const char *file)
{
PurpleXfer *xfer = silcpurple_ftp_new_xfer(gc, name);
g_return_if_fail(xfer != NULL);
/* Choose file to send */
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
void yahoo_send_file(PurpleConnection *gc, const char *who, const char *file)
{
PurpleXfer *xfer = yahoo_new_xfer(gc, who);
g_return_if_fail(xfer != NULL);
/* Now perform the request */
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
void sipe_purple_ft_send_file(PurpleConnection *gc,
const char *who,
const char *file)
{
PurpleXfer *xfer = sipe_purple_ft_new_xfer(gc, who);
if (xfer) {
if (file != NULL)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
}
void FiletransferRepeater::handleFTSendBytestream(Bytestream *bs, const std::string &filename) {
if (!m_xfer) {
Log("FiletransferRepeater::handleFTSendBytestream", "no xfer");
return;
}
purple_xfer_request_accepted(m_xfer, NULL);
if (filename.empty())
m_resender = new SendFileStraight(bs, 0, this);
else {
AbstractUser *user = Transport::instance()->userManager()->getUserByJID(bs->initiator().bare());
m_resender = new SendFile(bs, 0, filename, user, this);
}
}
void ggp_edisc_xfer_send_file(PurpleConnection *gc, const char *who,
const char *filename)
{
PurpleXfer *xfer;
g_return_if_fail(gc != NULL);
g_return_if_fail(who != NULL);
/* Nothing interesting here, this code is common among protocols.
* See ggp_edisc_xfer_send_new. */
xfer = ggp_edisc_xfer_send_new(gc, who);
if (filename)
purple_xfer_request_accepted(xfer, filename);
else
purple_xfer_request(xfer);
}
void
bonjour_send_file(PurpleConnection *gc, const char *who, const char *file)
{
PurpleXfer *xfer;
g_return_if_fail(gc != NULL);
g_return_if_fail(who != NULL);
purple_debug_info("bonjour", "Bonjour-send-file to=%s.\n", who);
xfer = bonjour_new_xfer(gc, who);
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
void yahoo_send_file(PurpleConnection *gc, const char *who, const char *file)
{
struct yahoo_xfer_data *xfer_data;
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleXfer *xfer = yahoo_new_xfer(gc, who);
g_return_if_fail(xfer != NULL);
#if 0
/* if we don't have a p2p connection, try establishing it now */
if( !g_hash_table_lookup(yd->peers, who) )
yahoo_send_p2p_pkt(gc, who, 0);
#endif
xfer_data = purple_xfer_get_protocol_data(xfer);
xfer_data->xfer_peer_idstring = yahoo_xfer_new_xfer_id();
g_hash_table_insert(yd->xfer_peer_idstring_map, xfer_data->xfer_peer_idstring, xfer);
/* Now perform the request */
if (file)
purple_xfer_request_accepted(xfer, file);
else
purple_xfer_request(xfer);
}
static void
purple_xfer_choose_file_ok_cb(void *user_data, const char *filename)
{
PurpleXfer *xfer;
PurpleXferType type;
struct stat st;
gchar *dir;
xfer = (PurpleXfer *)user_data;
type = purple_xfer_get_type(xfer);
if (g_stat(filename, &st) != 0) {
/* File not found. */
if (type == PURPLE_XFER_RECEIVE) {
#ifndef _WIN32
int mode = W_OK;
#else
int mode = F_OK;
#endif
dir = g_path_get_dirname(filename);
if (g_access(dir, mode) == 0) {
purple_xfer_request_accepted(xfer, filename);
} else {
purple_xfer_ref(xfer);
purple_notify_message(
NULL, PURPLE_NOTIFY_MSG_ERROR, NULL,
_("Directory is not writable."), NULL,
(PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer);
}
g_free(dir);
}
else {
purple_xfer_show_file_error(xfer, filename);
purple_xfer_cancel_local(xfer);
}
}
else if ((type == PURPLE_XFER_SEND) && (st.st_size == 0)) {
purple_notify_error(NULL, NULL,
_("Cannot send a file of 0 bytes."), NULL);
purple_xfer_cancel_local(xfer);
}
else if ((type == PURPLE_XFER_SEND) && S_ISDIR(st.st_mode)) {
/*
* XXX - Sending a directory should be valid for some protocols.
*/
purple_notify_error(NULL, NULL,
_("Cannot send a directory."), NULL);
purple_xfer_cancel_local(xfer);
}
else if ((type == PURPLE_XFER_RECEIVE) && S_ISDIR(st.st_mode)) {
char *msg, *utf8;
utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
msg = g_strdup_printf(
_("%s is not a regular file. Cowardly refusing to overwrite it.\n"), utf8);
g_free(utf8);
purple_notify_error(NULL, NULL, msg, NULL);
g_free(msg);
purple_xfer_request_denied(xfer);
}
else if (type == PURPLE_XFER_SEND) {
#ifndef _WIN32
int mode = R_OK;
#else
int mode = F_OK;
#endif
if (g_access(filename, mode) == 0) {
purple_xfer_request_accepted(xfer, filename);
} else {
purple_xfer_ref(xfer);
purple_notify_message(
NULL, PURPLE_NOTIFY_MSG_ERROR, NULL,
_("File is not readable."), NULL,
(PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer);
}
}
else {
purple_xfer_request_accepted(xfer, filename);
}
purple_xfer_unref(xfer);
}
static void
file_recv_request_cb(PurpleXfer *xfer, gpointer handle)
{
PurpleAccount *account;
PurpleBlistNode *node;
const char *pref;
char *filename;
char *dirname;
int accept_setting;
account = xfer->account;
node = PURPLE_BLIST_NODE(purple_find_buddy(account, xfer->who));
/* If person is on buddy list, use the buddy setting; otherwise, use the
stranger setting. */
if (node) {
node = purple_blist_node_get_parent(node);
g_return_if_fail(PURPLE_BLIST_NODE_IS_CONTACT(node));
accept_setting = purple_blist_node_get_int(node, "autoaccept");
} else {
accept_setting = purple_prefs_get_int(PREF_STRANGER);
}
switch (accept_setting)
{
case FT_ASK:
break;
case FT_ACCEPT:
pref = purple_prefs_get_string(PREF_PATH);
if (ensure_path_exists(pref))
{
int count = 1;
const char *escape;
gchar **name_and_ext;
const gchar *name;
gchar *ext;
if (purple_prefs_get_bool(PREF_NEWDIR))
dirname = g_build_filename(pref, purple_normalize(account, xfer->who), NULL);
else
dirname = g_build_filename(pref, NULL);
if (!ensure_path_exists(dirname))
{
g_free(dirname);
break;
}
/* Escape filename (if escaping is turned on) */
if (purple_prefs_get_bool(PREF_ESCAPE)) {
escape = purple_escape_filename(xfer->filename);
} else {
escape = xfer->filename;
}
filename = g_build_filename(dirname, escape, NULL);
/* Split at the first dot, to avoid uniquifying "foo.tar.gz" to "foo.tar-2.gz" */
name_and_ext = g_strsplit(escape, ".", 2);
name = name_and_ext[0];
g_return_if_fail(name != NULL);
if (name_and_ext[1] != NULL) {
/* g_strsplit does not include the separator in each chunk. */
ext = g_strdup_printf(".%s", name_and_ext[1]);
} else {
ext = g_strdup("");
}
/* Make sure the file doesn't exist. Do we want some better checking than this? */
/* FIXME: There is a race here: if the newly uniquified file name gets created between
* this g_file_test and the transfer starting, the file created in the meantime
* will be clobbered. But it's not at all straightforward to fix.
*/
while (g_file_test(filename, G_FILE_TEST_EXISTS)) {
char *file = g_strdup_printf("%s-%d%s", name, count++, ext);
g_free(filename);
filename = g_build_filename(dirname, file, NULL);
g_free(file);
}
purple_xfer_request_accepted(xfer, filename);
g_strfreev(name_and_ext);
g_free(ext);
g_free(dirname);
g_free(filename);
}
purple_signal_connect(purple_xfers_get_handle(), "file-recv-complete", handle,
PURPLE_CALLBACK(auto_accept_complete_cb), xfer);
break;
case FT_REJECT:
xfer->status = PURPLE_XFER_STATUS_CANCEL_LOCAL;
break;
}
}
