static void silcpurple_add_buddy_ask_import(void *user_data, const char *name) { SilcPurpleBuddyRes r = (SilcPurpleBuddyRes)user_data; SilcPublicKey public_key; /* Load the public key */ if (!silc_pkcs_load_public_key(name, &public_key, SILC_PKCS_FILE_PEM) && !silc_pkcs_load_public_key(name, &public_key, SILC_PKCS_FILE_BIN)) { silcpurple_add_buddy_ask_pk_cb(r, 0); purple_notify_error(r->client->application, _("Add Buddy"), _("Could not load public key"), NULL); return; } /* Now verify the public key */ r->offline_pk = silc_pkcs_public_key_encode(public_key, &r->offline_pk_len); silcpurple_verify_public_key(r->client, r->conn, r->b->name, SILC_SOCKET_TYPE_CLIENT, r->offline_pk, r->offline_pk_len, SILC_SKE_PK_TYPE_SILC, silcpurple_add_buddy_save, r); }
static void yahoo_process_filetrans_info_15_got(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer _xfer) { PurpleXfer *xfer = _xfer; struct yahoo_xfer_data *xd; YahooData *yd; xd = purple_xfer_get_protocol_data(xfer); yd = purple_connection_get_protocol_data(xd->gc); xd->hc = NULL; if (!purple_http_response_is_successful(response)) { purple_notify_error(yd->gc, NULL, _("File Transfer Failed"), _("Unable to get file header."), purple_request_cpar_from_connection(yd->gc)); purple_xfer_cancel_remote(xfer); return; } purple_xfer_start(xfer, -1, NULL, 0); }
void msn_session_warning (MsnSession *session, const gchar *fmt, ...) { PurpleAccount *account; PurpleConnection *connection; gchar *tmp; va_list args; account = msn_session_get_user_data (session); connection = purple_account_get_connection (account); va_start (args, fmt); tmp = g_strdup_vprintf (fmt, args); purple_notify_error (connection, NULL, tmp, NULL); g_free (tmp); va_end (args); }
static void roomlist_ok_cb(JabberStream *js, const char *server) { JabberIq *iq; if(!js->roomlist) return; if(!server || !*server) { purple_notify_error(js->gc, _("Invalid Server"), _("Invalid Server"), NULL); purple_roomlist_set_in_progress(js->roomlist, FALSE); return; } purple_roomlist_set_in_progress(js->roomlist, TRUE); iq = jabber_iq_new_query(js, JABBER_IQ_GET, NS_DISCO_ITEMS); xmlnode_set_attrib(iq->node, "to", server); jabber_iq_set_callback(iq, roomlist_disco_result_cb, NULL); jabber_iq_send(iq); }
static void silcpurple_ftp_send_file_resolved(SilcClient client, SilcClientConnection conn, SilcClientEntry *clients, SilcUInt32 clients_count, void *context) { PurpleConnection *gc = client->application; char tmp[256]; if (!clients) { g_snprintf(tmp, sizeof(tmp), _("User %s is not present in the network"), (const char *)context); purple_notify_error(gc, _("Secure File Transfer"), _("Cannot send file"), tmp); silc_free(context); return; } silcpurple_ftp_send_file(client->application, (const char *)context, NULL); silc_free(context); }
static void plainprpl_add_buddy_ok(void *ptr, PurpleRequestFields *fields) { PurpleBuddy *buddy; PurpleConnection *gc; plain_plugin_state *pstate; plain_buddy_state *bstate; const char *addr_str; //const char* invite_msg; purple_debug_info("plainprpl", "plainprpl_add_buddy_ok\n"); buddy = (PurpleBuddy *) ptr; gc = purple_account_get_connection(buddy->account); addr_str = purple_request_fields_get_string(fields, "addr_str"); //invite_msg = purple_request_fields_get_string(fields, "invite_msg"); if (addr_str == NULL || strlen(addr_str) == 0) { purple_notify_error(ptr, "Invalid Address", _("The address was empty."), _("You need to enter a host name or an IP address.")); purple_blist_remove_buddy(buddy); } else { /* Finalize buddy creation */ purple_debug_info("plainprpl", "Add buddy %s\n", buddy->name); purple_blist_node_set_string(PURPLE_BLIST_NODE(buddy), "addr_str", addr_str); assert(purple_blist_node_get_string(PURPLE_BLIST_NODE(buddy), "addr_str") != NULL); pstate = purple_connection_get_protocol_data(gc); bstate = add_buddy_sdata(buddy, pstate); pstate->time_next = 0; //handle now purple_prpl_got_user_status(buddy->account, buddy->name, PLAIN_STATUS_OFFLINE, NULL); /* if (invite_msg) { plainprpl_send_im(gc, buddy->name, invite_msg, 0); }*/ } }
void irc_msg_nonick(struct irc_conn *irc, const char *name, const char *from, char **args) { PurpleConnection *gc; PurpleConversation *convo; convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY, args[1], irc->account); if (convo) { if (purple_conversation_get_type(convo) == PURPLE_CONV_TYPE_CHAT) /* does this happen? */ purple_conv_chat_write(PURPLE_CONV_CHAT(convo), args[1], _("no such channel"), PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL)); else purple_conv_im_write(PURPLE_CONV_IM(convo), args[1], _("User is not logged in"), PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL)); } else { if ((gc = purple_account_get_connection(irc->account)) == NULL) return; purple_notify_error(gc, NULL, _("No such nick or channel"), args[1]); } if (irc->whois.nick && !purple_utf8_strcasecmp(irc->whois.nick, args[1])) { g_free(irc->whois.nick); irc->whois.nick = NULL; } }
void purple_xfer_error(PurpleXferType type, PurpleAccount *account, const char *who, const char *msg) { char *title; g_return_if_fail(msg != NULL); g_return_if_fail(type != PURPLE_XFER_UNKNOWN); if (account) { PurpleBuddy *buddy; buddy = purple_find_buddy(account, who); if (buddy) who = purple_buddy_get_alias(buddy); } if (type == PURPLE_XFER_SEND) title = g_strdup_printf(_("File transfer to %s failed."), who); else title = g_strdup_printf(_("File transfer from %s failed."), who); purple_notify_error(NULL, NULL, title, msg); g_free(title); }
void hon_parse_whisper_failed(PurpleConnection *gc,gchar* buffer){ purple_notify_error(NULL,_("Whisper failed"),_("The user you tried to whisper is not online"), NULL); }
void hon_parse_pm_failed(PurpleConnection *gc,gchar* buffer){ purple_notify_error(NULL,_("Message failed"),_("The user you tried to chat with is not online"), NULL); }
void hon_parse_channel_banned(PurpleConnection *gc,gchar* buffer){ gchar* msg = g_strdup_printf(_("You are banned from the channel '%s'"),buffer); purple_notify_error(NULL,_("Banned"),msg,NULL); }
void hon_parse_join_channel_password(PurpleConnection *gc,gchar* buffer){ gchar* msg = g_strdup_printf(_("The channel '%s' requires a password."),buffer); purple_notify_error(NULL,_("Banned"),msg,NULL); g_free(msg); }
void yahoo_process_filetrans_info_15(PurpleConnection *gc, struct yahoo_packet *pkt) { char *url = NULL; long val_249 = 0; long val_66 = 0; PurpleXfer *xfer; YahooData *yd; struct yahoo_xfer_data *xfer_data; char *xfer_peer_idstring = NULL; char *xfer_idstring_for_relay = NULL; GSList *l; struct yahoo_packet *pkt_to_send; yd = purple_connection_get_protocol_data(gc); for (l = pkt->hash; l; l = l->next) { struct yahoo_pair *pair = l->data; switch (pair->key) { case 4: /* from */ break; case 5: /* to */ break; case 265: if (g_utf8_validate(pair->value, -1, NULL)) { xfer_peer_idstring = pair->value; } else { purple_debug_warning("yahoo", "yahoo_process_filetrans_info_15 " "got non-UTF-8 string for key %d\n", pair->key); } break; case 27: /* filename */ break; case 66: val_66 = strtol(pair->value, NULL, 10); break; case 249: val_249 = strtol(pair->value, NULL, 10); /* 249 has value 1 or 2 when doing p2p transfer and value 3 when relaying through yahoo server */ break; case 250: if (g_utf8_validate(pair->value, -1, NULL)) { url = pair->value; /* TODO: rename to host? what about non-relay? */ } else { purple_debug_warning("yahoo", "yahoo_process_filetrans_info_15 " "got non-UTF-8 string for key %d\n", pair->key); } break; case 251: if (g_utf8_validate(pair->value, -1, NULL)) { xfer_idstring_for_relay = pair->value; } else { purple_debug_warning("yahoo", "yahoo_process_filetrans_info_15 " "got non-UTF-8 string for key %d\n", pair->key); } break; } } if(!xfer_peer_idstring) return; xfer = g_hash_table_lookup(yd->xfer_peer_idstring_map, xfer_peer_idstring); if(!xfer) return; if(val_66==-1) { purple_xfer_cancel_remote(xfer); return; } xfer_data = purple_xfer_get_protocol_data(xfer); xfer_data->info_val_249 = val_249; xfer_data->xfer_idstring_for_relay = g_strdup(xfer_idstring_for_relay); if(val_249 == 1 || val_249 == 3) { PurpleHttpRequest *req; PurpleAccount *account; xfer_data->is_relay = (val_249 == 3); if (!xfer_data->is_relay) { purple_debug_error("yahoo", "Non-relay FT aren't tested yet.\n"); purple_notify_error(gc, NULL, _("File Transfer Failed"), _("Unsupported method"), purple_request_cpar_from_connection(gc)); purple_xfer_cancel_remote(xfer); } account = purple_connection_get_account(xfer_data->gc); xfer_data->url = yahoo_ft_url_gen(xfer, url); pkt_to_send = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_ACC_15, YAHOO_STATUS_AVAILABLE, yd->session_id); yahoo_packet_hash(pkt_to_send, "ssssis", 1, purple_normalize(account, purple_account_get_username(account)), 5, purple_xfer_get_remote_user(xfer), 265, xfer_data->xfer_peer_idstring, 27, purple_xfer_get_filename(xfer), 249, xfer_data->info_val_249, 251, xfer_data->xfer_idstring_for_relay); yahoo_packet_send_and_free(pkt_to_send, yd); req = yahoo_ft_new_req(xfer_data); purple_http_request_set_method(req, "HEAD"); xfer_data->hc = purple_http_request(gc, req, yahoo_process_filetrans_info_15_got, xfer); purple_http_request_unref(req); } else if (val_249 == 2) purple_debug_error("yahoo", "p2p file transfers are not supported yet\n"); }
static void save_pounce_cb(GntWidget *w, PurpleGntPounceDialog *dialog) { const char *name; const char *message, *command, *reason; PurplePounceEvent events = PURPLE_POUNCE_NONE; PurplePounceOption options = PURPLE_POUNCE_OPTION_NONE; name = gnt_entry_get_text(GNT_ENTRY(dialog->buddy_entry)); if (*name == '\0') { purple_notify_error(NULL, NULL, _("Please enter a buddy to pounce."), NULL); return; } /* Options */ if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->on_away))) options |= PURPLE_POUNCE_OPTION_AWAY; /* Events */ if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->signon))) events |= PURPLE_POUNCE_SIGNON; if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->signoff))) events |= PURPLE_POUNCE_SIGNOFF; if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->away))) events |= PURPLE_POUNCE_AWAY; if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->away_return))) events |= PURPLE_POUNCE_AWAY_RETURN; if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->idle))) events |= PURPLE_POUNCE_IDLE; if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->idle_return))) events |= PURPLE_POUNCE_IDLE_RETURN; if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->typing))) events |= PURPLE_POUNCE_TYPING; if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->typed))) events |= PURPLE_POUNCE_TYPED; if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->stop_typing))) events |= PURPLE_POUNCE_TYPING_STOPPED; if (gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->message_recv))) events |= PURPLE_POUNCE_MESSAGE_RECEIVED; /* Data fields */ message = gnt_entry_get_text(GNT_ENTRY(dialog->send_msg_entry)); command = gnt_entry_get_text(GNT_ENTRY(dialog->exec_cmd_entry)); reason = gnt_entry_get_text(GNT_ENTRY(dialog->popup_entry)); if (*reason == '\0') reason = NULL; if (*message == '\0') message = NULL; if (*command == '\0') command = NULL; if (dialog->pounce == NULL) { dialog->pounce = purple_pounce_new(FINCH_UI, dialog->account, name, events, options); } else { purple_pounce_set_events(dialog->pounce, events); purple_pounce_set_options(dialog->pounce, options); purple_pounce_set_pouncer(dialog->pounce, dialog->account); purple_pounce_set_pouncee(dialog->pounce, name); } /* Actions */ purple_pounce_action_set_enabled(dialog->pounce, "open-window", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->open_win))); purple_pounce_action_set_enabled(dialog->pounce, "popup-notify", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->popup))); purple_pounce_action_set_enabled(dialog->pounce, "send-message", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->send_msg))); purple_pounce_action_set_enabled(dialog->pounce, "execute-command", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->exec_cmd))); purple_pounce_action_set_enabled(dialog->pounce, "play-beep", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->play_sound))); purple_pounce_action_set_attribute(dialog->pounce, "send-message", "message", message); purple_pounce_action_set_attribute(dialog->pounce, "execute-command", "command", command); purple_pounce_action_set_attribute(dialog->pounce, "popup-notify", "reason", reason); /* Set the defaults for next time. */ purple_prefs_set_bool("/finch/pounces/default_actions/open-window", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->open_win))); purple_prefs_set_bool("/finch/pounces/default_actions/popup-notify", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->popup))); purple_prefs_set_bool("/finch/pounces/default_actions/send-message", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->send_msg))); purple_prefs_set_bool("/finch/pounces/default_actions/execute-command", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->exec_cmd))); purple_prefs_set_bool("/finch/pounces/default_actions/play-beep", gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->play_sound))); purple_pounce_set_save(dialog->pounce, gnt_check_box_get_checked(GNT_CHECK_BOX(dialog->save_pounce))); purple_pounce_set_pouncer(dialog->pounce, (PurpleAccount *)gnt_combo_box_get_selected_data(GNT_COMBO_BOX(dialog->account_menu))); update_pounces(); gnt_widget_destroy(dialog->window); }
static void nap_callback(gpointer data, gint source, PurpleInputCondition condition) { PurpleConnection *gc = data; struct nap_data *ndata = gc->proto_data; PurpleAccount *account = NULL; PurpleConversation *c = NULL; PurpleNotifyUserInfo *pnui = NULL; gchar *buf = NULL, *buf2 = NULL, *buf3 = NULL, **res = NULL; unsigned short header[2] = { 0 , 0 }; int len = 0; int command = 0; int i; account = purple_connection_get_account(gc); if (read(source, (void*)header, 4) != 4) { purple_connection_error(gc, _("Unable to read header from server")); return; } len = header[0]; command = header[1]; buf = (gchar *)g_malloc((len + 1) * sizeof(gchar)); buf[len] = '\0'; i = 0; do { int tmp = read(source, buf + i, len - i); if (tmp <= 0) { g_free(buf); buf = g_strdup_printf(_("Unable to read message from server: %s. Command is %hd, length is %hd."), strerror(errno), len, command); purple_connection_error(gc, buf); g_free(buf); return; } i += tmp; } while (i != len); purple_debug(PURPLE_DEBUG_MISC, "napster", "R %3hd: %s\n", command, buf); switch (command) { case 000: /* MSG_SERVER_ERROR */ purple_notify_error(gc, NULL, buf, NULL); purple_input_remove(gc->inpa); gc->inpa = 0; close(source); purple_connection_error(gc, _("Unknown server error.")); break; case 003: /* MSG_SERVER_EMAIL */ purple_debug(PURPLE_DEBUG_MISC, "napster", "Registered with e-mail address: %s\n", buf); ndata->email = g_strdup(buf); /* Our signon is complete */ purple_connection_set_state(gc, PURPLE_CONNECTED); /* Send the server our buddy list */ nap_send_buddylist(gc); break; case 201: /* MSG_SERVER_SEARCH_RESULT */ res = g_strsplit(buf, " ", 0); purple_prpl_got_user_status(account, res[0], "available", NULL); g_strfreev(res); break; case 202: /* MSG_SERVER_SEARCH_END */ purple_prpl_got_user_status(account, buf, "offline", NULL); break; case 205: /* MSG_CLIENT_PRIVMSG */ res = g_strsplit(buf, " ", 2); buf2 = g_markup_escape_text(res[1], -1); serv_got_im(gc, res[0], buf2, 0, time(NULL)); g_free(buf2); g_strfreev(res); break; case 209: /* MSG_SERVER_USER_SIGNON */ /* USERNAME SPEED */ res = g_strsplit(buf, " ", 2); purple_prpl_got_user_status(account, res[0], "available", NULL); g_strfreev(res); break; case 210: /* MSG_SERVER_USER_SIGNOFF */ /* USERNAME SPEED */ res = g_strsplit(buf, " ", 2); purple_prpl_got_user_status(account, res[0], "offline", NULL); g_strfreev(res); break; case 214: /* MSG_SERVER_STATS */ res = g_strsplit(buf, " ", 3); buf2 = g_strdup_printf(_("users: %s, files: %s, size: %sGB"), res[0], res[1], res[2]); serv_got_im(gc, "server", buf2, 0, time(NULL)); g_free(buf2); g_strfreev(res); break; case 301: /* MSG_SERVER_HOTLIST_ACK */ /* Our buddy was added successfully */ break; case 302: /* MSG_SERVER_HOTLIST_ERROR */ buf2 = g_strdup_printf(_("Unable to add \"%s\" to your Napster hotlist"), buf); purple_notify_error(gc, NULL, buf2, NULL); g_free(buf2); break; case 316: /* MSG_SERVER_DISCONNECTING */ /* we have been kicked off =^( */ purple_connection_error(gc, _("You were disconnected from the server.")); break; case 401: /* MSG_CLIENT_PART */ c = nap_find_chat(gc, buf); if (c) serv_got_chat_left(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c))); break; case 403: /* MSG_SERVER_PUBLIC */ res = g_strsplit(buf, " ", 3); c = nap_find_chat(gc, res[0]); if (c) serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c)), res[1], 0, res[2], time((time_t)NULL)); g_strfreev(res); break; case 404: /* MSG_SERVER_NOSUCH */ /* abused by opennap servers to broadcast stuff */ buf2 = g_markup_escape_text(buf, -1); serv_got_im(gc, "server", buf2, 0, time(NULL)); g_free(buf2); break; case 405: /* MSG_SERVER_JOIN_ACK */ c = nap_find_chat(gc, buf); if (!c) serv_got_joined_chat(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c)), buf); break; case 407: /* MSG_SERVER_PART */ res = g_strsplit(buf, " ", 0); c = nap_find_chat(gc, res[0]); purple_conv_chat_remove_user(PURPLE_CONV_CHAT(c), res[1], NULL); g_strfreev(res); break; case 406: /* MSG_SERVER_JOIN */ case 408: /* MSG_SERVER_CHANNEL_USER_LIST */ res = g_strsplit(buf, " ", 4); c = nap_find_chat(gc, res[0]); purple_conv_chat_add_user(PURPLE_CONV_CHAT(c), res[1], NULL, PURPLE_CBFLAGS_NONE, TRUE); g_strfreev(res); break; case 409: /* MSG_SERVER_CHANNEL_USER_LIST_END */ break; case 410: /* MSG_SERVER_TOPIC */ /* display the topic in the channel */ res = g_strsplit(buf, " ", 2); c = nap_find_chat(gc, res[0]); purple_conv_chat_set_topic(PURPLE_CONV_CHAT(c), res[0], res[1]); g_strfreev(res); break; case 603: /* MSG_CLIENT_WHOIS */ buf2 = g_strdup_printf(_("%s requested your information"), buf); serv_got_im(gc, "server", buf2, 0, time(NULL)); g_free(buf2); break; case 604: /* MSG_SERVER_WHOIS_RESPONSE */ /* XXX - Format is: "Elite" 37 " " "Active" 0 0 0 0 "purple 0.63cvs" 0 0 192.168.1.41 32798 0 unknown flounder */ res = g_strsplit(buf, " ", 2); /* res[0] == username */ pnui = purple_notify_user_info_new(); purple_notify_user_info_add_pair(pnui, _("Napster User Info:"), res[1]); purple_notify_userinfo(gc, res[0], pnui, NULL, NULL); g_strfreev(res); break; case 621: case 622: /* MSG_CLIENT_MOTD */ /* also replaces MSG_SERVER_MOTD, so we should display it */ buf2 = g_markup_escape_text(buf, -1); serv_got_im(gc, "motd", buf2, 0, time(NULL)); g_free(buf2); break; case 627: /* MSG_CLIENT_WALLOP */ /* abused by opennap server maintainers to broadcast stuff */ buf2 = g_markup_escape_text(buf, -1); serv_got_im(gc, "wallop", buf2, 0, time(NULL)); g_free(buf2); break; case 628: /* MSG_CLIENT_ANNOUNCE */ buf2 = g_markup_escape_text(buf, -1); serv_got_im(gc, "announce", buf2, 0, time(NULL)); g_free(buf); break; case 748: /* MSG_SERVER_GHOST */ /* Looks like someone logged in as us! =-O */ purple_connection_error(gc, _("You have signed on from another location.")); break; case 751: /* MSG_CLIENT_PING */ buf2 = g_strdup_printf(_("%s requested a PING"), buf); serv_got_im(gc, "server", buf2, 0, time(NULL)); g_free(buf2); /* send back a pong */ /* MSG_CLIENT_PONG */ nap_write_packet(gc, 752, "%s", buf); break; case 752: /* MSG_CLIENT_PONG */ buf2 = g_strdup_printf("Received pong from %s", buf); purple_notify_info(gc, NULL, buf2, NULL); g_free(buf2); break; case 824: /* MSG_CLIENT_EMOTE */ res = g_strsplit(buf, " ", 3); buf2 = g_strndup(res[2]+1, strlen(res[2]) - 2); /* chomp off the surround quotes */ buf3 = g_strdup_printf("/me %s", buf2); g_free(buf2); if ((c = nap_find_chat(gc, res[0]))) { purple_conv_chat_write(PURPLE_CONV_CHAT(c), res[1], buf3, PURPLE_MESSAGE_NICK, time(NULL)); } g_free(buf3); g_strfreev(res); break; default: purple_debug(PURPLE_DEBUG_MISC, "napster", "Unknown packet %hd: %s\n", command, buf); break; } g_free(buf); }
static void configure_plugin_cb(GntWidget *button, gpointer null) { PurplePlugin *plugin; PurplePluginInfo *info; FinchPluginInfoPrivate *priv = NULL; FinchPluginUiData *ui_data; g_return_if_fail(plugins.tree != NULL); plugin = gnt_tree_get_selection_data(GNT_TREE(plugins.tree)); if (!purple_plugin_is_loaded(plugin)) { purple_notify_error(plugin, _("Error"), _("Plugin need to be loaded before you can configure it."), NULL, NULL); return; } info = purple_plugin_get_info(plugin); if (purple_plugin_info_get_ui_data(info)) return; ui_data = g_new0(FinchPluginUiData, 1); purple_plugin_info_set_ui_data(info, ui_data); if (FINCH_IS_PLUGIN_INFO(info)) priv = FINCH_PLUGIN_INFO_GET_PRIVATE(info); if (priv && priv->pref_frame_cb != NULL) { GntWidget *window = gnt_vbox_new(FALSE); GntWidget *box, *button; gnt_box_set_toplevel(GNT_BOX(window), TRUE); gnt_box_set_title(GNT_BOX(window), purple_plugin_info_get_name(info)); gnt_box_set_alignment(GNT_BOX(window), GNT_ALIGN_MID); box = priv->pref_frame_cb(); gnt_box_add_widget(GNT_BOX(window), box); box = gnt_hbox_new(FALSE); gnt_box_add_widget(GNT_BOX(window), box); button = gnt_button_new(_("Close")); gnt_box_add_widget(GNT_BOX(box), button); g_signal_connect_swapped(G_OBJECT(button), "activate", G_CALLBACK(gnt_widget_destroy), window); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(remove_confwin), plugin); gnt_widget_show(window); ui_data->type = FINCH_PLUGIN_UI_DATA_TYPE_WINDOW; ui_data->u.window = window; } else if (purple_plugin_info_get_pref_request_cb(info)) { PurplePluginPrefRequestCb pref_request_cb = purple_plugin_info_get_pref_request_cb(info); gpointer handle; ui_data->type = FINCH_PLUGIN_UI_DATA_TYPE_REQUEST; ui_data->u.request_handle = handle = pref_request_cb(plugin); purple_request_add_close_notify(handle, purple_callback_set_zero, &info->ui_data); purple_request_add_close_notify(handle, g_free, ui_data); } else if (purple_plugin_info_get_pref_frame_cb(info)) { PurplePluginPrefFrameCb pref_frame_cb = purple_plugin_info_get_pref_frame_cb(info); GntWidget *win = process_pref_frame(pref_frame_cb(plugin)); g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(remove_confwin), plugin); ui_data->type = FINCH_PLUGIN_UI_DATA_TYPE_WINDOW; ui_data->u.window = win; } else { purple_notify_info(plugin, _("Error"), _("No configuration " "options for this plugin."), NULL, NULL); g_free(ui_data); purple_plugin_info_set_ui_data(info, NULL); } }
static void pidgin_sound_init(void) { void *gtk_sound_handle = pidgin_sound_get_handle(); void *blist_handle = purple_blist_get_handle(); void *conv_handle = purple_conversations_get_handle(); #ifdef USE_GSTREAMER GError *error = NULL; #endif purple_signal_connect(purple_connections_get_handle(), "signed-on", gtk_sound_handle, PURPLE_CALLBACK(account_signon_cb), NULL); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/sound"); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/sound/enabled"); purple_prefs_add_none(PIDGIN_PREFS_ROOT "/sound/file"); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/login", TRUE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/login", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/logout", TRUE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/logout", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/im_recv", TRUE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/im_recv", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/first_im_recv", FALSE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/first_im_recv", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/send_im", TRUE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/send_im", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/join_chat", FALSE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/join_chat", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/left_chat", FALSE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/left_chat", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/send_chat_msg", FALSE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/send_chat_msg", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/chat_msg_recv", FALSE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/chat_msg_recv", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/nick_said", FALSE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/nick_said", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/pounce_default", TRUE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/pounce_default", ""); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/sound/theme", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/sent_attention", TRUE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/sent_attention", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/enabled/got_attention", TRUE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/file/got_attention", ""); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/conv_focus", TRUE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/sound/mute", FALSE); purple_prefs_add_path(PIDGIN_PREFS_ROOT "/sound/command", ""); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/sound/method", "automatic"); purple_prefs_add_int(PIDGIN_PREFS_ROOT "/sound/volume", 50); #ifdef USE_GSTREAMER purple_debug_info("sound", "Initializing sound output drivers.\n"); gst_registry_fork_set_enabled(FALSE); if ((gst_init_failed = !gst_init_check(NULL, NULL, &error))) { purple_notify_error(NULL, _("GStreamer Failure"), _("GStreamer failed to initialize."), error ? error->message : "", NULL); if (error) { g_error_free(error); error = NULL; } } #endif /* USE_GSTREAMER */ purple_signal_connect(blist_handle, "buddy-signed-on", gtk_sound_handle, PURPLE_CALLBACK(buddy_state_cb), GINT_TO_POINTER(PURPLE_SOUND_BUDDY_ARRIVE)); purple_signal_connect(blist_handle, "buddy-signed-off", gtk_sound_handle, PURPLE_CALLBACK(buddy_state_cb), GINT_TO_POINTER(PURPLE_SOUND_BUDDY_LEAVE)); purple_signal_connect(conv_handle, "received-im-msg", gtk_sound_handle, PURPLE_CALLBACK(im_msg_received_cb), GINT_TO_POINTER(PURPLE_SOUND_RECEIVE)); purple_signal_connect(conv_handle, "sent-im-msg", gtk_sound_handle, PURPLE_CALLBACK(im_msg_sent_cb), GINT_TO_POINTER(PURPLE_SOUND_SEND)); purple_signal_connect(conv_handle, "chat-user-joined", gtk_sound_handle, PURPLE_CALLBACK(chat_user_join_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_JOIN)); purple_signal_connect(conv_handle, "chat-user-left", gtk_sound_handle, PURPLE_CALLBACK(chat_user_left_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_LEAVE)); purple_signal_connect(conv_handle, "sent-chat-msg", gtk_sound_handle, PURPLE_CALLBACK(chat_msg_sent_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_YOU_SAY)); purple_signal_connect(conv_handle, "received-chat-msg", gtk_sound_handle, PURPLE_CALLBACK(chat_msg_received_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_SAY)); purple_signal_connect(conv_handle, "got-attention", gtk_sound_handle, PURPLE_CALLBACK(got_attention_cb), GINT_TO_POINTER(PURPLE_SOUND_GOT_ATTENTION)); /* for the time being, don't handle sent-attention here, since playing a sound would result induplicate sounds. And fixing that would require changing the conversation signal for msg-recv */ }
static gboolean handle_presence_chat(JabberStream *js, JabberPresence *presence, xmlnode *packet) { static int i = 1; PurpleConvChatBuddyFlags flags = PURPLE_CBFLAGS_NONE; JabberChat *chat = presence->chat; if (presence->state == JABBER_BUDDY_STATE_ERROR) { char *title, *msg = jabber_parse_error(js, packet, NULL); if (!chat->conv) { title = g_strdup_printf(_("Error joining chat %s"), presence->from); purple_serv_got_join_chat_failed(js->gc, chat->components); } else { title = g_strdup_printf(_("Error in chat %s"), presence->from); if (g_hash_table_size(chat->members) == 0) serv_got_chat_left(js->gc, chat->id); } purple_notify_error(js->gc, title, title, msg); g_free(title); g_free(msg); if (g_hash_table_size(chat->members) == 0) /* Only destroy the chat if the error happened while joining */ jabber_chat_destroy(chat); return FALSE; } if (presence->type == JABBER_PRESENCE_AVAILABLE) { const char *jid = NULL; const char *affiliation = NULL; const char *role = NULL; gboolean is_our_resource = FALSE; /* Is the presence about us? */ JabberBuddyResource *jbr; /* * XEP-0045 mandates the presence to include a resource (which is * treated as the chat nick). Some non-compliant servers allow * joining without a nick. */ if (!presence->jid_from->resource) return FALSE; if (presence->chat_info.item) { jid = xmlnode_get_attrib(presence->chat_info.item, "jid"); affiliation = xmlnode_get_attrib(presence->chat_info.item, "affiliation"); role = xmlnode_get_attrib(presence->chat_info.item, "role"); } if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(110)) || g_str_equal(presence->jid_from->resource, chat->handle) || purple_strequal(presence->to, jid)) is_our_resource = TRUE; if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(201))) { chat->config_dialog_type = PURPLE_REQUEST_ACTION; chat->config_dialog_handle = purple_request_action(js->gc, _("Create New Room"), _("Create New Room"), _("You are creating a new room. Would" " you like to configure it, or" " accept the default settings?"), /* Default Action */ 1, purple_connection_get_account(js->gc), NULL, chat->conv, chat, 2, _("_Configure Room"), G_CALLBACK(jabber_chat_request_room_configure), _("_Accept Defaults"), G_CALLBACK(jabber_chat_create_instant_room)); } if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(210))) { /* server rewrote room-nick */ g_free(chat->handle); chat->handle = g_strdup(presence->jid_from->resource); } if (purple_strequal(affiliation, "owner")) flags |= PURPLE_CBFLAGS_FOUNDER; if (role) { if (g_str_equal(role, "moderator")) flags |= PURPLE_CBFLAGS_OP; else if (g_str_equal(role, "participant")) flags |= PURPLE_CBFLAGS_VOICE; } if(!chat->conv) { char *room_jid = g_strdup_printf("%s@%s", presence->jid_from->node, presence->jid_from->domain); chat->id = i++; chat->conv = serv_got_joined_chat(js->gc, chat->id, room_jid); purple_conv_chat_set_nick(PURPLE_CONV_CHAT(chat->conv), chat->handle); jabber_chat_disco_traffic(chat); g_free(room_jid); } jbr = jabber_buddy_track_resource(presence->jb, presence->jid_from->resource, presence->priority, presence->state, presence->status); jbr->commands_fetched = TRUE; jabber_chat_track_handle(chat, presence->jid_from->resource, jid, affiliation, role); if(!jabber_chat_find_buddy(chat->conv, presence->jid_from->resource)) purple_conv_chat_add_user(PURPLE_CONV_CHAT(chat->conv), presence->jid_from->resource, jid, flags, chat->joined > 0 && ((!presence->delayed) || (presence->sent > chat->joined))); else purple_conv_chat_user_set_flags(PURPLE_CONV_CHAT(chat->conv), presence->jid_from->resource, flags); if (is_our_resource && chat->joined == 0) chat->joined = time(NULL); } else if (presence->type == JABBER_PRESENCE_UNAVAILABLE) { gboolean nick_change = FALSE; gboolean kick = FALSE; gboolean is_our_resource = FALSE; /* Is the presence about us? */ const char *jid = NULL; /* If the chat nick is invalid, we haven't yet joined, or we've * already left (it was probably us leaving after we closed the * chat), we don't care. */ if (!presence->jid_from->resource || !chat->conv || chat->left) { if (chat->left && presence->jid_from->resource && chat->handle && !strcmp(presence->jid_from->resource, chat->handle)) jabber_chat_destroy(chat); return FALSE; } is_our_resource = g_str_equal(presence->jid_from->resource, chat->handle); jabber_buddy_remove_resource(presence->jb, presence->jid_from->resource); if (presence->chat_info.item) jid = xmlnode_get_attrib(presence->chat_info.item, "jid"); if (chat->muc) { if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(110))) { is_our_resource = TRUE; chat->joined = 0; } if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(301))) { /* XXX: We got banned. YAY! (No GIR, that's bad) */ } if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(303))) { const char *nick = NULL; if (presence->chat_info.item) nick = xmlnode_get_attrib(presence->chat_info.item, "nick"); /* nick change */ if (!nick) { purple_debug_warning("jabber", "Chat presence indicating a nick change, but no new nickname!\n"); } else { nick_change = TRUE; if (g_str_equal(presence->jid_from->resource, chat->handle)) { /* Changing our own nickname */ g_free(chat->handle); /* TODO: This should be resourceprep'd */ chat->handle = g_strdup(nick); } purple_conv_chat_rename_user(PURPLE_CONV_CHAT(chat->conv), presence->jid_from->resource, nick); jabber_chat_remove_handle(chat, presence->jid_from->resource); } } if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(307))) { /* Someone was kicked from the room */ const char *actor = NULL; char *reason = NULL; char *tmp; kick = TRUE; if (presence->chat_info.item) { xmlnode *node; node = xmlnode_get_child(presence->chat_info.item, "actor"); if (node) actor = xmlnode_get_attrib(node, "jid"); node = xmlnode_get_child(presence->chat_info.item, "reason"); if (node) reason = xmlnode_get_data(node); } if (reason == NULL) reason = g_strdup(_("No reason")); if (is_our_resource) { if (actor) tmp = g_strdup_printf(_("You have been kicked by %s: (%s)"), actor, reason); else tmp = g_strdup_printf(_("You have been kicked: (%s)"), reason); } else { if (actor) tmp = g_strdup_printf(_("Kicked by %s (%s)"), actor, reason); else tmp = g_strdup_printf(_("Kicked (%s)"), reason); } g_free(presence->status); presence->status = tmp; g_free(reason); } if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(321))) { /* XXX: removed due to an affiliation change */ } if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(322))) { /* XXX: removed because room is now members-only */ } if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(332))) { /* XXX: removed due to system shutdown */ } } /* * Possibly another connected resource of our JID (see XEP-0045 * v1.24 section 7.1.10) being disconnected. Should be * distinguished by the item_jid. * Also possibly works around bits of an Openfire bug. See * #8319. */ if (is_our_resource && jid && !purple_strequal(presence->to, jid)) { /* TODO: When the above is a loop, this needs to still act * sanely for all cases (this code is a little fragile). */ if (!kick && !nick_change) /* Presumably, kicks and nick changes also affect us. */ is_our_resource = FALSE; } if(!nick_change) { if (is_our_resource) { if (kick) purple_conv_chat_write(PURPLE_CONV_CHAT(chat->conv), presence->jid_from->resource, presence->status, PURPLE_MESSAGE_SYSTEM, time(NULL)); serv_got_chat_left(js->gc, chat->id); jabber_chat_destroy(chat); } else { purple_conv_chat_remove_user(PURPLE_CONV_CHAT(chat->conv), presence->jid_from->resource, presence->status); jabber_chat_remove_handle(chat, presence->jid_from->resource); } } } return TRUE; }
void gfire_chat_proto_join_info(gfire_data *p_gfire, guint16 p_packet_len) { if(!p_gfire) return; guint32 offset = XFIRE_HEADER_LEN; gfire_chat *chat = NULL; guint8 *chat_id = NULL; guint32 requestID = 0; guint32 response = 0; guint32 my_permission = 0; guint32 access = 0; guint32 type = 0; gchar *topic = NULL; gchar *motd = NULL; gboolean new_room = FALSE; gboolean secure = FALSE; gboolean silenced = FALSE; gboolean show_join_leave = FALSE; if (!p_gfire || (p_packet_len == 0)) return; // xfire chat id offset = gfire_proto_read_attr_chatid_bs(p_gfire->buff_in, &chat_id, 0x04, offset); if(offset == -1 || !chat_id) return; // requestID offset = gfire_proto_read_attr_int32_bs(p_gfire->buff_in, &requestID, 0x0B, offset); if(offset == -1) return; // response offset = gfire_proto_read_attr_int32_bs(p_gfire->buff_in, &response, 0x0C, offset); if(offset == -1) return; // Password required but not given if(response == 4) { // Chat ID will be freed by the function gfire_chat_request_password_rejoin(p_gfire, chat_id, FALSE); return; } // Wrong password given else if(response == 5) { // Chat ID will be freed by the function gfire_chat_request_password_rejoin(p_gfire, chat_id, TRUE); return; } // Other failure else if(response != 0) { purple_notify_error(gfire_get_connection(p_gfire), _("Chat room join error"), _("Unknown error"), _("Unknown join error. You might be blocked from this chat room or are already in 5 rooms.")); g_free(chat_id); return; } // own permission offset = gfire_proto_read_attr_int32_bs(p_gfire->buff_in, &my_permission, 0x12, offset); if(offset == -1) { g_free(chat_id); return; } // accessibility (public / private) offset = gfire_proto_read_attr_int32_bs(p_gfire->buff_in, &access, 0x17, offset); if(offset == -1) { g_free(chat_id); return; } // chat room type (normal / live broadcast) offset = gfire_proto_read_attr_int32_bs(p_gfire->buff_in, &type, 0xAA, offset); if(offset == -1) { g_free(chat_id); return; } // topic offset = gfire_proto_read_attr_string_bs(p_gfire->buff_in, &topic, 0x05, offset); if(offset == -1 || !topic) { g_free(chat_id); return; } // message of the day offset = gfire_proto_read_attr_string_bs(p_gfire->buff_in, &motd, 0x4D, offset); if(offset == -1 || !motd) { g_free(chat_id); g_free(topic); return; } // new room offset = gfire_proto_read_attr_boolean_bs(p_gfire->buff_in, &new_room, 0xA5, offset); if(offset == -1) { g_free(chat_id); g_free(topic); g_free(motd); return; } // password protected offset = gfire_proto_read_attr_boolean_bs(p_gfire->buff_in, &secure, 0xA6, offset); if(offset == -1) { g_free(chat_id); g_free(topic); g_free(motd); return; } // silenced offset = gfire_proto_read_attr_boolean_bs(p_gfire->buff_in, &silenced, 0x16, offset); if(offset == -1) { g_free(chat_id); g_free(topic); g_free(motd); return; } // show join/leave messages offset = gfire_proto_read_attr_boolean_bs(p_gfire->buff_in, &show_join_leave, 0x1B, offset); if(offset == -1) { g_free(chat_id); g_free(topic); g_free(motd); return; } // packet has been parsed gboolean created = FALSE; chat = gfire_find_chat(p_gfire, chat_id, GFFC_CID); if(!chat) { // Create a new chat with the correct values created = TRUE; chat = gfire_chat_create(p_gfire, chat_id, topic, motd, FALSE); } else { // Set current values gfire_chat_set_topic(chat, topic, FALSE); gfire_chat_set_motd(chat, motd, FALSE); } g_free(chat_id); g_free(topic); g_free(motd); gfire_chat_set_accessibility(chat, access, FALSE); gfire_chat_set_secure(chat, secure, FALSE); gfire_chat_set_silenced(chat, silenced, FALSE); gfire_chat_set_show_join_leave(chat, show_join_leave, FALSE); // Add it to gfire_data and tell purple about the chat if(created) gfire_add_chat(p_gfire, chat); gfire_chat_show(chat); }
PurpleXmlNode * purple_xmlnode_from_file(const char *dir,const char *filename, const char *description, const char *process) { gchar *filename_full; GError *error = NULL; gchar *contents = NULL; gsize length; PurpleXmlNode *node = NULL; g_return_val_if_fail(dir != NULL, NULL); purple_debug_misc(process, "Reading file %s from directory %s\n", filename, dir); filename_full = g_build_filename(dir, filename, NULL); if (!g_file_test(filename_full, G_FILE_TEST_EXISTS)) { purple_debug_info(process, "File %s does not exist (this is not " "necessarily an error)\n", filename_full); g_free(filename_full); return NULL; } if (!g_file_get_contents(filename_full, &contents, &length, &error)) { purple_debug_error(process, "Error reading file %s: %s\n", filename_full, error->message); g_error_free(error); } if ((contents != NULL) && (length > 0)) { node = purple_xmlnode_from_str(contents, length); /* If we were unable to parse the file then save its contents to a backup file */ if (node == NULL) { gchar *filename_temp, *filename_temp_full; filename_temp = g_strdup_printf("%s~", filename); filename_temp_full = g_build_filename(dir, filename_temp, NULL); purple_debug_error("util", "Error parsing file %s. Renaming old " "file to %s\n", filename_full, filename_temp); purple_util_write_data_to_file_absolute(filename_temp_full, contents, length); g_free(filename_temp_full); g_free(filename_temp); } g_free(contents); } /* If we could not parse the file then show the user an error message */ if (node == NULL) { gchar *title, *msg; title = g_strdup_printf(_("Error Reading %s"), filename); msg = g_strdup_printf(_("An error was encountered reading your " "%s. The file has not been loaded, and the old file " "has been renamed to %s~."), description, filename_full); purple_notify_error(NULL, NULL, title, msg, NULL); g_free(title); g_free(msg); } g_free(filename_full); return node; }
/*add buddy*/ void msn_userlist_add_buddy(MsnUserList *userlist, const char *who, const char *group_name) { MsnUser *user; MsnCallbackState *state = NULL; const char *group_id = NULL, *new_group_name; new_group_name = group_name == NULL ? MSN_INDIVIDUALS_GROUP_NAME : group_name; g_return_if_fail(userlist != NULL); g_return_if_fail(userlist->session != NULL); purple_debug_info("msn", "Add user: %s to group: %s\n", who, new_group_name); if (!msn_email_is_valid(who)) { /* only notify the user about problems adding to the friends list * maybe we should do something else for other lists, but it probably * won't cause too many problems if we just ignore it */ char *str = g_strdup_printf(_("Unable to add \"%s\"."), who); purple_notify_error(NULL, NULL, str, _("The username specified is invalid.")); g_free(str); return; } state = msn_callback_state_new(userlist->session); msn_callback_state_set_who(state, who); msn_callback_state_set_new_group_name(state, new_group_name); group_id = msn_userlist_find_group_id(userlist, new_group_name); if (group_id == NULL) { /* Whoa, we must add that group first. */ purple_debug_info("msn", "Adding user %s to a new group, creating group %s first\n", who, new_group_name); msn_callback_state_set_action(state, MSN_ADD_BUDDY); msn_add_group(userlist->session, state, new_group_name); return; } else { msn_callback_state_set_guid(state, group_id); } /* XXX: adding user here may not be correct (should add them in the * ACK to the ADL command), but for now we need to make sure they exist * early enough that the ILN command doesn't screw us up */ user = msn_userlist_find_add_user(userlist, who, who); if ( msn_userlist_user_is_in_list(user, MSN_LIST_FL) ) { purple_debug_info("msn", "User %s already exists\n", who); msn_userlist_rem_buddy_from_list(userlist, who, MSN_LIST_BL); if (msn_userlist_user_is_in_group(user, group_id)) { purple_debug_info("msn", "User %s is already in group %s, returning\n", who, new_group_name); msn_callback_state_free(state); return; } } purple_debug_info("msn", "Adding user: %s to group id: %s\n", who, group_id); msn_callback_state_set_action(state, MSN_ADD_BUDDY); /* Add contact in the Contact server with a SOAP request and if successful, send ADL with MSN_LIST_AL and MSN_LIST_FL and a FQY */ msn_add_contact_to_group(userlist->session, state, who, group_id); }
void hon_parse_max_channels(PurpleConnection *gc,gchar* buffer){ purple_notify_error(NULL,_("Channel limit reached"),_("You have reached an open channels limit."), _("To join other channel close some already opened")); }
void qq_process_question(PurpleConnection *gc, guint8 *data, gint data_len, guint32 uid) { qq_data *qd; gint bytes; guint8 cmd, reply; gchar *question, *answer; guint16 code_len; guint8 *code; g_return_if_fail(data != NULL && data_len != 0); qd = (qq_data *) gc->proto_data; qq_show_packet("qq_process_question", data, data_len); bytes = 0; bytes += qq_get8(&cmd, data + bytes); if (cmd == QQ_QUESTION_GET) { bytes += qq_get_vstr(&question, QQ_CHARSET_DEFAULT, data + bytes); bytes += qq_get_vstr(&answer, QQ_CHARSET_DEFAULT, data + bytes); purple_debug_info("QQ", "Get buddy adding Q&A:\n%s\n%s\n", question, answer); g_free(question); g_free(answer); return; } if (cmd == QQ_QUESTION_SET) { bytes += qq_get8(&reply, data + bytes); if (reply == 0) { purple_debug_info("QQ", "Successed setting Q&A\n"); } else { purple_debug_warning("QQ", "Failed setting Q&A, reply %d\n", reply); } return; } g_return_if_fail(uid != 0); bytes += 2; /* skip 2 bytes, 0x(00 01)*/ if (cmd == QQ_QUESTION_REQUEST) { bytes += qq_get8(&reply, data + bytes); if (reply == 0x01) { purple_debug_warning("QQ", "Failed getting question, reply %d\n", reply); return; } bytes += qq_get_vstr(&question, QQ_CHARSET_DEFAULT, data + bytes); purple_debug_info("QQ", "Get buddy question:\n%s\n", question); add_buddy_question_input(gc, uid, question); g_free(question); return; } if (cmd == QQ_QUESTION_ANSWER) { bytes += qq_get8(&reply, data + bytes); if (reply == 0x01) { purple_notify_error(gc, _("Add Buddy"), _("Invalid answer."), NULL); return; } bytes += qq_get16(&code_len, data + bytes); g_return_if_fail(code_len > 0); g_return_if_fail(bytes + code_len <= data_len); code = g_newa(guint8, code_len); bytes += qq_getdata(code, code_len, data + bytes); request_add_buddy_by_question(gc, uid, code, code_len); return; } g_return_if_reached(); }
void jabber_chat_join(PurpleConnection *gc, GHashTable *data) { JabberChat *chat; char *room, *server, *handle, *passwd; xmlnode *presence, *x; char *tmp, *room_jid, *full_jid; JabberStream *js = gc->proto_data; PurplePresence *gpresence; PurpleStatus *status; JabberBuddyState state; char *msg; int priority; room = g_hash_table_lookup(data, "room"); server = g_hash_table_lookup(data, "server"); handle = g_hash_table_lookup(data, "handle"); passwd = g_hash_table_lookup(data, "password"); if(!room || !server) return; if(!handle) handle = js->user->node; if(!jabber_nodeprep_validate(room)) { char *buf = g_strdup_printf(_("%s is not a valid room name"), room); purple_notify_error(gc, _("Invalid Room Name"), _("Invalid Room Name"), buf); g_free(buf); return; } else if(!jabber_nameprep_validate(server)) { char *buf = g_strdup_printf(_("%s is not a valid server name"), server); purple_notify_error(gc, _("Invalid Server Name"), _("Invalid Server Name"), buf); g_free(buf); return; } else if(!jabber_resourceprep_validate(handle)) { char *buf = g_strdup_printf(_("%s is not a valid room handle"), handle); purple_notify_error(gc, _("Invalid Room Handle"), _("Invalid Room Handle"), buf); } if(jabber_chat_find(js, room, server)) return; tmp = g_strdup_printf("%s@%s", room, server); room_jid = g_strdup(jabber_normalize(NULL, tmp)); g_free(tmp); chat = g_new0(JabberChat, 1); chat->js = gc->proto_data; chat->room = g_strdup(room); chat->server = g_strdup(server); chat->handle = g_strdup(handle); chat->members = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, (GDestroyNotify)jabber_chat_member_free); g_hash_table_insert(js->chats, room_jid, chat); gpresence = purple_account_get_presence(gc->account); status = purple_presence_get_active_status(gpresence); purple_status_to_jabber(status, &state, &msg, &priority); presence = jabber_presence_create(state, msg, priority); full_jid = g_strdup_printf("%s/%s", room_jid, handle); xmlnode_set_attrib(presence, "to", full_jid); g_free(full_jid); g_free(msg); x = xmlnode_new_child(presence, "x"); xmlnode_set_namespace(x, "http://jabber.org/protocol/muc"); if(passwd && *passwd) { xmlnode *password = xmlnode_new_child(x, "password"); xmlnode_insert_data(password, passwd, -1); } jabber_send(js, presence); xmlnode_free(presence); }
static void ggp_pubdir_search_results_display(PurpleConnection *gc, int records_count, const ggp_pubdir_record *records, int next_offset, void *_form) { ggp_pubdir_search_form *form = _form; PurpleNotifySearchResults *results; int i; purple_debug_info("gg", "ggp_pubdir_search_results_display: " "got %d records (next offset: %d)\n", records_count, next_offset); if (records_count < 0 || (records_count == 0 && form->offset != 0)) { purple_notify_error(gc, GGP_PUBDIR_SEARCH_TITLE, _("Error while searching for buddies"), NULL, purple_request_cpar_from_connection(gc)); ggp_pubdir_search_form_free(form); return; } if (records_count == 0) { purple_notify_info(gc, GGP_PUBDIR_SEARCH_TITLE, _("No matching users found"), _("There are no users matching your search criteria."), purple_request_cpar_from_connection(gc)); ggp_pubdir_search_form_free(form); return; } form->offset = next_offset; results = purple_notify_searchresults_new(); purple_notify_searchresults_column_add(results, purple_notify_searchresults_column_new(_("GG Number"))); purple_notify_searchresults_column_add(results, purple_notify_searchresults_column_new(_("Name"))); purple_notify_searchresults_column_add(results, purple_notify_searchresults_column_new(_("City"))); purple_notify_searchresults_column_add(results, purple_notify_searchresults_column_new(_("Gender"))); purple_notify_searchresults_column_add(results, purple_notify_searchresults_column_new(_("Age"))); for (i = 0; i < records_count; i++) { GList *row = NULL; const ggp_pubdir_record *record = &records[i]; gchar *gender = NULL, *age = NULL; if (record->gender == GGP_PUBDIR_GENDER_MALE) gender = g_strdup("male"); else if (record->gender == GGP_PUBDIR_GENDER_FEMALE) gender = g_strdup("female"); if (record->age) age = g_strdup_printf("%d", record->age); row = g_list_append(row, g_strdup(ggp_uin_to_str(record->uin))); row = g_list_append(row, g_strdup(record->label)); row = g_list_append(row, g_strdup(record->city)); row = g_list_append(row, gender); row = g_list_append(row, age); purple_notify_searchresults_row_add(results, row); } purple_notify_searchresults_button_add(results, PURPLE_NOTIFY_BUTTON_ADD, ggp_pubdir_search_results_add); purple_notify_searchresults_button_add(results, PURPLE_NOTIFY_BUTTON_IM, ggp_pubdir_search_results_im); purple_notify_searchresults_button_add(results, PURPLE_NOTIFY_BUTTON_INFO, ggp_pubdir_search_results_info); purple_notify_searchresults_button_add_labeled(results, _("New search"), ggp_pubdir_search_results_new); if (next_offset != 0) purple_notify_searchresults_button_add(results, PURPLE_NOTIFY_BUTTON_CONTINUE, ggp_pubdir_search_results_next); if (!form->display_handle) form->display_handle = purple_notify_searchresults(gc, GGP_PUBDIR_SEARCH_TITLE, _("Search results"), NULL, results, ggp_pubdir_search_results_close, form); else purple_notify_searchresults_new_rows(gc, results, form->display_handle); g_assert(form->display_handle); }
void silcpurple_verify_public_key(SilcClient client, SilcClientConnection conn, const char *name, SilcConnectionType conn_type, SilcPublicKey public_key, SilcVerifyPublicKey completion, void *context) { PurpleConnection *gc = client->application; int i; char file[256], filename[256], filename2[256], *ipf, *hostf = NULL; char *fingerprint, *babbleprint; struct passwd *pw; struct stat st; char *entity = ((conn_type == SILC_CONN_SERVER || conn_type == SILC_CONN_ROUTER) ? "server" : "client"); PublicKeyVerify verify; const char *ip, *hostname; SilcUInt16 port; unsigned char *pk; SilcUInt32 pk_len; if (silc_pkcs_get_type(public_key) != SILC_PKCS_SILC) { purple_notify_error(gc, _("Verify Public Key"), _("Unsupported public key type"), NULL); if (completion) completion(FALSE, context); return; } pw = getpwuid(getuid()); if (!pw) { if (completion) completion(FALSE, context); return; } memset(filename, 0, sizeof(filename)); memset(filename2, 0, sizeof(filename2)); memset(file, 0, sizeof(file)); silc_socket_stream_get_info(silc_packet_stream_get_stream(conn->stream), NULL, &hostname, &ip, &port); pk = silc_pkcs_public_key_encode(public_key, &pk_len); if (!pk) { if (completion) completion(FALSE, context); return; } if (conn_type == SILC_CONN_SERVER || conn_type == SILC_CONN_ROUTER) { if (!name) { g_snprintf(file, sizeof(file) - 1, "%skey_%s_%d.pub", entity, ip, port); g_snprintf(filename, sizeof(filename) - 1, "%s" G_DIR_SEPARATOR_S "%skeys" G_DIR_SEPARATOR_S "%s", silcpurple_silcdir(), entity, file); g_snprintf(file, sizeof(file) - 1, "%skey_%s_%d.pub", entity, hostname, port); g_snprintf(filename2, sizeof(filename2) - 1, "%s" G_DIR_SEPARATOR_S "%skeys" G_DIR_SEPARATOR_S "%s", silcpurple_silcdir(), entity, file); ipf = filename; hostf = filename2; } else { g_snprintf(file, sizeof(file) - 1, "%skey_%s_%d.pub", entity, name, port); g_snprintf(filename, sizeof(filename) - 1, "%s" G_DIR_SEPARATOR_S "%skeys" G_DIR_SEPARATOR_S "%s", silcpurple_silcdir(), entity, file); ipf = filename; } } else { /* Replace all whitespaces with `_'. */ fingerprint = silc_hash_fingerprint(NULL, pk, pk_len); for (i = 0; i < strlen(fingerprint); i++) if (fingerprint[i] == ' ') fingerprint[i] = '_'; g_snprintf(file, sizeof(file) - 1, "%skey_%s.pub", entity, fingerprint); g_snprintf(filename, sizeof(filename) - 1, "%s" G_DIR_SEPARATOR_S "%skeys" G_DIR_SEPARATOR_S "%s", silcpurple_silcdir(), entity, file); silc_free(fingerprint); ipf = filename; } verify = silc_calloc(1, sizeof(*verify)); if (!verify) return; verify->client = client; verify->conn = conn; verify->filename = g_strdup(ipf); verify->entity = g_strdup(entity); verify->entity_name = (conn_type != SILC_CONN_CLIENT ? (name ? g_strdup(name) : g_strdup(hostname)) : NULL); verify->public_key = silc_pkcs_public_key_copy(public_key); verify->completion = completion; verify->context = context; fingerprint = verify->fingerprint = silc_hash_fingerprint(NULL, pk, pk_len); babbleprint = verify->babbleprint = silc_hash_babbleprint(NULL, pk, pk_len); /* Check whether this key already exists */ if (g_stat(ipf, &st) < 0 && (!hostf || g_stat(hostf, &st) < 0)) { /* Key does not exist, ask user to verify the key and save it */ silcpurple_verify_ask(name ? name : entity, fingerprint, babbleprint, verify); return; } else { /* The key already exists, verify it. */ SilcPublicKey public_key; unsigned char *encpk; SilcUInt32 encpk_len; /* Load the key file, try for both IP filename and hostname filename */ if (!silc_pkcs_load_public_key(ipf, &public_key) && (!hostf || (!silc_pkcs_load_public_key(hostf, &public_key)))) { silcpurple_verify_ask(name ? name : entity, fingerprint, babbleprint, verify); return; } /* Encode the key data */ encpk = silc_pkcs_public_key_encode(public_key, &encpk_len); if (!encpk) { silcpurple_verify_ask(name ? name : entity, fingerprint, babbleprint, verify); return; } /* Compare the keys */ if (memcmp(encpk, pk, encpk_len)) { /* Ask user to verify the key and save it */ verify->changed = TRUE; silcpurple_verify_ask(name ? name : entity, fingerprint, babbleprint, verify); return; } /* Local copy matched */ if (completion) completion(TRUE, context); g_free(verify->filename); g_free(verify->entity); g_free(verify->entity_name); silc_free(verify->fingerprint); silc_free(verify->babbleprint); silc_pkcs_public_key_free(verify->public_key); silc_free(verify); } }
static void install_selected_file_cb(gpointer handle, const char *filename) { /* Try to init the selected file. * If it succeeds, try to make a copy of the file in $USERDIR/plugins/. * If the copy succeeds, unload and destroy the plugin in the original * location and init+load the new one. * Select the plugin in the plugin list. */ char *path; PurplePlugin *plugin; g_return_if_fail(plugins.window); plugin = purple_plugin_probe(filename); if (!plugin) { purple_notify_error(handle, _("Error loading plugin"), _("The selected file is not a valid plugin."), _("Please open the debug window and try again to see the exact error message."), NULL); return; } if (g_list_find(gnt_tree_get_rows(GNT_TREE(plugins.tree)), plugin)) { purple_plugin_load(plugin); gnt_tree_set_choice(GNT_TREE(plugins.tree), plugin, purple_plugin_is_loaded(plugin)); gnt_tree_set_selected(GNT_TREE(plugins.tree), plugin); return; } path = g_build_filename(purple_user_dir(), "plugins", NULL); if (purple_build_dir(path, S_IRUSR | S_IWUSR | S_IXUSR) == 0) { char *content = NULL; gsize length = 0; if (g_file_get_contents(filename, &content, &length, NULL)) { char *file = g_path_get_basename(filename); g_free(path); path = g_build_filename(purple_user_dir(), "plugins", file, NULL); if (purple_util_write_data_to_file_absolute(path, content, length)) { purple_plugin_destroy(plugin); plugin = purple_plugin_probe(path); if (!plugin) { purple_debug_warning("gntplugin", "This is really strange. %s can be loaded, but %s can't!\n", filename, path); g_unlink(path); plugin = purple_plugin_probe(filename); } } else { } } g_free(content); } g_free(path); purple_plugin_load(plugin); if (plugin->info->type == PURPLE_PLUGIN_LOADER) { GList *cur; for (cur = PURPLE_PLUGIN_LOADER_INFO(plugin)->exts; cur != NULL; cur = cur->next) purple_plugins_probe(cur->data); return; } if (plugin->info->type != PURPLE_PLUGIN_STANDARD || (plugin->info->flags & PURPLE_PLUGIN_FLAG_INVISIBLE) || plugin->error) return; gnt_tree_add_choice(GNT_TREE(plugins.tree), plugin, gnt_tree_create_row(GNT_TREE(plugins.tree), plugin->info->name), NULL, NULL); gnt_tree_set_choice(GNT_TREE(plugins.tree), plugin, purple_plugin_is_loaded(plugin)); gnt_tree_set_row_flags(GNT_TREE(plugins.tree), plugin, GNT_TEXT_FLAG_BOLD); gnt_tree_set_selected(GNT_TREE(plugins.tree), plugin); }
static void silcpurple_ftp_monitor(SilcClient client, SilcClientConnection conn, SilcClientMonitorStatus status, SilcClientFileError error, SilcUInt64 offset, SilcUInt64 filesize, SilcClientEntry client_entry, SilcUInt32 session_id, const char *filepath, void *context) { SilcPurpleXfer xfer = context; PurpleConnection *gc = xfer->sg->gc; char tmp[256]; if (status == SILC_CLIENT_FILE_MONITOR_CLOSED) { purple_xfer_unref(xfer->xfer); silc_free(xfer); return; } if (status == SILC_CLIENT_FILE_MONITOR_KEY_AGREEMENT) return; if (status == SILC_CLIENT_FILE_MONITOR_ERROR) { if (error == SILC_CLIENT_FILE_NO_SUCH_FILE) { g_snprintf(tmp, sizeof(tmp), "No such file %s", filepath ? filepath : "[N/A]"); purple_notify_error(gc, _("Secure File Transfer"), _("Error during file transfer"), tmp); } else if (error == SILC_CLIENT_FILE_PERMISSION_DENIED) { purple_notify_error(gc, _("Secure File Transfer"), _("Error during file transfer"), _("Permission denied")); } else if (error == SILC_CLIENT_FILE_KEY_AGREEMENT_FAILED) { purple_notify_error(gc, _("Secure File Transfer"), _("Error during file transfer"), _("Key agreement failed")); } else if (error == SILC_CLIENT_FILE_UNKNOWN_SESSION) { purple_notify_error(gc, _("Secure File Transfer"), _("Error during file transfer"), _("File transfer session does not exist")); } else { purple_notify_error(gc, _("Secure File Transfer"), _("Error during file transfer"), NULL); } silc_client_file_close(client, conn, session_id); purple_xfer_unref(xfer->xfer); silc_free(xfer); return; } /* Update file transfer UI */ if (!offset && filesize) purple_xfer_set_size(xfer->xfer, filesize); if (offset && filesize) { xfer->xfer->bytes_sent = offset; xfer->xfer->bytes_remaining = filesize - offset; } purple_xfer_update_progress(xfer->xfer); if (status == SILC_CLIENT_FILE_MONITOR_SEND || status == SILC_CLIENT_FILE_MONITOR_RECEIVE) { if (offset == filesize) { /* Download finished */ purple_xfer_set_completed(xfer->xfer, TRUE); silc_client_file_close(client, conn, session_id); } } }
static void purple_xfer_choose_file_ok_cb(void *user_data, const char *filename) { PurpleXfer *xfer; PurpleXferType type; struct stat st; gchar *dir; xfer = (PurpleXfer *)user_data; type = purple_xfer_get_type(xfer); if (g_stat(filename, &st) != 0) { /* File not found. */ if (type == PURPLE_XFER_RECEIVE) { #ifndef _WIN32 int mode = W_OK; #else int mode = F_OK; #endif dir = g_path_get_dirname(filename); if (g_access(dir, mode) == 0) { purple_xfer_request_accepted(xfer, filename); } else { purple_xfer_ref(xfer); purple_notify_message( NULL, PURPLE_NOTIFY_MSG_ERROR, NULL, _("Directory is not writable."), NULL, (PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer); } g_free(dir); } else { purple_xfer_show_file_error(xfer, filename); purple_xfer_cancel_local(xfer); } } else if ((type == PURPLE_XFER_SEND) && (st.st_size == 0)) { purple_notify_error(NULL, NULL, _("Cannot send a file of 0 bytes."), NULL); purple_xfer_cancel_local(xfer); } else if ((type == PURPLE_XFER_SEND) && S_ISDIR(st.st_mode)) { /* * XXX - Sending a directory should be valid for some protocols. */ purple_notify_error(NULL, NULL, _("Cannot send a directory."), NULL); purple_xfer_cancel_local(xfer); } else if ((type == PURPLE_XFER_RECEIVE) && S_ISDIR(st.st_mode)) { char *msg, *utf8; utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL); msg = g_strdup_printf( _("%s is not a regular file. Cowardly refusing to overwrite it.\n"), utf8); g_free(utf8); purple_notify_error(NULL, NULL, msg, NULL); g_free(msg); purple_xfer_request_denied(xfer); } else if (type == PURPLE_XFER_SEND) { #ifndef _WIN32 int mode = R_OK; #else int mode = F_OK; #endif if (g_access(filename, mode) == 0) { purple_xfer_request_accepted(xfer, filename); } else { purple_xfer_ref(xfer); purple_notify_message( NULL, PURPLE_NOTIFY_MSG_ERROR, NULL, _("File is not readable."), NULL, (PurpleNotifyCloseCallback)purple_xfer_choose_file, xfer); } } else { purple_xfer_request_accepted(xfer, filename); } purple_xfer_unref(xfer); }
static void finch_sound_init(void) { void *gnt_sound_handle = finch_sound_get_handle(); void *blist_handle = purple_blist_get_handle(); void *conv_handle = purple_conversations_get_handle(); #ifdef USE_GSTREAMER GError *error = NULL; #endif purple_signal_connect(purple_connections_get_handle(), "signed-on", gnt_sound_handle, PURPLE_CALLBACK(account_signon_cb), NULL); purple_prefs_add_none(FINCH_PREFS_ROOT "/sound"); purple_prefs_add_string(FINCH_PREFS_ROOT "/sound/actprofile", DEFAULT_PROFILE); purple_prefs_add_none(FINCH_PREFS_ROOT "/sound/profiles"); purple_prefs_connect_callback(gnt_sound_handle, FINCH_PREFS_ROOT "/sound/actprofile", initialize_profile, NULL); purple_prefs_trigger_callback(FINCH_PREFS_ROOT "/sound/actprofile"); #ifdef USE_GSTREAMER purple_debug_info("sound", "Initializing sound output drivers.\n"); #if (GST_VERSION_MAJOR > 0 || \ (GST_VERSION_MAJOR == 0 && GST_VERSION_MINOR > 10) || \ (GST_VERSION_MAJOR == 0 && GST_VERSION_MINOR == 10 && GST_VERSION_MICRO >= 10)) gst_registry_fork_set_enabled(FALSE); #endif if ((gst_init_failed = !gst_init_check(NULL, NULL, &error))) { purple_notify_error(NULL, _("GStreamer Failure"), _("GStreamer failed to initialize."), error ? error->message : ""); if (error) { g_error_free(error); error = NULL; } } #endif /* USE_GSTREAMER */ purple_signal_connect(blist_handle, "buddy-signed-on", gnt_sound_handle, PURPLE_CALLBACK(buddy_state_cb), GINT_TO_POINTER(PURPLE_SOUND_BUDDY_ARRIVE)); purple_signal_connect(blist_handle, "buddy-signed-off", gnt_sound_handle, PURPLE_CALLBACK(buddy_state_cb), GINT_TO_POINTER(PURPLE_SOUND_BUDDY_LEAVE)); purple_signal_connect(conv_handle, "received-im-msg", gnt_sound_handle, PURPLE_CALLBACK(im_msg_received_cb), GINT_TO_POINTER(PURPLE_SOUND_RECEIVE)); purple_signal_connect(conv_handle, "sent-im-msg", gnt_sound_handle, PURPLE_CALLBACK(im_msg_sent_cb), GINT_TO_POINTER(PURPLE_SOUND_SEND)); purple_signal_connect(conv_handle, "chat-buddy-joined", gnt_sound_handle, PURPLE_CALLBACK(chat_buddy_join_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_JOIN)); purple_signal_connect(conv_handle, "chat-buddy-left", gnt_sound_handle, PURPLE_CALLBACK(chat_buddy_left_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_LEAVE)); purple_signal_connect(conv_handle, "sent-chat-msg", gnt_sound_handle, PURPLE_CALLBACK(chat_msg_sent_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_YOU_SAY)); purple_signal_connect(conv_handle, "received-chat-msg", gnt_sound_handle, PURPLE_CALLBACK(chat_msg_received_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_SAY)); purple_signal_connect(conv_handle, "got-attention", gnt_sound_handle, PURPLE_CALLBACK(got_attention_cb), GINT_TO_POINTER(PURPLE_SOUND_GOT_ATTENTION)); update_profiles(); }