PurpleAccount *account;

PurpleConnection *gc;

PurpleConversationPrivate *priv = PURPLE_CONVERSATION_GET_PRIVATE(conv);

char *displayed = NULL, *sent = NULL;

int err = 0;

msgflags |= PURPLE_MESSAGE_SEND;

if (PURPLE_IS_IM_CONVERSATION(conv)) {

msg = purple_message_new(purple_conversation_get_name(conv),

sent, msgflags);

}

else if (PURPLE_IS_CHAT_CONVERSATION(conv)) {

int id = purple_chat_conversation_get_id(PURPLE_CHAT_CONVERSATION(conv));

purple_signal_emit(purple_conversations_get_handle(), "sending-chat-msg",

account, &sent, id);

purple_signal_emit(purple_conversations_get_handle(), "sent-chat-msg",

account, sent, id);

}

purple_message_new(const gchar *who, const gchar *contents,

PurpleMessageFlags flags)

{

return g_object_new(PURPLE_TYPE_MESSAGE,

"who", who,

"contents", contents,

static void irc_ssl_connect_failure(PurpleSslConnection *gsc, PurpleSslErrorType error, gpointer data);

static void irc_close(PurpleConnection *gc);

static int irc_im_send(PurpleConnection *gc, PurpleMessage *msg);

static void irc_chat_join (PurpleConnection *gc, GHashTable *data);

static void irc_input_cb(gpointer data, gint source, PurpleInputCondition cond);

static void irc_input_cb_ssl(gpointer data, PurpleSslConnection *gsc, PurpleInputCondition cond);

purple_serv_got_chat_left(gc, id);

}

{

struct irc_conn *irc = purple_connection_get_protocol_data(gc);

PurpleConversation *convo = PURPLE_CONVERSATION(purple_conversations_find_chat(gc, id));

return irc_parse_cmd(irc, convo->name, what + 1);

}

#endif

args[0] = purple_conversation_get_name(convo);

args[1] = tmp;

irc_cmd_privmsg(irc, "msg", NULL, args);

g_free(tmp);

return 0;

}

return 1;

}

{

JabberChat *chat;

JabberMessage *jm;

char *xhtml;

char *tmp;

return 0;

js = purple_connection_get_protocol_data(gc);

jm->to = g_strdup_printf("%s@%s", chat->room, chat->server);

jm->id = jabber_get_next_id(jm->js);

purple_markup_html_to_xhtml(tmp, &xhtml, &jm->body);

g_free(tmp);

tmp = jabber_message_smileyfy_xhtml(jm, xhtml);

void jabber_message_parse(JabberStream *js, PurpleXmlNode *packet);

int jabber_message_send_im(PurpleConnection *gc, PurpleMessage *msg);

unsigned int jabber_send_typing(PurpleConnection *gc, const char *who, PurpleIMTypingState state);

}

static int

{

PurpleAccount *account;

MsnSession *session;

swboard->flag |= MSN_SB_FLAG_IM;

msglen = strlen(msgtext);

if ((msglen == 0) || (msglen + strlen(msgformat) + strlen(VERSION) > 1564))

g_free(msgformat);

g_free(msgtext);

return 0;

}

*

* @param gc The connection object

* @param id The chat room ID

* @return Indicates success / failure

*/

{

struct MXitSession* session = purple_connection_get_protocol_data(gc);

struct multimx* multimx = NULL;

const char* nickname;

/* Find matching MultiMX group */

multimx = find_room_by_id(session, id);

if (multimx == NULL) {

}

/* Send packet to MXit */

/* Determine our nickname to display */

if (multimx->nickname)

nickname = purple_account_get_private_alias(purple_connection_get_account(gc)); /* local alias */

/* Display message in chat window */

return 0;

}

/*

* User has entered a message in a chatroom window, send it to the MXit server.

*/

#endif /* _MXIT_MULTIMX_H_ */

}

static int

{

NMConference *conference;

PurpleChatConversation *chat;

const char *name;

char *str, *plain;

return -1;

user = purple_connection_get_protocol_data(gc);

if (user == NULL)

return -1;

message = nm_create_message(plain);

g_free(plain);

}

}

return 0;

} else

return -1;

time(NULL));

}

const char *username = purple_account_get_username(purple_connection_get_account(gc));

PurpleChatConversation *chat = purple_conversations_find_chat(gc, id);

if (chat) {

purple_debug_info("nullprpl",

oscar_chat_kill(gc, cc);

}

{

OscarData *od = purple_connection_get_protocol_data(gc);

PurpleChatConversation *conv = NULL;

guint16 charset;

char *charsetstr;

gsize len;

if (!(conv = purple_conversations_find_chat(gc, id)))

return -EINVAL;

char *oscar_get_chat_name(GHashTable *data);

void oscar_chat_invite(PurpleConnection *gc, int id, const char *message, const char *name);

void oscar_chat_leave(PurpleConnection *gc, int id);

void oscar_keepalive(PurpleConnection *gc);

void oscar_alias_buddy(PurpleConnection *gc, const char *name, const char *alias);

void oscar_move_buddy(PurpleConnection *gc, const char *name, const char *old_group, const char *new_group);

}

struct mwPurplePluginData *pd;

struct mwConference *conf;

char *msg;

g_return_val_if_fail(pd != NULL, 0);

conf = ID_TO_CONF(pd, id);

if(conf) {

ret = ! mwConference_sendText(conf, msg);

}

}

{

SilcPurple sg = purple_connection_get_protocol_data(gc);

SilcClient client = sg->client;

SilcChannelPrivateKey key = NULL;

SilcMessageFlags flags;

int ret = 0;

char *msg2, *tmp;

gboolean found = FALSE;

gboolean sign = purple_account_get_bool(sg->account, "sign-verify", FALSE);

SilcDList list;

if (!msg || !conn)

return 0;

void silcpurple_chat_invite(PurpleConnection *gc, int id, const char *msg,

const char *name);

void silcpurple_chat_leave(PurpleConnection *gc, int id);

void silcpurple_chat_set_topic(PurpleConnection *gc, int id, const char *topic);

PurpleRoomlist *silcpurple_roomlist_get_list(PurpleConnection *gc);

void silcpurple_roomlist_cancel(PurpleRoomlist *list);

purple_serv_got_chat_left(gc, id);

}

{

PurpleChatConversation *c;

int ret;

YahooData *yd;

yd = purple_connection_get_protocol_data(gc);

if (!yd)

void yahoo_process_chat_goto(PurpleConnection *gc, struct yahoo_packet *pkt);

void yahoo_c_leave(PurpleConnection *gc, int id);

GList *yahoo_c_info(PurpleConnection *gc);

GHashTable *yahoo_c_info_defaults(PurpleConnection *gc, const char *chat_name);

void yahoo_c_join(PurpleConnection *gc, GHashTable *data);

return sig;

}

{

zephyr_triple *zt;

const char *sig;

else

recipient = local_zephyr_normalize(zephyr,zt->recipient);

return 0;

}

* errno values, or just big something.

*

* @id: The id of the chat to send the message to.

*

* Returns: A positive number or 0 in case of success,

* a negative error number in case of failure.

*/

/* If implemented, this will be called regularly for this prpl's

* active connections. You'd want to do this if you need to repeatedly

}

}

{

PurplePlugin *prpl;

PurplePluginProtocolInfo *prpl_info;

prpl = purple_connection_get_prpl(gc);

prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);

if (prpl_info->chat_send)

return -EINVAL;

}

void purple_serv_chat_invite(PurpleConnection *, int, const char *, const char *);

void purple_serv_chat_leave(PurpleConnection *, int);

void purple_serv_chat_whisper(PurpleConnection *, int, const char *, const char *);

void purple_serv_alias_buddy(PurpleBuddy *);

void purple_serv_got_alias(PurpleConnection *gc, const char *who, const char *alias);