static char *irc_send_convert(struct irc_conn *irc, const char *string)
{
char *utf8;
GError *err = NULL;
gchar **encodings;
const gchar *enclist;
enclist = purple_account_get_string(irc->account, "encoding", IRC_DEFAULT_CHARSET);
encodings = g_strsplit(enclist, ",", 2);
if (encodings[0] == NULL || !g_ascii_strcasecmp("UTF-8", encodings[0])) {
g_strfreev(encodings);
return NULL;
}
utf8 = g_convert(string, strlen(string), encodings[0], "UTF-8", NULL, NULL, &err);
if (err) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "Send conversion error: %s\n", err->message);
purple_debug(PURPLE_DEBUG_ERROR, "irc", "Sending as UTF-8 instead of %s\n", encodings[0]);
utf8 = g_strdup(string);
g_error_free(err);
}
g_strfreev(encodings);
return utf8;
}
static char *gaym_send_convert(struct gaym_conn *gaym, const char *string)
{
char *utf8;
GError *err = NULL;
const gchar *charset;
charset =
purple_account_get_string(gaym->account, "encoding",
IRC_DEFAULT_CHARSET);
if (!strcasecmp("UTF-8", charset))
return g_strdup(string);
utf8 =
g_convert(string, strlen(string), charset, "UTF-8", NULL, NULL,
&err);
if (err) {
purple_debug(PURPLE_DEBUG_ERROR, "gaym", "Send conversion error: %s\n",
err->message);
purple_debug(PURPLE_DEBUG_ERROR, "gaym",
"Sending as UTF-8 instead of %s\n", charset);
utf8 = g_strdup(string);
g_error_free(err);
}
return utf8;
}
void qq_process_request_login_token_reply(guint8 *buf, gint buf_len, PurpleConnection *gc)
{
qq_data *qd;
gchar *hex_dump;
g_return_if_fail(buf != NULL && buf_len != 0);
qd = (qq_data *) gc->proto_data;
if (buf[0] == QQ_REQUEST_LOGIN_TOKEN_REPLY_OK) {
if (buf[1] != buf_len-2) {
purple_debug(PURPLE_DEBUG_INFO, "QQ",
"Malformed login token reply packet. Packet specifies length of %d, actual length is %d\n", buf[1], buf_len-2);
purple_debug(PURPLE_DEBUG_INFO, "QQ",
"Attempting to proceed with the actual packet length.\n");
}
hex_dump = hex_dump_to_str(buf+2, buf_len-2);
purple_debug(PURPLE_DEBUG_INFO, "QQ",
"<<< got a token with %d bytes -> [default] decrypt and dump\n%s", buf_len-2, hex_dump);
qq_send_packet_login(gc, buf_len-2, buf+2);
} else {
purple_debug(PURPLE_DEBUG_ERROR, "QQ", "Unknown request login token reply code : %d\n", buf[0]);
hex_dump = hex_dump_to_str(buf, buf_len);
purple_debug(PURPLE_DEBUG_WARNING, "QQ",
">>> %d bytes -> [default] decrypt and dump\n%s",
buf_len, hex_dump);
try_dump_as_gbk(buf, buf_len);
purple_connection_error(gc, _("Error requesting login token"));
}
g_free(hex_dump);
}
GList *gfire_read_buddy_status(PurpleConnection *gc, int packet_len)
{
int index = XFIRE_HEADER_LEN + 1;
int itmp = 0;
GList *btmp = NULL;
gfire_buddy *gf_buddy = NULL;
GList *ret = NULL;
GList *sids = NULL;
GList *msgs = NULL;
GList *s, *m;
gfire_data *gfire = (gfire_data *)gc->proto_data;
itmp = gfire_read_attrib(&sids, gfire->buff_in + index, packet_len - index, "sid", FALSE, TRUE, 0, 0,
XFIRE_SID_LEN);
if (itmp < 1 ) {
//FIXME add mem cleanup code
FIXME("gfire_read_attrib returned < 1! sids");
return NULL;
}
index += itmp + 1;
itmp = gfire_read_attrib(&msgs, gfire->buff_in + index, packet_len - index, "msg", TRUE, FALSE, 0, 0, 0);
if (itmp < 1 ) {
//FIXME add mem cleanup code
FIXME("gfire_read_attrib returned < 1! msgs");
return NULL;
}
msgs = g_list_first(msgs); sids = g_list_first(sids);
m = msgs; s = sids;
while ( NULL != s ){
btmp = gfire_find_buddy_in_list(gfire->buddies, s->data, GFFB_SIDBIN);
if (NULL == btmp) {
purple_debug(PURPLE_DEBUG_MISC, "gfire", "WARN: pkt 154: (away status) could not find sid in buddy list.\n");
} else {
gf_buddy = (gfire_buddy *)btmp->data;
if (NULL != m->data) {
/* got an away message */
gf_buddy->away = TRUE;
gf_buddy->away_msg = m->data;
} else {
/* no message, user is back */
gf_buddy->away = FALSE;
if (NULL != gf_buddy->away_msg) g_free(gf_buddy->away_msg);
gf_buddy->away_msg = NULL;
}
ret = g_list_append(ret, (gpointer *)gf_buddy);
purple_debug(PURPLE_DEBUG_MISC, "gfire","(away): %s, is away/back with msg %s\n",
NN(gf_buddy->name), NN(gf_buddy->away_msg));
}
g_free(s->data);
s->data = NULL;
s = g_list_next(s); m = g_list_next(m);
}
g_list_free(msgs);
g_list_free(sids);
return ret;
}
gboolean gfire_game_load_config_xml(gboolean p_force)
{
if(!p_force && gfire_games_config)
return TRUE;
xmlnode *node = NULL;
gchar *filename = g_build_filename(purple_user_dir(), "gfire_game_config.xml", NULL);
if(filename)
{
purple_debug(PURPLE_DEBUG_INFO, "gfire", "Loading Game Launch Data from: %s\n", filename);
g_free(filename);
}
node = purple_util_read_xml_from_file("gfire_game_config.xml", "Gfire Game Config List");
if(!node)
{
purple_debug(PURPLE_DEBUG_ERROR, "gfire", "gfire_game_load_config_xml: Couldn't load game config.\n");
return FALSE;
}
// Check for a valid game config
if(g_utf8_collate(node->name, "game_config"))
{
xmlnode_free(node);
return FALSE;
}
// Check for a valid version
if(!xmlnode_get_attrib(node, "version") || g_utf8_collate(xmlnode_get_attrib(node, "version"), "2"))
{
xmlnode_free(node);
return FALSE;
}
// Delete all old configurations
gfire_game_config_cleanup();
// Parse all games
xmlnode *game_node = xmlnode_get_child(node, "game");
while(game_node)
{
gfire_game_configuration *gconf = gfire_game_configuration_create_from_xml(game_node);
if(gconf)
gfire_games_config = g_list_append(gfire_games_config, gconf);
game_node = xmlnode_get_next_twin(game_node);
}
gfire_game_config_sort();
xmlnode_free(node);
return TRUE;
}
gboolean gfire_game_load_games_xml()
{
xmlnode *node = NULL;
gchar *filename = g_build_filename(purple_user_dir(), "gfire_games.xml", NULL);
if(filename)
{
purple_debug(PURPLE_DEBUG_INFO, "gfire", "Loading Game Data from: %s\n", filename);
g_free(filename);
}
node = purple_util_read_xml_from_file("gfire_games.xml", "Gfire Games List");
if(!node)
{
purple_debug(PURPLE_DEBUG_ERROR, "gfire", "gfire_game_load_games_xml: Couldn't load game list.\n");
return FALSE;
}
// Delete all old games
gfire_game_cleanup();
// Read the games version
if(g_utf8_collate(node->name, "games"))
{
xmlnode_free(node);
return FALSE;
}
if(!xmlnode_get_attrib(node, "version"))
gfire_games_version = 0;
else
sscanf(xmlnode_get_attrib(node, "version"), "%u", &gfire_games_version);
// Read all games
xmlnode *game_node = xmlnode_get_child(node, "game");
while(game_node)
{
gboolean external = FALSE;
gfire_game *game = gfire_game_create_from_xml(game_node, &external);
if(game)
{
gfire_games = g_list_append(gfire_games, game);
if(external)
gfire_games_external = g_list_append(gfire_games_external, game);
}
game_node = xmlnode_get_next_twin(game_node);
}
xmlnode_free(node);
return TRUE;
}
static gboolean
load_perl_plugin(PurplePlugin *plugin)
{
PurplePerlScript *gps = (PurplePerlScript *)plugin->info->extra_info;
char *atmp[3] = { plugin->path, NULL, NULL };
if (gps == NULL || gps->load_sub == NULL)
return FALSE;
purple_debug(PURPLE_DEBUG_INFO, "perl", "Loading perl script\n");
if (my_perl == NULL)
perl_init();
plugin->handle = gps;
atmp[1] = gps->package;
PERL_SET_CONTEXT(my_perl);
execute_perl("Purple::PerlLoader::load_n_eval", 2, atmp);
{
dSP;
PERL_SET_CONTEXT(my_perl);
SPAGAIN;
ENTER;
SAVETMPS;
PUSHMARK(sp);
XPUSHs(sv_2mortal(purple_perl_bless_object(plugin,
"Purple::Plugin")));
PUTBACK;
perl_call_pv(gps->load_sub, G_EVAL | G_SCALAR);
SPAGAIN;
if (SvTRUE(ERRSV)) {
STRLEN len;
purple_debug(PURPLE_DEBUG_ERROR, "perl",
"Perl function %s exited abnormally: %s\n",
gps->load_sub, SvPV(ERRSV, len));
}
PUTBACK;
FREETMPS;
LEAVE;
}
return TRUE;
}
int gfire_read_attrib(GList **values, guint8 *buffer, int packet_len, const char *name,
gboolean dynamic, gboolean binary, int bytes_to_first, int bytes_between, int vallen)
{
int index = 0; int i=0; int ali = 0; int alen = 0;
gchar tmp[100];
guint16 numitems = 0; guint16 attr_len = 0;
guint8 *str;
memset(tmp, 0x00, 100);
alen = strlen(name);
memcpy(tmp, buffer + index, alen);
index += strlen(name);
if ( 0 == g_ascii_strcasecmp(name, tmp)) {
index += 2;
memcpy(&numitems, buffer + index, 2);
numitems = GUINT16_FROM_LE(numitems);
index += 2;
purple_debug(PURPLE_DEBUG_MISC, "gfire", "Looking for %d %s's in packet.\n", numitems, NN(name));
} else {
purple_debug(PURPLE_DEBUG_MISC, "gfire", "ERROR: %s signature isn't in the correct position.\n", NN(name));
return -1;
}
/* if we are copying a string make sure we have a space for the trailing \0 */
if (binary) ali = 0;
else ali = 1;
for (i = 0; i < numitems; i++) {
if (dynamic) {
memcpy(&attr_len, buffer + index, 2);
attr_len = GUINT16_FROM_LE(attr_len); index+=2;
} else attr_len = vallen;
if (dynamic && (attr_len == 0)) str = NULL;
else {
str = g_malloc0(sizeof(char) * (attr_len+ali));
memcpy(str, buffer + index, attr_len);
if (!binary) str[attr_len] = 0x00;
}
index += attr_len;
*values = g_list_append(*values,(gpointer *)str);
if ( index > packet_len ) {
purple_debug(PURPLE_DEBUG_MISC, "gfire", "ERROR: pkt 131: more friends then packet length.\n");
return -1;
}
}
return index;
}
static void
text_sent_cb(GtkEntry *entry)
{
const char *txt;
PurpleConnection *gc;
const char *protocol_id;
if (account == NULL)
return;
gc = purple_account_get_connection(account);
txt = gtk_entry_get_text(entry);
protocol_id = purple_account_get_protocol_id(account);
purple_debug_misc("raw", "protocol_id = %s\n", protocol_id);
if (strcmp(protocol_id, "prpl-toc") == 0) {
int *a = (int *)purple_connection_get_protocol_data(gc);
unsigned short seqno = htons(a[1]++ & 0xffff);
unsigned short len = htons(strlen(txt) + 1);
write(*a, "*\002", 2);
write(*a, &seqno, 2);
write(*a, &len, 2);
write(*a, txt, ntohs(len));
purple_debug(PURPLE_DEBUG_MISC, "raw", "TOC C: %s\n", txt);
} else if (strcmp(protocol_id, "prpl-msn") == 0) {
MsnSession *session = purple_connection_get_protocol_data(gc);
char buf[strlen(txt) + 3];
g_snprintf(buf, sizeof(buf), "%s\r\n", txt);
msn_servconn_write(session->notification->servconn, buf, strlen(buf));
} else if (strcmp(protocol_id, "prpl-irc") == 0) {
write(*(int *)purple_connection_get_protocol_data(gc), txt, strlen(txt));
write(*(int *)purple_connection_get_protocol_data(gc), "\r\n", 2);
purple_debug(PURPLE_DEBUG_MISC, "raw", "IRC C: %s\n", txt);
} else if (strcmp(protocol_id, "prpl-jabber") == 0) {
jabber_send_raw((JabberStream *)purple_connection_get_protocol_data(gc), txt, -1);
} else {
purple_debug_error("raw", "Unknown protocol ID %s\n", protocol_id);
}
gtk_entry_set_text(entry, "");
}
static void ggp_libgaduw_debug_handler(int level, const char * format,
va_list args)
{
PurpleDebugLevel purple_level;
char *msg;
if ((level & GG_DEBUG_NET) || (level & GG_DEBUG_FUNCTION) ||
(level & GG_DEBUG_VERBOSE))
{
if (!purple_debug_is_verbose())
return;
}
if ((level & GG_DEBUG_DUMP) || /* GG session protocol packets */
(level & GG_DEBUG_TRAFFIC)) /* HTTP traffic */
{
if (!purple_debug_is_verbose() || !purple_debug_is_unsafe())
return;
}
msg = g_strdup_vprintf(format, args);
if (level & GG_DEBUG_ERROR)
purple_level = PURPLE_DEBUG_ERROR;
else if (level & GG_DEBUG_WARNING)
purple_level = PURPLE_DEBUG_WARNING;
else
purple_level = PURPLE_DEBUG_MISC;
purple_debug(purple_level, "gg", "%s", msg);
g_free(msg);
}
void
fb_util_vdebug(PurpleDebugLevel level, const gchar *format, va_list ap)
{
gboolean unsafe;
gboolean verbose;
gchar *str;
g_return_if_fail(format != NULL);
unsafe = (level & FB_UTIL_DEBUG_FLAG_UNSAFE) != 0;
verbose = (level & FB_UTIL_DEBUG_FLAG_VERBOSE) != 0;
if ((unsafe && !purple_debug_is_unsafe()) ||
(verbose && !purple_debug_is_verbose()))
{
return;
}
/* Ensure all local flags are removed */
level &= ~FB_UTIL_DEBUG_FLAG_ALL;
str = g_strdup_vprintf(format, ap);
purple_debug(level, "facebook", "%s\n", str);
g_free(str);
}
static gssize jabber_oob_xfer_read(guchar **buffer, PurpleXfer *xfer) {
JabberOOBXfer *jox = xfer->data;
char test[2048];
char *tmp, *lenstr;
int len;
if((len = read(xfer->fd, test, sizeof(test))) > 0) {
jox->headers = g_string_append_len(jox->headers, test, len);
if((tmp = strstr(jox->headers->str, "\r\n\r\n"))) {
*tmp = '\0';
lenstr = strstr(jox->headers->str, "Content-Length: ");
if(lenstr) {
int size;
sscanf(lenstr, "Content-Length: %d", &size);
purple_xfer_set_size(xfer, size);
}
purple_xfer_set_read_fnc(xfer, NULL);
tmp += 4;
*buffer = (unsigned char*) g_strdup(tmp);
return strlen(tmp);
}
return 0;
} else if (errno != EAGAIN) {
purple_debug(PURPLE_DEBUG_ERROR, "jabber", "Read error on oob xfer!\n");
purple_xfer_cancel_local(xfer);
}
return 0;
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
purple_debug(PURPLE_DEBUG_INFO, "simple", "simple plugin loaded.\n");
return TRUE;
}
/** This function needs to be better written **/
static char * snd(char * sndType) {
char *daemon = "";
if (strcmp (sndType, "arts") == 0 ||
strcmp (sndType, "esd") == 0 ||
strcmp (sndType, "alsa") == 0 ||
strcmp (sndType, "automatic") == 0) {
FILE *which_pf;
char sndserver[1024];
if (strcmp (sndType, "arts") == 0)
which_pf= popen("which artsdsp 2>/dev/null","r");
else if (strcmp (sndType, "esd") == 0)
which_pf= popen("which esddsp 2>/dev/null","r");
else if (strcmp (sndType, "alsa") == 0)
which_pf= popen("which aoss 2>/dev/null","r");
else if (strcmp (sndType, "automatic") == 0)
which_pf= popen("which artsdsp 2>/dev/null","r");
fscanf(which_pf,"%1023s",sndserver);
pclose(which_pf);
daemon=sndserver;
}
else{
purple_debug(PURPLE_DEBUG_INFO, "pidgin festival sound method ", sndType);
}
return daemon;
}
static gboolean
plugin_load(PurplePlugin *plugin) {
FILE *which_pf;
char line[1024];
which_pf= popen("which festival 2>/dev/null","r");
fscanf(which_pf,"%1023s",line);
pclose(which_pf);
if( *line != '/')
return FALSE;
char proc[1024];
sprintf(proc, "%s %s", snd((char *)purple_prefs_get_string("/pidgin/sound/method")), line);
purple_debug(PURPLE_DEBUG_INFO, "pidgin festival", proc);
int errno=0;
festival_pf= popen(proc,"w");
if(errno) {
pclose(festival_pf);
return FALSE;
}
load_conf();
void *conv_handle = purple_conversations_get_handle();
void *blist_handle = purple_blist_get_handle();
void *accounts_handle = purple_accounts_get_handle();
purple_signal_connect(conv_handle, "received-im-msg",
plugin, PURPLE_CALLBACK(im_recv_im), NULL);
purple_signal_connect(conv_handle, "received-chat-msg",
plugin, PURPLE_CALLBACK(im_recv_im), NULL);
purple_signal_connect(conv_handle, "conversation-created",
plugin, PURPLE_CALLBACK(chat_created), NULL);
purple_signal_connect(blist_handle, "buddy-signed-on",
plugin, PURPLE_CALLBACK(buddy_signed_on_cb), NULL);
purple_signal_connect(blist_handle, "buddy-signed-off",
plugin, PURPLE_CALLBACK(buddy_signed_off_cb), NULL);
purple_signal_connect(conv_handle, "chat-buddy-joined",
plugin, PURPLE_CALLBACK(chat_buddy_joined_cb), NULL);
purple_signal_connect(conv_handle, "chat-buddy-left",
plugin, PURPLE_CALLBACK(chat_buddy_left_cb), NULL);
/* Buddy List subsystem signals */
purple_signal_connect(blist_handle, "buddy-away",
plugin, PURPLE_CALLBACK(buddy_away_cb), NULL);
purple_signal_connect(blist_handle, "buddy-back",
plugin, PURPLE_CALLBACK(buddy_back_cb), NULL);
purple_signal_connect(blist_handle, "buddy-idle",
plugin, PURPLE_CALLBACK(buddy_idle_cb), NULL);
purple_signal_connect(blist_handle, "buddy-unidle",
plugin, PURPLE_CALLBACK(buddy_unidle_cb), NULL);
purple_signal_connect(accounts_handle, "account-connecting",
plugin, PURPLE_CALLBACK(account_connecting_cb), NULL);
return TRUE;
}
static void yahoo_receivefile_connected(gpointer data, gint source, const gchar *error_message)
{
PurpleXfer *xfer;
struct yahoo_xfer_data *xd;
purple_debug(PURPLE_DEBUG_INFO, "yahoo",
"AAA - in yahoo_receivefile_connected\n");
if (!(xfer = data))
return;
if (!(xd = xfer->data))
return;
if ((source < 0) || (xd->path == NULL) || (xd->host == NULL)) {
purple_xfer_error(PURPLE_XFER_RECEIVE, purple_xfer_get_account(xfer),
xfer->who, _("Unable to connect."));
purple_xfer_cancel_remote(xfer);
return;
}
xfer->fd = source;
/* The first time we get here, assemble the tx buffer */
if (xd->txbuflen == 0) {
xd->txbuf = g_strdup_printf("GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n",
xd->path, xd->host);
xd->txbuflen = strlen(xd->txbuf);
xd->txbuf_written = 0;
}
if (!xd->tx_handler)
{
xd->tx_handler = purple_input_add(source, PURPLE_INPUT_WRITE,
yahoo_receivefile_send_cb, xfer);
yahoo_receivefile_send_cb(xfer, source, PURPLE_INPUT_WRITE);
}
}
void irc_msg_kick(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, args[0], irc->account);
char *nick = irc_mask_nick(from), *buf;
if (!gc) {
g_free(nick);
return;
}
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "Recieved a KICK for unknown channel %s\n", args[0]);
g_free(nick);
return;
}
if (!purple_utf8_strcasecmp(purple_connection_get_display_name(gc), args[1])) {
buf = g_strdup_printf(_("You have been kicked by %s: (%s)"), nick, args[2]);
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), args[0], buf, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(buf);
serv_got_chat_left(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)));
} else {
buf = g_strdup_printf(_("Kicked by %s (%s)"), nick, args[2]);
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(convo), args[1], buf);
g_free(buf);
}
g_free(nick);
return;
}
static int irc_chat_send(PurpleConnection *gc, int id, const char *what, PurpleMessageFlags flags)
{
struct irc_conn *irc = gc->proto_data;
PurpleConversation *convo = purple_find_chat(gc, id);
const char *args[2];
char *tmp;
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "chat send on nonexistent chat\n");
return -EINVAL;
}
#if 0
if (*what == '/') {
return irc_parse_cmd(irc, convo->name, what + 1);
}
#endif
purple_markup_html_to_xhtml(what, NULL, &tmp);
args[0] = convo->name;
args[1] = tmp;
irc_cmd_privmsg(irc, "msg", NULL, args);
serv_got_chat_in(gc, id, purple_connection_get_display_name(gc), 0, what, time(NULL));
g_free(tmp);
return 0;
}
static gboolean purple_gnt_io_invoke(GIOChannel *source,
GIOCondition condition, gpointer data) {
PurpleGntIOClosure *closure = data;
PurpleInputCondition purple_cond = 0;
if (condition & FINCH_READ_COND)
purple_cond |= PURPLE_INPUT_READ;
if (condition & FINCH_WRITE_COND)
purple_cond |= PURPLE_INPUT_WRITE;
#ifdef _WIN32
if(! purple_cond) {
#ifdef DEBUG
purple_debug(PURPLE_DEBUG_MISC, "purplexmpp",
"CLOSURE received GIOCondition of 0x%x, which does not"
" match 0x%x (READ) or 0x%x (WRITE)\n",
condition, PIDGIN_READ_COND, PIDGIN_WRITE_COND);
#endif /* DEBUG */
return TRUE;
}
#endif /* _WIN32 */
closure->function(closure->data, g_io_channel_unix_get_fd(source),
purple_cond);
return TRUE;
}
static gboolean
plugin_unload(PurplePlugin *plugin)
{
purple_debug(PURPLE_DEBUG_INFO, "plugins", "block <user> has left the conversation plugin unloaded.\n");
return TRUE;
}
static char *gaym_recv_convert(struct gaym_conn *gaym, const char *string)
{
char *utf8 = NULL;
GError *err = NULL;
const gchar *charset;
charset =
purple_account_get_string(gaym->account, "encoding",
IRC_DEFAULT_CHARSET);
if (!strcasecmp("UTF-8", charset)) {
if (g_utf8_validate(string, strlen(string), NULL))
utf8 = g_strdup(string);
} else {
utf8 =
g_convert(string, strlen(string), "UTF-8", charset, NULL, NULL,
&err);
}
if (err) {
purple_debug(PURPLE_DEBUG_ERROR, "gaym", "recv conversion error: %s\n",
err->message);
g_error_free(err);
}
if (utf8 == NULL)
utf8 =
g_strdup(_
("(There was an error converting this message. Check the 'Encoding' option in the Account Editor)"));
return utf8;
}
static gboolean
plugin_unload(PurplePlugin *plugin, GError **error)
{
purple_debug(PURPLE_DEBUG_INFO, "simple", "simple plugin unloaded.\n");
return TRUE;
}
void CreateTempGroup(PurpleConnection * gc, PurpleBuddy * buddy)
{
gchar *body, *hdr;
gint xml_len;
xmlnode *root, *son, *item;
struct fetion_account_data *sip = gc->proto_data;
root = xmlnode_new("args");
g_return_if_fail(root != NULL);
son = xmlnode_new_child(root, "participants");
g_return_if_fail(son != NULL);
son = xmlnode_new_child(son, "participant");
g_return_if_fail(son != NULL);
xmlnode_set_attrib(son, "uri", buddy->name);
hdr = g_strdup("N: CreateTemporaryGroup\r\nK: text/html-fragment\r\n");
body = g_strdup_printf(xmlnode_to_str(root, &xml_len));
purple_debug(PURPLE_DEBUG_MISC, "fetion", "in CreateTempGroup[%s]\n",
body);
send_sip_request(sip->gc, "S", "", "", hdr, body, NULL,
CreateTempGroup_cb);
g_free(body);
g_free(hdr);
xmlnode_free(root);
}
int purple_signal_connect_glue(MonoObject* h, MonoObject *plugin, MonoString *signal, MonoObject *func)
{
char *sig;
void **instance = NULL;
SignalData *sig_data;
PurpleMonoPlugin *mplug;
MonoClass *klass;
sig = mono_string_to_utf8(signal);
purple_debug(PURPLE_DEBUG_INFO, "mono", "connecting signal: %s\n", sig);
instance = (void*)mono_object_unbox(h);
sig_data = g_new0(SignalData, 1);
sig_data->func = func;
sig_data->signal = sig;
purple_signal_get_values(*instance, sig, &sig_data->ret_value, &sig_data->num_vals, &sig_data->values);
klass = mono_object_get_class(plugin);
mplug = ml_find_plugin_by_class(klass);
mplug->signal_data = g_list_append(mplug->signal_data, (gpointer)sig_data);
return purple_signal_connect(*instance, sig, (gpointer)klass, get_callback(sig_data), (gpointer)sig_data);
}
static gboolean purple_gnt_io_invoke(GIOChannel *source, GIOCondition condition, gpointer data)
{
PurpleGntIOClosure *closure = data;
PurpleInputCondition purple_cond = 0;
if (condition & FINCH_READ_COND)
purple_cond |= PURPLE_INPUT_READ;
if (condition & FINCH_WRITE_COND)
purple_cond |= PURPLE_INPUT_WRITE;
#if 0
purple_debug(PURPLE_DEBUG_MISC, "gtk_eventloop",
"CLOSURE: callback for %d, fd is %d\n",
closure->result, g_io_channel_unix_get_fd(source));
#endif
#ifdef _WIN32
if(! purple_cond) {
#if 0
purple_debug_misc("gnt_eventloop",
"CLOSURE received GIOCondition of 0x%x, which does not"
" match 0x%x (READ) or 0x%x (WRITE)\n",
condition, FINCH_READ_COND, FINCH_WRITE_COND);
#endif /* DEBUG */
return TRUE;
}
#endif /* _WIN32 */
closure->function(closure->data, g_io_channel_unix_get_fd(source),
purple_cond);
return TRUE;
}
void gfire_chat_proto_user_join(gfire_data *p_gfire, guint16 p_packet_len)
{
if(!p_gfire)
return;
guint32 offset = XFIRE_HEADER_LEN;
guint8 *chat_id = NULL;
gfire_chat *chat = NULL;
guint32 userid = 0;
gchar *name = NULL;
gchar *nick = NULL;
guint32 perm = 0;
gfire_buddy *gf_buddy = NULL;
offset = gfire_proto_read_attr_chatid_bs(p_gfire->buff_in, &chat_id, 0x04, offset);
if(offset == -1 || !chat_id)
return;
chat = gfire_find_chat(p_gfire, chat_id, GFFC_CID);
if(!chat)
{
g_free(chat_id);
purple_debug_error("gfire", "gfire_chat_proto_user_leave: Unknown chat id!\n");
return;
}
g_free(chat_id);
offset = gfire_proto_read_attr_int32_bs(p_gfire->buff_in, &userid, 0x01, offset);
if(offset == -1)
return;
offset = gfire_proto_read_attr_string_bs(p_gfire->buff_in, &name, 0x02, offset);
if(offset == -1 || !name)
{
return;
}
offset = gfire_proto_read_attr_string_bs(p_gfire->buff_in, &nick, 0x0D, offset);
if(offset == -1 || !nick)
{
g_free(name);
return;
}
offset = gfire_proto_read_attr_int32_bs(p_gfire->buff_in, &perm, 0x12, offset);
if(offset == -1)
return;
gf_buddy = gfire_buddy_create(userid, name, nick, GFBT_GROUPCHAT);
gfire_chat_add_user(chat, gf_buddy, perm, TRUE);
purple_debug(PURPLE_DEBUG_MISC, "gfire", "groupchat join, userid: %u, username: %s, alias: %s\n",
userid, NN(name), NN(nick));
g_free(name);
g_free(nick);
}
void irc_msg_default(struct irc_conn *irc, const char *name, const char *from, char **args)
{
char *clean;
/* This, too, should be escaped somehow (smarter) */
clean = purple_utf8_salvage(args[0]);
purple_debug(PURPLE_DEBUG_INFO, "irc", "Unrecognized message: %s\n", clean);
g_free(clean);
}
static gboolean
unload_perl_plugin(PurplePlugin *plugin)
{
PurplePerlScript *gps = (PurplePerlScript *)plugin->info->extra_info;
if (gps == NULL)
return FALSE;
purple_debug(PURPLE_DEBUG_INFO, "perl", "Unloading perl script\n");
if (gps->unload_sub != NULL) {
dSP;
PERL_SET_CONTEXT(my_perl);
SPAGAIN;
ENTER;
SAVETMPS;
PUSHMARK(sp);
XPUSHs(sv_2mortal(purple_perl_bless_object(plugin,
"Purple::Plugin")));
PUTBACK;
perl_call_pv(gps->unload_sub, G_EVAL | G_SCALAR);
SPAGAIN;
if (SvTRUE(ERRSV)) {
STRLEN len;
purple_debug(PURPLE_DEBUG_ERROR, "perl",
"Perl function %s exited abnormally: %s\n",
gps->load_sub, SvPV(ERRSV, len));
}
PUTBACK;
FREETMPS;
LEAVE;
}
purple_perl_cmd_clear_for_plugin(plugin);
purple_perl_signal_clear_for_plugin(plugin);
purple_perl_timeout_clear_for_plugin(plugin);
destroy_package(gps->package);
return TRUE;
}
static void
pidgin_sound_play_file_win32(const char *filename)
{
wchar_t *wc_filename = g_utf8_to_utf16(filename,
-1, NULL, NULL, NULL);
if (!PlaySoundW(wc_filename, NULL, SND_ASYNC | SND_FILENAME))
purple_debug(PURPLE_DEBUG_ERROR, "sound", "Error playing sound.\n");
g_free(wc_filename);
}
static void irc_parse_error_cb(struct irc_conn *irc, char *input)
{
char *clean;
/* This really should be escaped somehow that you can tell what
* the junk was -- but as it is, it can crash glib. */
clean = purple_utf8_salvage(input);
purple_debug(PURPLE_DEBUG_WARNING, "irc", "Unrecognized string: %s\n", clean);
g_free(clean);
}
