if (message != NULL)

{

im = purple_conversations_find_im_with_account(pouncee, account);

if (im == NULL)

im = purple_im_conversation_new(account, pouncee);

purple_conversation_write(PURPLE_CONVERSATION(im), NULL, message,

PURPLE_MESSAGE_SEND, time(NULL));

}

}

msgflags |= PURPLE_MESSAGE_SEND;

if (PURPLE_IS_IM_CONVERSATION(conv)) {

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

account,

purple_conversation_get_name(conv), &sent);

if ((err > 0) && (displayed != NULL))

purple_conversation_write_message(conv, NULL, displayed, msgflags, time(NULL));

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

account,

purple_conversation_get_name(conv), sent);

return g_hash_table_lookup(messages, GINT_TO_POINTER(id));

}

/******************************************************************************

* Object stuff

******************************************************************************/

"ID", "The session-unique message id",

0, G_MAXUINT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

properties[PROP_WHO] = g_param_spec_string("who",

NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

properties[PROP_CONTENTS] = g_param_spec_string("contents",

"Contents", "The message text",

PurpleMessage *

purple_message_find_by_id(guint id);

void

_purple_message_init(void);

who = Tcl_GetString(objv[2]);

text = Tcl_GetString(objv[3]);

return TCL_OK;

}

}

static int

{

BonjourData *bd = purple_connection_get_protocol_data(connection);

return 0;

}

static void

return text_new;

}

{

GGPInfo *info = purple_connection_get_protocol_data(gc);

PurpleIMConversation *im;

ggp_buddy_data *buddy_data;

gchar *gg_msg;

gboolean succ;

/* TODO: return -ENOTCONN, if not connected */

return 0;

buddy_data = ggp_buddy_get_data(purple_blist_find_buddy(

im = purple_conversations_find_im_with_account(

who, purple_connection_get_account(gc));

/* TODO: splitting messages */

if (strlen(gg_msg) > GG_MSG_MAXSIZE) {

void ggp_message_got_multilogon(PurpleConnection *gc,

const struct gg_event_msg *ev);

gchar * ggp_message_format_to_gg(PurpleConversation *conv, const gchar *text);

#endif /* _GGP_MESSAGE_PRPL_H */

static void irc_login_cb(gpointer data, gint source, const gchar *error_message);

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

static void irc_close(PurpleConnection *gc);

static int irc_chat_send(PurpleConnection *gc, int id, const char *what, PurpleMessageFlags flags);

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

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

g_free(irc);

}

{

struct irc_conn *irc = purple_connection_get_protocol_data(gc);

char *plain;

const char *args[2];

args[1] = plain;

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

who = g_strdup_printf("%s@%s/%s", chat->room, chat->server, args[0]);

g_free(who);

return PURPLE_CMD_RET_OK;

return ret;

}

{

JabberMessage *jm;

JabberBuddy *jb;

char *xhtml;

char *tmp;

char *resource;

resource = jabber_get_resource(who);

}

}

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

g_free(tmp);

void jabber_message_send(JabberMessage *jm);

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

int jabber_message_send_chat(PurpleConnection *gc, int id, const char *message, PurpleMessageFlags flags);

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

}

static int

{

PurpleAccount *account;

MsnSession *session;

MsnSwitchBoard *swboard;

MsnMessage *msg;

char *msgtext;

size_t msglen;

const char *username;

account = purple_connection_get_account(gc);

username = purple_account_get_username(account);

swboard = msn_session_find_swboard(session, who);

if (!strncmp("tel:+", who, 5)) {

send_to_mobile(gc, who, text);

g_free(text);

return 1;

if (buddy) {

PurplePresence *p = purple_buddy_get_presence(buddy);

if (purple_presence_is_status_primitive_active(p, PURPLE_STATUS_MOBILE)) {

send_to_mobile(gc, who, text);

g_free(text);

return 1;

}

}

msglen = strlen(msgtext);

if (msglen == 0) {

/* Stuff like <hr> will be ignored. Don't send an empty message

Zero (success, no echo)

Negative value (error)

*/

{

return 1; /* echo to conversation window */

}

}

static int

{

NMUserRecord *user_record = NULL;

NMConference *conf = NULL;

char *plain;

gboolean done = TRUE, created_conf = FALSE;

NMERR_T rc = NM_OK;

return 0;

user = purple_connection_get_protocol_data(gc);

return 0;

/* Create a new message */

message = nm_create_message(plain);

g_free(plain);

foreach_nullprpl_gc(report_status_change, gc, NULL);

}

{

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

PurpleAccount *to_acct = purple_accounts_find(who, NULLPRPL_ID);

PurpleConnection *to;

purple_debug_info("nullprpl", "sending message from %s to %s: %s\n",

from_username, who, message);

}

int

{

OscarData *od;

PurpleAccount *account;

int ret;

char *tmp1, *tmp2;

gboolean is_sms, is_html;

od = purple_connection_get_protocol_data(gc);

account = purple_connection_get_account(gc);

ret = 0;

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

void oscar_login(PurpleAccount *account);

void oscar_close(PurpleConnection *gc);

void oscar_set_info(PurpleConnection *gc, const char *rawinfo);

unsigned int oscar_send_typing(PurpleConnection *gc, const char *name, PurpleIMTypingState state);

void oscar_get_info(PurpleConnection *gc, const char *name);

}

struct mwPurplePluginData *pd;

struct mwConversation *conv;

g_return_val_if_fail(gc != NULL, 0);

pd = purple_connection_get_protocol_data(gc);

g_return_val_if_fail(pd != NULL, 0);

conv = mwServiceIm_getConversation(pd->srvc_im, &who);

/* this detection of features to determine how to send the message

const char *who,

const char *message) {

}

}

static int

{

SilcPurple sg = purple_connection_get_protocol_data(gc);

SilcClient client = sg->client;

int ret = 0;

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

SilcDList list;

return 0;

mflags = SILC_MESSAGE_FLAG_UTF8;

if (gc == NULL)

return PURPLE_CMD_RET_FAILED;

if (ret)

return PURPLE_CMD_RET_OK;

im = purple_im_conversation_new(account, args[0]);

if (args[1]) {

purple_conversation_write_message(PURPLE_CONVERSATION(im), purple_connection_get_display_name(gc),

args[1], PURPLE_MESSAGE_SEND, time(NULL));

}

g_free(fullto);

}

struct simple_account_data *sip = purple_connection_get_protocol_data(gc);

simple_send_message(sip, to, text, NULL);

g_free(to);

g_free(text);

if (status && g_str_equal(status, "Valid")) {

g_hash_table_insert(yd->sms_carrier,

g_strdup_printf("+%s", mobile_no), g_strdup(carrier));

} else {

g_hash_table_insert(yd->sms_carrier,

g_strdup_printf("+%s", mobile_no), g_strdup("Unknown"));

g_free(validate_request_str);

}

{

YahooData *yd = purple_connection_get_protocol_data(gc);

struct yahoo_packet *pkt = NULL;

char *msg2;

PurpleWhiteboard *wb;

int ret = 1;

glong lenc = 0;

struct yahoo_p2p_data *p2p_data;

YahooFederation fed = YAHOO_FEDERATION_NONE;

msg2 = yahoo_string_encode(gc, msg, TRUE);

if(msg2) {

sms_cb_data = g_malloc(sizeof(struct yahoo_sms_carrier_cb_data));

sms_cb_data->gc = gc;

sms_cb_data->who = g_strdup(who);

purple_conversation_write(PURPLE_CONVERSATION(im), NULL, _("Getting mobile carrier to send the SMS."), PURPLE_MESSAGE_SYSTEM, time(NULL));

GList *yahoo_blist_node_menu(PurpleBlistNode *node);

void yahoo_login(PurpleAccount *account);

void yahoo_close(PurpleConnection *gc);

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

void yahoo_set_status(PurpleAccount *account, PurpleStatus *status);

void yahoo_set_idle(PurpleConnection *gc, int idle);

}

{

const char *sig;

zephyr_account *zephyr = purple_connection_get_protocol_data(gc);

sig = "Automated reply:";

sig = zephyr_get_signature();

}

return 1;

}

#include "xfer.h"

#include "image.h"

#include "media.h"

#include "notify.h"

#include "proxy.h"

#include "plugin.h"

* errno values, or just big something. If the message should

* not be echoed to the conversation window, return 0.

*/

void (*set_info)(PurpleConnection *, const char *info);

return lar;

}

{

PurpleIMConversation *im = NULL;

PurpleAccount *account = NULL;

PurplePluginProtocolInfo *prpl_info = NULL;

int val = -EINVAL;

const gchar *auto_reply_pref = NULL;

g_return_val_if_fail(gc != NULL, val);

prpl = purple_connection_get_prpl(gc);

account = purple_connection_get_account(gc);

presence = purple_account_get_presence(account);

if (prpl_info->send_im)

/*

* XXX - If "only auto-reply when away & idle" is set, then shouldn't

!purple_strequal(auto_reply_pref, "never")) {

struct last_auto_response *lar;

lar->sent = time(NULL);

}

if (!(flags & PURPLE_MESSAGE_AUTO_RESP))

{

purple_conversation_write_message(PURPLE_CONVERSATION(im), NULL, away_msg,

PURPLE_MESSAGE_SEND | PURPLE_MESSAGE_AUTO_RESP,

#include "accounts.h"

#include "conversations.h"

#include "prpl.h"

G_BEGIN_DECLS

unsigned int purple_serv_send_typing(PurpleConnection *gc, const char *name, PurpleIMTypingState state);

void purple_serv_move_buddy(PurpleBuddy *, PurpleGroup *, PurpleGroup *);

/**

* purple_get_attention_type_from_code:

if (message != NULL)

{

im = purple_conversations_find_im_with_account(pouncee, account);

if (im == NULL)

im = purple_im_conversation_new(account, pouncee);

purple_conversation_write(PURPLE_CONVERSATION(im), NULL, message,

PURPLE_MESSAGE_SEND, time(NULL));

}

}

{

PurpleConnection *connection = purple_conversation_get_connection(mmconv->conv);

const char *convName = purple_conversation_get_name(mmconv->conv);

}

static void send_request_confirmed(MMConversation *mmconv)

{

PurpleConnection *connection = purple_conversation_get_connection(mmconv->conv);

const char *convName = purple_conversation_get_name(mmconv->conv);

}