예제 #1
0
파일: ft.c 프로젝트: 5rather/pidgin-lwqq
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);
}
예제 #2
0
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;
}
예제 #3
0
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);
	}
}
예제 #4
0
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;
}
예제 #5
0
파일: bonjour_ft.c 프로젝트: dylex/pidgin
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;
}
예제 #6
0
파일: ft.c 프로젝트: lawm/pidgin-lwqq
void file_message(LwqqClient* lc,LwqqMsgFileMessage* file)
{
    qq_account* ac = lwqq_client_userdata(lc);
    if(file->mode == MODE_RECV) {
        PurpleAccount* account = ac->account;
        LwqqClient* lc = ac->qq;
        //for(i=0;i<file->file_count;i++){
        LwqqBuddy* buddy = lc->find_buddy_by_uin(lc,file->from);
        if(buddy == NULL ) return;
        const char* key = try_get(buddy->qqnumber,buddy->uin);
        PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_RECEIVE,key);
        purple_xfer_set_filename(xfer,file->recv.name);
        purple_xfer_set_init_fnc(xfer,recv_file_init);
        purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
        purple_xfer_set_cancel_recv_fnc(xfer,recv_file_cancel);
        LwqqMsgFileMessage* fdup = s_malloc(sizeof(*fdup));
        memcpy(fdup,file,sizeof(*fdup));
        file->from = file->to = file->reply_ip = file->recv.name = NULL;
        xfer->data = fdup;
        purple_xfer_request(xfer);
    } else if(file->mode == MODE_REFUSE) {
        if(file->refuse.cancel_type == CANCEL_BY_USER) {
            qq_sys_msg_write(ac, LWQQ_MT_BUDDY_MSG, file->from, "对方取消文件传输", PURPLE_MESSAGE_SYSTEM, time(NULL));
        } else if(file->refuse.cancel_type == CANCEL_BY_OVERTIME) {
            qq_sys_msg_write(ac, LWQQ_MT_BUDDY_MSG, file->from, "文件传输超时", PURPLE_MESSAGE_SYSTEM, time(NULL));
        }

    }

}
예제 #7
0
파일: filexfer.c 프로젝트: Lilitana/Pidgin
/*------------------------------------------------------------------------
 * A file transfer offer has been received from the MXit server.
 *
 *  @param session		The MXit session object
 *  @param usermame		The username of the sender
 *  @param filename		The name of the file being offered
 *  @param filesize		The size of the file being offered
 *  @param fileid		A unique ID that identifies this file
 */
void mxit_xfer_rx_offer( struct MXitSession* session, const char* username, const char* filename, int filesize, const char* fileid )
{
	PurpleXfer*			xfer	= NULL;
	struct mxitxfer*	mx		= NULL;

	purple_debug_info( MXIT_PLUGIN_ID, "File Offer: file=%s, from=%s, size=%i\n", filename, username, filesize );

	xfer = purple_xfer_new( session->acc, PURPLE_XFER_RECEIVE, username );
	if ( xfer ) {
		/* create a new mxit xfer struct for internal use */
		mx = g_new0( struct mxitxfer, 1 );
		mx->session = session;
		memcpy( mx->fileid, fileid, MXIT_CHUNK_FILEID_LEN );
		xfer->data = mx;

		purple_xfer_set_filename( xfer, filename );
		if( filesize > 0 )
			purple_xfer_set_size( xfer, filesize );

		/* register file transfer callback functions */
		purple_xfer_set_init_fnc( xfer, mxit_xfer_init );
		purple_xfer_set_request_denied_fnc( xfer, mxit_xfer_request_denied );
		purple_xfer_set_cancel_recv_fnc( xfer, mxit_xfer_cancel_recv );
		purple_xfer_set_end_fnc( xfer, mxit_xfer_end );

		/* give the request to the user to accept/deny */
		purple_xfer_request( xfer );
	}
}
예제 #8
0
파일: ft.c 프로젝트: 5rather/pidgin-lwqq
//the entrience for recv file messages
void file_message(LwqqClient* lc,LwqqMsgFileMessage* file)
{
	qq_account* ac = lwqq_client_userdata(lc);
	if(file->mode == MODE_RECV) {
		PurpleAccount* account = ac->account;
		LwqqClient* lc = ac->qq;
		LwqqBuddy* buddy = lc->find_buddy_by_uin(lc,file->super.from);
		if(buddy == NULL ) return;
		const char* key = try_get(buddy->qqnumber,buddy->uin);
		PurpleXfer* xfer = purple_xfer_new(account,PURPLE_XFER_RECEIVE,key);
		purple_xfer_set_filename(xfer,file->recv.name);
		purple_xfer_set_init_fnc(xfer,recv_file_init);
		purple_xfer_set_request_denied_fnc(xfer,recv_file_request_denied);
		purple_xfer_set_cancel_recv_fnc(xfer,recv_file_cancel);
		LwqqMsgFileMessage* fdup = s_malloc0(sizeof(*fdup));
		lwqq_msg_move(fdup,file);
		xfer->data = fdup;
		purple_xfer_request(xfer);
	} else if(file->mode == MODE_REFUSE) {
		if(file->refuse.cancel_type == CANCEL_BY_USER) 
			qq_sys_msg_write(ac, LWQQ_MS_BUDDY_MSG, file->super.from, 
					_("Other canceled file transport"), 
					PURPLE_MESSAGE_SYSTEM, 
					time(NULL));
		else if(file->refuse.cancel_type == CANCEL_BY_OVERTIME) 
			qq_sys_msg_write(ac, LWQQ_MS_BUDDY_MSG, file->super.from, 
					_("File transport timeout"), 
					PURPLE_MESSAGE_SYSTEM, 
					time(NULL));
	}
}
예제 #9
0
static PurpleXfer *tgprpl_new_xfer_recv (PurpleConnection *gc, const char *who) {
  PurpleXfer *X = purple_xfer_new (purple_connection_get_account (gc), PURPLE_XFER_RECEIVE, who);
  purple_xfer_set_init_fnc (X, tgprpl_xfer_recv_init);
  purple_xfer_set_cancel_recv_fnc (X, tgprpl_xfer_canceled);

  return X;
}
예제 #10
0
static PurpleXfer *tgprpl_new_xfer_recv (PurpleConnection * gc, const char *who) {
  connection_data *conn = purple_connection_get_protocol_data (gc);
  
  PurpleXfer *X = purple_xfer_new (conn->pa, PURPLE_XFER_RECEIVE, who);
  purple_xfer_set_init_fnc (X, tgprpl_xfer_recv_init);
  purple_xfer_set_cancel_recv_fnc (X, tgprpl_xfer_canceled);
  
  return X;
}
예제 #11
0
파일: ft.c 프로젝트: 5rather/pidgin-lwqq
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);
}
예제 #12
0
void
purple_pn_xfer_got_invite(struct pn_peer_call *call,
                          const char *branch,
                          const char *context)
{
    PurpleAccount *account;
    PurpleXfer *xfer;
    char *bin;
    gsize bin_len;
    guint32 file_size;
    char *file_name;
    gunichar2 *uni_name;

    account = msn_session_get_user_data (pn_peer_link_get_session (call->link));

    call->cb = xfer_completed_cb;
    call->end_cb = xfer_end_cb;
    call->progress_cb = xfer_progress_cb;
    call->branch = g_strdup(branch);

    call->pending = TRUE;

    xfer = purple_xfer_new(account, PURPLE_XFER_RECEIVE,
                           pn_peer_link_get_passport (call->link));
    if (xfer)
    {
        bin = (char *)purple_base64_decode(context, &bin_len);
        file_size = GUINT32_FROM_LE(*(gsize *)(bin + 8));

        uni_name = (gunichar2 *)(bin + 20);
        while(*uni_name != 0 && ((char *)uni_name - (bin + 20)) < MAX_FILE_NAME_LEN) {
            *uni_name = GUINT16_FROM_LE(*uni_name);
            uni_name++;
        }

        file_name = g_utf16_to_utf8((const gunichar2 *)(bin + 20), -1,
                                    NULL, NULL, NULL);

        g_free(bin);

        purple_xfer_set_filename(xfer, file_name);
        purple_xfer_set_size(xfer, file_size);
        purple_xfer_set_init_fnc(xfer, xfer_init);
        purple_xfer_set_request_denied_fnc(xfer, xfer_cancel);
        purple_xfer_set_cancel_recv_fnc(xfer, xfer_cancel);

        call->xfer = xfer;
        purple_xfer_ref(call->xfer);

        xfer->data = call;

        purple_xfer_request(xfer);
    }
}
예제 #13
0
파일: oob.c 프로젝트: dylex/pidgin
void jabber_oob_parse(JabberStream *js, const char *from, JabberIqType type,
                      const char *id, xmlnode *querynode) {
	JabberOOBXfer *jox;
	PurpleXfer *xfer;
	char *filename;
	char *url;
	xmlnode *urlnode;

	if(type != JABBER_IQ_SET)
		return;

	if(!from)
		return;

	if(!(urlnode = xmlnode_get_child(querynode, "url")))
		return;

	url = xmlnode_get_data(urlnode);

	jox = g_new0(JabberOOBXfer, 1);
	if (!purple_url_parse(url, &jox->address, &jox->port, &jox->page, NULL, NULL)) {
		g_free(url);
		return;
	}
	g_free(url);
	jox->js = js;
	jox->headers = g_string_new("");
	jox->iq_id = g_strdup(id);

	xfer = purple_xfer_new(js->gc->account, PURPLE_XFER_RECEIVE, from);
	if (xfer)
	{
		xfer->data = jox;

		if(!(filename = g_strdup(g_strrstr(jox->page, "/"))))
			filename = g_strdup(jox->page);

		purple_xfer_set_filename(xfer, filename);

		g_free(filename);

		purple_xfer_set_init_fnc(xfer,   jabber_oob_xfer_init);
		purple_xfer_set_end_fnc(xfer,    jabber_oob_xfer_end);
		purple_xfer_set_request_denied_fnc(xfer, jabber_oob_xfer_recv_denied);
		purple_xfer_set_cancel_recv_fnc(xfer, jabber_oob_xfer_recv_cancelled);
		purple_xfer_set_read_fnc(xfer,   jabber_oob_xfer_read);
		purple_xfer_set_start_fnc(xfer,  jabber_oob_xfer_start);

		js->oob_file_transfers = g_list_append(js->oob_file_transfers, xfer);

		purple_xfer_request(xfer);
	}
}
예제 #14
0
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;
}
예제 #15
0
파일: ft.c 프로젝트: Formenel/mrim-prpl
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;
}
예제 #16
0
파일: oob.c 프로젝트: bf4/pidgin-mac
void jabber_oob_parse(JabberStream *js, xmlnode *packet) {
	JabberOOBXfer *jox;
	PurpleXfer *xfer;
	char *filename;
	char *url;
	const char *type;
	xmlnode *querynode, *urlnode;

	if(!(type = xmlnode_get_attrib(packet, "type")) || strcmp(type, "set"))
		return;

	if(!(querynode = xmlnode_get_child(packet, "query")))
		return;

	if(!(urlnode = xmlnode_get_child(querynode, "url")))
		return;

	url = xmlnode_get_data(urlnode);

	jox = g_new0(JabberOOBXfer, 1);
	purple_url_parse(url, &jox->address, &jox->port, &jox->page, NULL, NULL);
	g_free(url);
	jox->js = js;
	jox->headers = g_string_new("");
	jox->iq_id = g_strdup(xmlnode_get_attrib(packet, "id"));

	xfer = purple_xfer_new(js->gc->account, PURPLE_XFER_RECEIVE,
			xmlnode_get_attrib(packet, "from"));
	if (xfer)
	{
		xfer->data = jox;

		if(!(filename = g_strdup(g_strrstr(jox->page, "/"))))
			filename = g_strdup(jox->page);

		purple_xfer_set_filename(xfer, filename);

		g_free(filename);

		purple_xfer_set_init_fnc(xfer,   jabber_oob_xfer_init);
		purple_xfer_set_end_fnc(xfer,    jabber_oob_xfer_end);
		purple_xfer_set_request_denied_fnc(xfer, jabber_oob_xfer_recv_denied);
		purple_xfer_set_cancel_recv_fnc(xfer, jabber_oob_xfer_recv_canceled);
		purple_xfer_set_read_fnc(xfer,   jabber_oob_xfer_read);
		purple_xfer_set_start_fnc(xfer,  jabber_oob_xfer_start);

		js->oob_file_transfers = g_list_append(js->oob_file_transfers, xfer);

		purple_xfer_request(xfer);
	}
}
예제 #17
0
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;
}
예제 #18
0
static void
skypeweb_got_vm_download_info(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
	PurpleConversation *conv = user_data;
	PurpleXfer *xfer;
	JsonObject *obj, *file;
	JsonArray *files;
	gint64 fileSize;
	const gchar *url, *assetId, *status;
	gchar *filename;
	
	if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT)
		return;
	obj = json_node_get_object(node);
	
	files = json_object_get_array_member(obj, "files");
	file = json_array_get_object_element(files, 0);
	if (file != NULL) {
		status = json_object_get_string_member(file, "status");
		if (status && g_str_equal(status, "ok")) {
			assetId = json_object_get_string_member(obj, "assetId");
			fileSize = json_object_get_int_member(file, "fileSize");
			url = json_object_get_string_member(file, "url");
			(void) url;
			
			filename = g_strconcat(assetId, ".mp4", NULL);
			
			xfer = purple_xfer_new(sa->account, PURPLE_XFER_RECEIVE, conv->name);
			purple_xfer_set_size(xfer, fileSize);
			purple_xfer_set_filename(xfer, filename);
			json_object_ref(file);
			purple_xfer_set_protocol_data(xfer, file);
			purple_xfer_set_init_fnc(xfer, skypeweb_init_vm_download);
			purple_xfer_set_cancel_recv_fnc(xfer, skypeweb_cancel_vm_download);
			purple_xfer_add(xfer);
			
			g_free(filename);
		} else if (status && g_str_equal(status, "running")) {
			//skypeweb_download_video_message(sa, sid??????, conv);
		}
	}
}
예제 #19
0
파일: ft.c 프로젝트: lawm/pidgin-lwqq
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);
}
예제 #20
0
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;
}
예제 #21
0
static void
silcpurple_ftp_ask_name(SilcClient client,
                        SilcClientConnection conn,
                        SilcUInt32 session_id,
                        const char *remote_filename,
                        SilcClientFileName completion,
                        void *completion_context,
                        void *context)
{
    SilcPurpleXfer xfer = context;

    xfer->completion = completion;
    xfer->completion_context = completion_context;

    purple_xfer_set_init_fnc(xfer->xfer, silcpurple_ftp_ask_name_ok);
    purple_xfer_set_request_denied_fnc(xfer->xfer, silcpurple_ftp_ask_name_cancel);

    /* Request to save the file */
    purple_xfer_set_filename(xfer->xfer, remote_filename);
    purple_xfer_request(xfer->xfer);
}
예제 #22
0
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;
}
예제 #23
0
/* 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;
}
예제 #24
0
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;
}
예제 #25
0
static PurpleXfer * ggp_edisc_xfer_recv_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_RECEIVE, 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_recv_accept);
	purple_xfer_set_request_denied_fnc(xfer, ggp_edisc_xfer_recv_reject);
	purple_xfer_set_start_fnc(xfer, ggp_edisc_xfer_recv_start);
	purple_xfer_set_cancel_recv_fnc(xfer, ggp_edisc_xfer_cancel);

	return xfer;
}
예제 #26
0
파일: filexfer.c 프로젝트: Lilitana/Pidgin
/*------------------------------------------------------------------------
 * 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;
}
예제 #27
0
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;
}
예제 #28
0
static void
bonjour_xfer_receive(PurpleConnection *pc, const char *id, const char *sid, const char *from,
		     const goffset filesize, const char *filename, int option)
{
	PurpleXfer *xfer;
	XepXfer *xf;
	BonjourData *bd;

	if(pc == NULL || id == NULL || from == NULL)
		return;

	bd = purple_connection_get_protocol_data(pc);
	if(bd == NULL)
		return;

	purple_debug_info("bonjour", "bonjour-xfer-receive.\n");

	/* Build the file transfer handle */
	xfer = purple_xfer_new(purple_connection_get_account(pc), PURPLE_XFER_TYPE_RECEIVE, from);
	xf = g_new0(XepXfer, 1);
	purple_xfer_set_protocol_data(xfer, xf);
	xf->data = bd;
	purple_xfer_set_filename(xfer, filename);
	xf->iq_id = g_strdup(id);
	xf->sid = g_strdup(sid);

	if(filesize > 0)
		purple_xfer_set_size(xfer, filesize);
	purple_xfer_set_init_fnc(xfer, bonjour_xfer_init);
	purple_xfer_set_request_denied_fnc(xfer, bonjour_xfer_request_denied);
	purple_xfer_set_cancel_recv_fnc(xfer, bonjour_xfer_cancel_recv);
	purple_xfer_set_end_fnc(xfer, bonjour_xfer_end);

	bd->xfer_lists = g_slist_append(bd->xfer_lists, xfer);

	purple_xfer_request(xfer);
}
예제 #29
0
void silcpurple_ftp_request(SilcClient client, SilcClientConnection conn,
                            SilcClientEntry client_entry, SilcUInt32 session_id,
                            const char *hostname, SilcUInt16 port)
{
    PurpleConnection *gc = client->application;
    SilcPurple sg = gc->proto_data;
    SilcPurpleXfer xfer;

    xfer = silc_calloc(1, sizeof(*xfer));
    if (!xfer) {
        silc_client_file_close(sg->client, sg->conn, session_id);
        return;
    }

    xfer->sg = sg;
    xfer->client_entry = client_entry;
    xfer->session_id = session_id;
    xfer->hostname = g_strdup(hostname);
    xfer->port = port;
    xfer->xfer = purple_xfer_new(xfer->sg->account, PURPLE_XFER_RECEIVE,
                                 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;
    }
    purple_xfer_set_init_fnc(xfer->xfer, silcpurple_ftp_request_result);
    purple_xfer_set_request_denied_fnc(xfer->xfer, silcpurple_ftp_request_denied);
    purple_xfer_set_cancel_recv_fnc(xfer->xfer, silcpurple_ftp_cancel);
    xfer->xfer->remote_ip = g_strdup(hostname);
    xfer->xfer->remote_port = port;
    xfer->xfer->data = xfer;

    /* File transfer request */
    purple_xfer_request(xfer->xfer);
}
예제 #30
0
파일: peer.c 프로젝트: Tasssadar/libpurple
/**
 * Someone else wants to establish a peer connection with us.
 */
void
peer_connection_got_proposition(OscarData *od, const gchar *bn, const gchar *message, IcbmArgsCh2 *args)
{
	PurpleConnection *gc;
	PurpleAccount *account;
	PeerConnection *conn;
	gchar *buf;

	gc = od->gc;
	account = purple_connection_get_account(gc);

	/*
	 * If we have a connection with this same cookie then they are
	 * probably just telling us they weren't able to connect to us
	 * and we should try connecting to them, instead.  Or they want
	 * to go through a proxy.
	 */
	conn = peer_connection_find_by_cookie(od, bn, args->cookie);
	if ((conn != NULL) && (conn->type == args->type))
	{
		purple_debug_info("oscar", "Remote user wants to try a "
				"different connection method\n");
		g_free(conn->proxyip);
		g_free(conn->clientip);
		g_free(conn->verifiedip);
		if (args->use_proxy)
			conn->proxyip = g_strdup(args->proxyip);
		else
			conn->proxyip = NULL;
		conn->verifiedip = g_strdup(args->verifiedip);
		conn->clientip = g_strdup(args->clientip);
		conn->port = args->port;
		conn->use_proxy |= args->use_proxy;
		conn->lastrequestnumber++;
		peer_connection_trynext(conn);
		return;
	}

	/* If this is a direct IM, then close any existing session */
	if (args->type == OSCAR_CAPABILITY_DIRECTIM)
	{
		conn = peer_connection_find_by_type(od, bn, args->type);
		if (conn != NULL)
		{
			/* Close the old direct IM and start a new one */
			purple_debug_info("oscar", "Received new direct IM request "
				"from %s.  Destroying old connection.\n", bn);
			peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_CLOSED, NULL);
		}
	}

	/* Check for proper arguments */
	if (args->type == OSCAR_CAPABILITY_SENDFILE)
	{
		if ((args->info.sendfile.filename == NULL) ||
			(args->info.sendfile.totsize == 0) ||
			(args->info.sendfile.totfiles == 0))
		{
			purple_debug_warning("oscar",
					"%s tried to send you a file with incomplete "
					"information.\n", bn);
			return;
		}
	}

	conn = peer_connection_new(od, args->type, bn);
	memcpy(conn->cookie, args->cookie, 8);
	if (args->use_proxy)
		conn->proxyip = g_strdup(args->proxyip);
	conn->clientip = g_strdup(args->clientip);
	conn->verifiedip = g_strdup(args->verifiedip);
	conn->port = args->port;
	conn->use_proxy |= args->use_proxy;
	conn->lastrequestnumber++;

	if (args->type == OSCAR_CAPABILITY_DIRECTIM)
	{
		buf = g_strdup_printf(_("%s has just asked to directly connect to %s"),
				bn, purple_account_get_username(account));

		purple_request_action(conn, NULL, buf,
						_("This requires a direct connection between "
						  "the two computers and is necessary for IM "
						  "Images.  Because your IP address will be "
						  "revealed, this may be considered a privacy "
						  "risk."),
						PURPLE_DEFAULT_ACTION_NONE,
						account, bn, NULL,
						conn, 2,
						_("C_onnect"), G_CALLBACK(peer_connection_got_proposition_yes_cb),
						_("Cancel"), G_CALLBACK(peer_connection_got_proposition_no_cb));
	}
	else if (args->type == OSCAR_CAPABILITY_SENDFILE)
	{
		gchar *filename;

		conn->xfer = purple_xfer_new(account, PURPLE_XFER_RECEIVE, bn);
		if (conn->xfer)
		{
			conn->xfer->data = conn;
			purple_xfer_ref(conn->xfer);
			purple_xfer_set_size(conn->xfer, args->info.sendfile.totsize);

			/* Set the file name */
			if (g_utf8_validate(args->info.sendfile.filename, -1, NULL))
				filename = g_strdup(args->info.sendfile.filename);
			else
				filename = purple_utf8_salvage(args->info.sendfile.filename);

			if (args->info.sendfile.subtype == AIM_OFT_SUBTYPE_SEND_DIR)
			{
				/*
				 * If they are sending us a directory then the last character
				 * of the file name will be an asterisk.  We don't want to
				 * save stuff to a directory named "*" so we remove the
				 * asterisk from the file name.
				 */
				char *tmp = strrchr(filename, '\\');
				if ((tmp != NULL) && (tmp[1] == '*'))
					tmp[0] = '\0';
			}
			purple_xfer_set_filename(conn->xfer, filename);
			g_free(filename);

			/*
			 * Set the message, unless this is the dummy message from an
			 * ICQ client or an empty message from an AIM client.
			 * TODO: Maybe we should strip HTML and then see if strlen>0?
			 */
			if ((message != NULL) &&
				(g_ascii_strncasecmp(message, "<ICQ_COOL_FT>", 13) != 0) &&
				(g_ascii_strcasecmp(message, "<HTML>") != 0))
			{
				purple_xfer_set_message(conn->xfer, message);
			}

			/* Setup our I/O op functions */
			purple_xfer_set_init_fnc(conn->xfer, peer_oft_recvcb_init);
			purple_xfer_set_end_fnc(conn->xfer, peer_oft_recvcb_end);
			purple_xfer_set_request_denied_fnc(conn->xfer, peer_oft_cb_generic_cancel);
			purple_xfer_set_cancel_recv_fnc(conn->xfer, peer_oft_cb_generic_cancel);
			purple_xfer_set_ack_fnc(conn->xfer, peer_oft_recvcb_ack_recv);

			/* Now perform the request */
			purple_xfer_request(conn->xfer);
		}
	}
}