qulogic/pidgin
Clone
Summary
Browse
Changes
Graph
Remove some unused stuff from PurpleMessage
6 months ago, Gary Kramlich
edc1281d605e
Remove some unused stuff from PurpleMessage
Testing Done:
Compiled and sent some messages to the echo bot and verified they were in the database.
Reviewed at https://reviews.imfreedom.org/r/2862/
/*
* purple
*
* Purple is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*
*/
/* This file is the fullcrap */
#include
<glib/gi18n-lib.h>
#include
"buddylist.h"
#include
"debug.h"
#include
"notify.h"
#include
"prefs.h"
#include
"purpleconversation.h"
#include
"purpleconversationmanager.h"
#include
"purpleprivate.h"
#include
"purpleprotocol.h"
#include
"purpleprotocolchat.h"
#include
"purpleprotocolim.h"
#include
"purpleprotocolserver.h"
#include
"request.h"
#include
"signals.h"
#include
"server.h"
#include
"status.h"
#include
"util.h"
#include
"xfer.h"
unsigned
int
purple_serv_send_typing
(
PurpleConnection
*
gc
,
const
char
*
name
,
PurpleIMTypingState
state
)
{
if
(
gc
)
{
PurpleProtocol
*
protocol
=
purple_connection_get_protocol
(
gc
);
PurpleProtocolIM
*
im
=
PURPLE_PROTOCOL_IM
(
protocol
);
return
purple_protocol_im_send_typing
(
im
,
gc
,
name
,
state
);
}
return
0
;
}
int
purple_serv_send_im
(
PurpleConnection
*
gc
,
PurpleMessage
*
msg
)
{
PurpleAccount
*
account
=
NULL
;
PurpleConversation
*
im
=
NULL
;
PurpleConversationManager
*
manager
=
NULL
;
PurpleProtocol
*
protocol
=
NULL
;
int
val
=
-
EINVAL
;
const
gchar
*
recipient
;
g_return_val_if_fail
(
gc
!=
NULL
,
val
);
g_return_val_if_fail
(
msg
!=
NULL
,
val
);
protocol
=
purple_connection_get_protocol
(
gc
);
g_return_val_if_fail
(
protocol
!=
NULL
,
val
);
g_return_val_if_fail
(
PURPLE_IS_PROTOCOL_IM
(
protocol
),
val
);
account
=
purple_connection_get_account
(
gc
);
recipient
=
purple_message_get_recipient
(
msg
);
manager
=
purple_conversation_manager_get_default
();
im
=
purple_conversation_manager_find_im
(
manager
,
account
,
recipient
);
/* we probably shouldn't be here if the protocol doesn't know how to send
* im's... but there was a similar check here before so I just reproduced
* it until we can reevaluate this function.
*/
if
(
PURPLE_IS_PROTOCOL_IM
(
protocol
))
{
PurpleProtocolIM
*
pim
=
PURPLE_PROTOCOL_IM
(
protocol
);
val
=
purple_protocol_im_send
(
pim
,
gc
,
im
,
msg
);
}
if
(
im
&&
purple_im_conversation_get_send_typed_timeout
(
PURPLE_IM_CONVERSATION
(
im
)))
purple_im_conversation_stop_send_typed_timeout
(
PURPLE_IM_CONVERSATION
(
im
));
return
val
;
}
/*
* Set buddy's alias on server roster/list
*/
void
purple_serv_alias_buddy
(
PurpleBuddy
*
b
)
{
PurpleAccount
*
account
;
PurpleConnection
*
gc
;
PurpleProtocol
*
protocol
;
if
(
b
)
{
account
=
purple_buddy_get_account
(
b
);
if
(
account
)
{
gc
=
purple_account_get_connection
(
account
);
if
(
gc
)
{
protocol
=
purple_connection_get_protocol
(
gc
);
purple_protocol_server_alias_buddy
(
PURPLE_PROTOCOL_SERVER
(
protocol
),
gc
,
purple_buddy_get_name
(
b
),
purple_buddy_get_local_alias
(
b
));
}
}
}
}
void
purple_serv_got_alias
(
PurpleConnection
*
gc
,
const
char
*
who
,
const
char
*
alias
)
{
PurpleAccount
*
account
;
PurpleBuddy
*
b
;
PurpleConversation
*
im
;
PurpleConversationManager
*
manager
;
GSList
*
buddies
;
account
=
purple_connection_get_account
(
gc
);
buddies
=
purple_blist_find_buddies
(
account
,
who
);
manager
=
purple_conversation_manager_get_default
();
while
(
buddies
!=
NULL
)
{
const
char
*
server_alias
;
b
=
buddies
->
data
;
buddies
=
g_slist_delete_link
(
buddies
,
buddies
);
server_alias
=
purple_buddy_get_server_alias
(
b
);
if
(
purple_strequal
(
server_alias
,
alias
))
continue
;
purple_buddy_set_server_alias
(
b
,
alias
);
im
=
purple_conversation_manager_find_im
(
manager
,
account
,
purple_buddy_get_name
(
b
));
if
(
im
!=
NULL
&&
alias
!=
NULL
&&
!
purple_strequal
(
alias
,
who
))
{
char
*
escaped
=
g_markup_escape_text
(
who
,
-1
);
char
*
escaped2
=
g_markup_escape_text
(
alias
,
-1
);
char
*
tmp
=
g_strdup_printf
(
_
(
"%s is now known as %s.
\n
"
),
escaped
,
escaped2
);
purple_conversation_write_system_message
(
im
,
tmp
,
PURPLE_MESSAGE_NO_LINKIFY
);
g_free
(
tmp
);
g_free
(
escaped2
);
g_free
(
escaped
);
}
}
}
void
purple_serv_got_private_alias
(
PurpleConnection
*
gc
,
const
char
*
who
,
const
char
*
alias
)
{
PurpleAccount
*
account
=
NULL
;
GSList
*
buddies
=
NULL
;
PurpleBuddy
*
b
=
NULL
;
account
=
purple_connection_get_account
(
gc
);
buddies
=
purple_blist_find_buddies
(
account
,
who
);
while
(
buddies
!=
NULL
)
{
const
char
*
balias
;
b
=
buddies
->
data
;
buddies
=
g_slist_delete_link
(
buddies
,
buddies
);
balias
=
purple_buddy_get_local_alias
(
b
);
if
(
purple_strequal
(
balias
,
alias
))
continue
;
purple_buddy_set_local_alias
(
b
,
alias
);
}
}
/*
* Move a buddy from one group to another on server.
*
* Note: For now we'll not deal with changing gc's at the same time, but
* it should be possible. Probably needs to be done, someday. Although,
* the UI for that would be difficult, because groups are Purple-wide.
*/
void
purple_serv_move_buddy
(
PurpleBuddy
*
buddy
,
PurpleGroup
*
orig
,
PurpleGroup
*
dest
)
{
PurpleAccount
*
account
;
PurpleConnection
*
gc
;
PurpleProtocol
*
protocol
;
g_return_if_fail
(
buddy
!=
NULL
);
g_return_if_fail
(
orig
!=
NULL
);
g_return_if_fail
(
dest
!=
NULL
);
account
=
purple_buddy_get_account
(
buddy
);
gc
=
purple_account_get_connection
(
account
);
if
(
gc
)
{
protocol
=
purple_connection_get_protocol
(
gc
);
purple_protocol_server_group_buddy
(
PURPLE_PROTOCOL_SERVER
(
protocol
),
gc
,
purple_buddy_get_name
(
buddy
),
purple_group_get_name
(
orig
),
purple_group_get_name
(
dest
));
}
}
void
purple_serv_join_chat
(
PurpleConnection
*
gc
,
GHashTable
*
data
)
{
PurpleProtocol
*
protocol
;
if
(
gc
)
{
protocol
=
purple_connection_get_protocol
(
gc
);
purple_protocol_chat_join
(
PURPLE_PROTOCOL_CHAT
(
protocol
),
gc
,
data
);
}
}
void
purple_serv_reject_chat
(
PurpleConnection
*
gc
,
GHashTable
*
data
)
{
PurpleProtocol
*
protocol
;
if
(
gc
)
{
protocol
=
purple_connection_get_protocol
(
gc
);
purple_protocol_chat_reject
(
PURPLE_PROTOCOL_CHAT
(
protocol
),
gc
,
data
);
}
}
void
purple_serv_chat_invite
(
PurpleConnection
*
gc
,
int
id
,
const
char
*
message
,
const
char
*
name
)
{
PurpleAccount
*
account
;
PurpleConversation
*
chat
;
PurpleConversationManager
*
manager
;
PurpleProtocol
*
protocol
=
NULL
;
char
*
buffy
;
account
=
purple_connection_get_account
(
gc
);
manager
=
purple_conversation_manager_get_default
();
chat
=
purple_conversation_manager_find_chat_by_id
(
manager
,
account
,
id
);
if
(
chat
==
NULL
)
return
;
if
(
gc
)
protocol
=
purple_connection_get_protocol
(
gc
);
buffy
=
message
&&
*
message
?
g_strdup
(
message
)
:
NULL
;
purple_signal_emit
(
purple_conversations_get_handle
(),
"chat-inviting-user"
,
chat
,
name
,
&
buffy
);
if
(
protocol
)
{
purple_protocol_chat_invite
(
PURPLE_PROTOCOL_CHAT
(
protocol
),
gc
,
id
,
buffy
,
name
);
}
purple_signal_emit
(
purple_conversations_get_handle
(),
"chat-invited-user"
,
chat
,
name
,
buffy
);
g_free
(
buffy
);
}
/* Ya know, nothing uses this except purple_chat_conversation_finalize(),
* I think I'll just merge it into that later...
* Then again, something might want to use this, from outside protocol-land
* to leave a chat without destroying the conversation.
*/
void
purple_serv_chat_leave
(
PurpleConnection
*
gc
,
int
id
)
{
PurpleProtocol
*
protocol
;
protocol
=
purple_connection_get_protocol
(
gc
);
purple_protocol_chat_leave
(
PURPLE_PROTOCOL_CHAT
(
protocol
),
gc
,
id
);
}
int
purple_serv_chat_send
(
PurpleConnection
*
gc
,
int
id
,
PurpleMessage
*
msg
)
{
PurpleAccount
*
account
=
NULL
;
PurpleProtocol
*
protocol
=
NULL
;
PurpleConversation
*
conversation
=
NULL
;
PurpleConversationManager
*
manager
=
NULL
;
g_return_val_if_fail
(
msg
!=
NULL
,
-
EINVAL
);
account
=
purple_connection_get_account
(
gc
);
protocol
=
purple_connection_get_protocol
(
gc
);
manager
=
purple_conversation_manager_get_default
();
conversation
=
purple_conversation_manager_find_chat_by_id
(
manager
,
account
,
id
);
if
(
PURPLE_PROTOCOL_IMPLEMENTS
(
protocol
,
CHAT
,
send
))
{
return
purple_protocol_chat_send
(
PURPLE_PROTOCOL_CHAT
(
protocol
),
gc
,
id
,
conversation
,
msg
);
}
return
-
EINVAL
;
}
/*
* woo. i'm actually going to comment this function. isn't that fun. make
* sure to follow along, kids
*/
void
purple_serv_got_im
(
PurpleConnection
*
gc
,
const
char
*
who
,
const
char
*
msg
,
PurpleMessageFlags
flags
,
time_t
mtime
)
{
PurpleAccount
*
account
;
PurpleConversation
*
im
;
PurpleConversationManager
*
manager
;
char
*
message
,
*
name
;
char
*
angel
,
*
buffy
;
int
plugin_return
;
PurpleMessage
*
pmsg
;
g_return_if_fail
(
msg
!=
NULL
);
account
=
purple_connection_get_account
(
gc
);
if
(
mtime
<
0
)
{
purple_debug_error
(
"server"
,
"purple_serv_got_im ignoring negative timestamp
\n
"
);
/* TODO: Would be more appropriate to use a value that indicates
that the timestamp is unknown, and surface that in the UI. */
mtime
=
time
(
NULL
);
}
/*
* XXX: Should we be setting this here, or relying on protocols to set it?
*/
flags
|=
PURPLE_MESSAGE_RECV
;
manager
=
purple_conversation_manager_get_default
();
/*
* We should update the conversation window buttons and menu,
* if it exists.
*/
im
=
purple_conversation_manager_find_im
(
manager
,
account
,
who
);
/*
* Make copies of the message and the sender in case plugins want
* to free these strings and replace them with a modified version.
*/
buffy
=
g_strdup
(
msg
);
angel
=
g_strdup
(
who
);
plugin_return
=
GPOINTER_TO_INT
(
purple_signal_emit_return_1
(
purple_conversations_get_handle
(),
"receiving-im-msg"
,
account
,
&
angel
,
&
buffy
,
im
,
&
flags
));
if
(
!
buffy
||
!
angel
||
plugin_return
)
{
g_free
(
buffy
);
g_free
(
angel
);
return
;
}
name
=
angel
;
message
=
buffy
;
purple_signal_emit
(
purple_conversations_get_handle
(),
"received-im-msg"
,
account
,
name
,
message
,
im
,
flags
);
/* search for conversation again in case it was created by received-im-msg handler */
if
(
im
==
NULL
)
{
im
=
purple_conversation_manager_find_im
(
manager
,
account
,
name
);
}
if
(
im
==
NULL
)
{
im
=
purple_im_conversation_new
(
account
,
name
);
}
pmsg
=
purple_message_new_incoming
(
name
,
message
,
flags
,
mtime
);
purple_conversation_write_message
(
im
,
pmsg
);
g_free
(
message
);
g_object_unref
(
G_OBJECT
(
pmsg
));
g_free
(
name
);
}
void
purple_serv_got_typing
(
PurpleConnection
*
gc
,
const
char
*
name
,
int
timeout
,
PurpleIMTypingState
state
)
{
PurpleAccount
*
account
;
PurpleConversation
*
conv
;
PurpleConversationManager
*
manager
;
account
=
purple_connection_get_account
(
gc
);
manager
=
purple_conversation_manager_get_default
();
conv
=
purple_conversation_manager_find_im
(
manager
,
account
,
name
);
if
(
PURPLE_IS_IM_CONVERSATION
(
conv
))
{
PurpleIMConversation
*
im
=
PURPLE_IM_CONVERSATION
(
conv
);
purple_im_conversation_set_typing_state
(
im
,
state
);
if
(
timeout
>
0
)
{
purple_im_conversation_start_typing_timeout
(
im
,
timeout
);
}
}
else
{
switch
(
state
)
{
case
PURPLE_IM_TYPING
:
purple_signal_emit
(
purple_conversations_get_handle
(),
"buddy-typing"
,
account
,
name
);
break
;
case
PURPLE_IM_TYPED
:
purple_signal_emit
(
purple_conversations_get_handle
(),
"buddy-typed"
,
account
,
name
);
break
;
case
PURPLE_IM_NOT_TYPING
:
purple_signal_emit
(
purple_conversations_get_handle
(),
"buddy-typing-stopped"
,
account
,
name
);
break
;
}
}
}
void
purple_serv_got_typing_stopped
(
PurpleConnection
*
gc
,
const
char
*
name
)
{
PurpleAccount
*
account
;
PurpleConversation
*
conv
;
PurpleConversationManager
*
manager
;
account
=
purple_connection_get_account
(
gc
);
manager
=
purple_conversation_manager_get_default
();
conv
=
purple_conversation_manager_find_im
(
manager
,
account
,
name
);
if
(
conv
!=
NULL
)
{
PurpleIMConversation
*
im
=
PURPLE_IM_CONVERSATION
(
conv
);
if
(
purple_im_conversation_get_typing_state
(
im
)
==
PURPLE_IM_NOT_TYPING
)
{
return
;
}
purple_im_conversation_stop_typing_timeout
(
im
);
purple_im_conversation_set_typing_state
(
im
,
PURPLE_IM_NOT_TYPING
);
}
else
{
purple_signal_emit
(
purple_conversations_get_handle
(),
"buddy-typing-stopped"
,
account
,
name
);
}
}
struct
chat_invite_data
{
PurpleConnection
*
gc
;
GHashTable
*
components
;
};
static
void
chat_invite_data_free
(
struct
chat_invite_data
*
cid
)
{
g_clear_pointer
(
&
cid
->
components
,
g_hash_table_destroy
);
g_free
(
cid
);
}
static
void
chat_invite_reject
(
struct
chat_invite_data
*
cid
)
{
purple_serv_reject_chat
(
cid
->
gc
,
cid
->
components
);
chat_invite_data_free
(
cid
);
}
static
void
chat_invite_accept
(
struct
chat_invite_data
*
cid
)
{
purple_serv_join_chat
(
cid
->
gc
,
cid
->
components
);
chat_invite_data_free
(
cid
);
}
void
purple_serv_got_chat_invite
(
PurpleConnection
*
gc
,
const
char
*
name
,
const
char
*
who
,
const
char
*
message
,
GHashTable
*
data
)
{
PurpleAccount
*
account
;
PurpleContactInfo
*
info
=
NULL
;
struct
chat_invite_data
*
cid
;
int
plugin_return
;
g_return_if_fail
(
name
!=
NULL
);
g_return_if_fail
(
who
!=
NULL
);
account
=
purple_connection_get_account
(
gc
);
info
=
PURPLE_CONTACT_INFO
(
account
);
cid
=
g_new0
(
struct
chat_invite_data
,
1
);
plugin_return
=
GPOINTER_TO_INT
(
purple_signal_emit_return_1
(
purple_conversations_get_handle
(),
"chat-invited"
,
account
,
who
,
name
,
message
,
data
));
cid
->
gc
=
gc
;
cid
->
components
=
data
;
if
(
plugin_return
==
0
)
{
char
*
buf2
;
if
(
message
!=
NULL
)
{
buf2
=
g_strdup_printf
(
_
(
"%s has invited %s to the chat room "
"%s:
\n
%s"
),
who
,
purple_contact_info_get_username
(
info
),
name
,
message
);
}
else
{
buf2
=
g_strdup_printf
(
_
(
"%s has invited %s to the chat room %s
\n
"
),
who
,
purple_contact_info_get_username
(
info
),
name
);
}
purple_request_accept_cancel
(
gc
,
NULL
,
_
(
"Accept chat invitation?"
),
buf2
,
PURPLE_DEFAULT_ACTION_NONE
,
purple_request_cpar_from_connection
(
gc
),
cid
,
G_CALLBACK
(
chat_invite_accept
),
G_CALLBACK
(
chat_invite_reject
));
g_free
(
buf2
);
}
else
if
(
plugin_return
>
0
)
chat_invite_accept
(
cid
);
else
chat_invite_reject
(
cid
);
}
PurpleConversation
*
purple_serv_got_joined_chat
(
PurpleConnection
*
gc
,
int
id
,
const
char
*
name
)
{
PurpleConversation
*
chat
;
PurpleAccount
*
account
;
account
=
purple_connection_get_account
(
gc
);
g_return_val_if_fail
(
account
!=
NULL
,
NULL
);
g_return_val_if_fail
(
name
!=
NULL
,
NULL
);
chat
=
purple_chat_conversation_new
(
account
,
name
);
g_return_val_if_fail
(
chat
!=
NULL
,
NULL
);
if
(
!
g_slist_find
(
purple_connection_get_active_chats
(
gc
),
chat
))
_purple_connection_add_active_chat
(
gc
,
PURPLE_CHAT_CONVERSATION
(
chat
));
purple_chat_conversation_set_id
(
PURPLE_CHAT_CONVERSATION
(
chat
),
id
);
purple_signal_emit
(
purple_conversations_get_handle
(),
"chat-joined"
,
chat
);
return
chat
;
}
void
purple_serv_got_chat_left
(
PurpleConnection
*
g
,
int
id
)
{
GSList
*
bcs
;
PurpleChatConversation
*
chat
=
NULL
;
for
(
bcs
=
purple_connection_get_active_chats
(
g
);
bcs
!=
NULL
;
bcs
=
bcs
->
next
)
{
if
(
purple_chat_conversation_get_id
(
PURPLE_CHAT_CONVERSATION
(
bcs
->
data
))
==
id
)
{
chat
=
(
PurpleChatConversation
*
)
bcs
->
data
;
break
;
}
}
if
(
!
chat
)
return
;
purple_debug_info
(
"server"
,
"Leaving room: %s"
,
purple_conversation_get_name
(
PURPLE_CONVERSATION
(
chat
)));
_purple_connection_remove_active_chat
(
g
,
chat
);
purple_chat_conversation_leave
(
chat
);
purple_signal_emit
(
purple_conversations_get_handle
(),
"chat-left"
,
chat
);
}
void
purple_serv_got_join_chat_failed
(
PurpleConnection
*
gc
,
GHashTable
*
data
)
{
purple_signal_emit
(
purple_conversations_get_handle
(),
"chat-join-failed"
,
gc
,
data
);
}
void
purple_serv_got_chat_in
(
PurpleConnection
*
g
,
int
id
,
const
char
*
who
,
PurpleMessageFlags
flags
,
const
char
*
message
,
time_t
mtime
)
{
GSList
*
bcs
;
PurpleChatConversation
*
chat
=
NULL
;
char
*
buffy
,
*
angel
;
int
plugin_return
;
PurpleMessage
*
pmsg
;
g_return_if_fail
(
who
!=
NULL
);
g_return_if_fail
(
message
!=
NULL
);
if
(
mtime
<
0
)
{
purple_debug_error
(
"server"
,
"purple_serv_got_chat_in ignoring negative timestamp
\n
"
);
/* TODO: Would be more appropriate to use a value that indicates
that the timestamp is unknown, and surface that in the UI. */
mtime
=
time
(
NULL
);
}
for
(
bcs
=
purple_connection_get_active_chats
(
g
);
bcs
!=
NULL
;
bcs
=
bcs
->
next
)
{
if
(
purple_chat_conversation_get_id
(
PURPLE_CHAT_CONVERSATION
(
bcs
->
data
))
==
id
)
{
chat
=
(
PurpleChatConversation
*
)
bcs
->
data
;
break
;
}
}
if
(
!
chat
)
return
;
/* Did I send the message? */
if
(
purple_strequal
(
purple_chat_conversation_get_nick
(
chat
),
purple_normalize
(
purple_conversation_get_account
(
PURPLE_CONVERSATION
(
chat
)),
who
)))
{
flags
|=
PURPLE_MESSAGE_SEND
;
flags
&=
~
PURPLE_MESSAGE_RECV
;
/* Just in case some protocol sets it! */
}
else
{
flags
|=
PURPLE_MESSAGE_RECV
;
}
/*
* Make copies of the message and the sender in case plugins want
* to free these strings and replace them with a modified version.
*/
buffy
=
g_strdup
(
message
);
angel
=
g_strdup
(
who
);
plugin_return
=
GPOINTER_TO_INT
(
purple_signal_emit_return_1
(
purple_conversations_get_handle
(),
"receiving-chat-msg"
,
purple_connection_get_account
(
g
),
&
angel
,
&
buffy
,
chat
,
&
flags
));
if
(
!
buffy
||
!
angel
||
plugin_return
)
{
g_free
(
buffy
);
g_free
(
angel
);
return
;
}
who
=
angel
;
message
=
buffy
;
purple_signal_emit
(
purple_conversations_get_handle
(),
"received-chat-msg"
,
purple_connection_get_account
(
g
),
who
,
message
,
chat
,
flags
);
if
(
flags
&
PURPLE_MESSAGE_RECV
)
{
pmsg
=
purple_message_new_incoming
(
who
,
message
,
flags
,
mtime
);
}
else
{
PurpleAccount
*
account
=
purple_connection_get_account
(
g
);
PurpleContactInfo
*
info
=
PURPLE_CONTACT_INFO
(
account
);
GDateTime
*
dt
=
g_date_time_new_from_unix_local
((
gint64
)
mtime
);
const
gchar
*
me
=
purple_contact_info_get_name_for_display
(
info
);
pmsg
=
purple_message_new_outgoing
(
me
,
who
,
message
,
flags
);
purple_message_set_timestamp
(
pmsg
,
dt
);
g_date_time_unref
(
dt
);
}
purple_conversation_write_message
(
PURPLE_CONVERSATION
(
chat
),
pmsg
);
g_free
(
angel
);
g_free
(
buffy
);
g_object_unref
(
G_OBJECT
(
pmsg
));
}
void
purple_serv_send_file
(
PurpleConnection
*
gc
,
const
char
*
who
,
const
char
*
file
)
{
PurpleProtocol
*
protocol
;
if
(
gc
)
{
protocol
=
purple_connection_get_protocol
(
gc
);
if
(
PURPLE_IS_PROTOCOL_XFER
(
protocol
))
{
PurpleProtocolXfer
*
xfer
=
PURPLE_PROTOCOL_XFER
(
protocol
);
if
(
purple_protocol_xfer_can_receive
(
xfer
,
gc
,
who
))
{
purple_protocol_xfer_send_file
(
xfer
,
gc
,
who
,
file
);
}
}
}
}