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); }