/************************************************************************** * Connect stuff **************************************************************************/ static void connect_cb(MsnServConn *servconn) { MsnSwitchBoard *swboard; MsnCmdProc *cmdproc; GaimAccount *account; cmdproc = servconn->cmdproc; g_return_if_fail(cmdproc != NULL); account = cmdproc->session->account; swboard = cmdproc->data; g_return_if_fail(swboard != NULL); if (msn_switchboard_is_invited(swboard)) { swboard->empty = FALSE; msn_cmdproc_send(cmdproc, "ANS", "%s %s %s", gaim_account_get_username(account), swboard->auth_key, swboard->session_id); } else { msn_cmdproc_send(cmdproc, "USR", "%s %s", gaim_account_get_username(account), swboard->auth_key); } }
static void sending_im_msg_cb(GaimAccount *account, char *recipient, char **buffer, void *data) { gaim_debug_misc("signals test", "sending-im-msg (%s, %s, %s)\n", gaim_account_get_username(account), recipient, *buffer); }
static char * gaim_log_get_log_dir(GaimLogType type, const char *name, GaimAccount *account) { GaimPlugin *prpl; GaimPluginProtocolInfo *prpl_info; const char *prpl_name; char *acct_name; const char *target; char *dir; prpl = gaim_find_prpl(gaim_account_get_protocol_id(account)); if (!prpl) return NULL; prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(prpl); prpl_name = prpl_info->list_icon(account, NULL); acct_name = g_strdup(gaim_escape_filename(gaim_normalize(account, gaim_account_get_username(account)))); if (type == GAIM_LOG_CHAT) { char *temp = g_strdup_printf("%s.chat", gaim_normalize(account, name)); target = gaim_escape_filename(temp); g_free(temp); } else if(type == GAIM_LOG_SYSTEM) { target = ".system"; } else { target = gaim_escape_filename(gaim_normalize(account, name)); } dir = g_build_filename(gaim_user_dir(), "logs", prpl_name, acct_name, target, NULL); g_free(acct_name); return dir; }
static void gaym_login_with_chat_key(GaimAccount * account) { GaimConnection *gc; struct gaym_conn *gaym; char *buf; const char *username = gaim_account_get_username(account); int err; gc = gaim_account_get_connection(account); gaym = gc->proto_data; buf = g_strdup_printf(_("Signon: %s"), username); gaim_connection_update_progress(gc, buf, 5, 6); g_free(buf); gaim_debug_misc("gaym", "Trying login to %s\n", gaym->server); err = gaim_proxy_connect(account, gaym->server, gaim_account_get_int(account, "port", IRC_DEFAULT_PORT), gaym_login_cb, gc); if (err || !account->gc) { gaim_connection_error(gc, _("Couldn't create socket")); gaim_debug_misc("gaym", "err: %d, account->gc: %x\n", err, account->gc); return; } }
static void ver_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd) { MsnSession *session; GaimAccount *account; gboolean protocol_supported = FALSE; char proto_str[8]; size_t i; session = cmdproc->session; account = session->account; g_snprintf(proto_str, sizeof(proto_str), "MSNP%d", session->protocol_ver); for (i = 1; i < cmd->param_count; i++) { if (!strcmp(cmd->params[i], proto_str)) { protocol_supported = TRUE; break; } } if (!protocol_supported) { msn_session_set_error(session, MSN_ERROR_UNSUPPORTED_PROTOCOL, NULL); return; } msn_cmdproc_send(cmdproc, "CVR", "0x0409 winnt 5.1 i386 MSNMSGR 6.0.0602 MSMSGS %s", gaim_account_get_username(account)); }
static void account_away_cb(GaimAccount *account, const char *state, const char *message, void *data) { gaim_debug_misc("signals test", "account-away (%s, %s, %s)\n", gaim_account_get_username(account), state, message); }
static void account_warned_cb(GaimAccount *account, const char *warner, int level, void *data) { gaim_debug_misc("signals test", "account-warned (%s, %s, %d)\n", gaim_account_get_username(account), warner, level); }
GaimAccount * gaim_accounts_find_ext(const char *name, const char *protocol_id, gboolean (*account_test)(const GaimAccount *account)) { GaimAccount *result = NULL; GList *l; char *who; if (name) who = g_strdup(gaim_normalize(NULL, name)); else who = NULL; for (l = gaim_accounts_get_all(); l != NULL; l = l->next) { GaimAccount *account = (GaimAccount *)l->data; if (who && strcmp(gaim_normalize(NULL, gaim_account_get_username(account)), who)) continue; if (protocol_id && strcmp(account->protocol_id, protocol_id)) continue; if (account_test && !account_test(account)) continue; result = account; break; } g_free(who); return result; }
static void received_im_msg_cb(GaimAccount *account, char *sender, char *buffer, int flags, void *data) { gaim_debug_misc("signals test", "received-im-msg (%s, %s, %s, %d)\n", gaim_account_get_username(account), sender, buffer, flags); }
static gboolean sending_chat_msg_cb(GaimAccount *account, char **buffer, int id, void *data) { gaim_debug_misc("signals test", "sending-chat-msg (%s, %s, %d)\n", gaim_account_get_username(account), *buffer, id); return FALSE; }
static void received_chat_msg_cb(GaimAccount *account, char *sender, char *buffer, GaimConversation *chat, void *data) { gaim_debug_misc("signals test", "received-chat-msg (%s, %s, %s, %s)\n", gaim_account_get_username(account), sender, buffer, gaim_conversation_get_name(chat)); }
static void chat_invited_cb(GaimAccount *account, const char *inviter, const char *room_name, const char *message, const GHashTable *components, void *data) { gaim_debug_misc("signals test", "chat-invited (%s, %s, %s, %s)\n", gaim_account_get_username(account), inviter, room_name, message); }
static gboolean writing_im_msg_cb(GaimAccount *account, GaimConversation *conv, char **buffer, void *data) { gaim_debug_misc("signals test", "writing-im-msg (%s, %s, %s)\n", gaim_account_get_username(account), gaim_conversation_get_name(conv), *buffer); return FALSE; }
static void irc_login(GaimAccount *account) { GaimConnection *gc; struct irc_conn *irc; char **userparts; const char *username = gaim_account_get_username(account); gc = gaim_account_get_connection(account); gc->flags |= GAIM_CONNECTION_NO_NEWLINES; if (strpbrk(username, " \t\v\r\n") != NULL) { gaim_connection_error(gc, _("IRC nicks may not contain whitespace")); return; } gc->proto_data = irc = g_new0(struct irc_conn, 1); irc->fd = -1; irc->account = account; irc->outbuf = gaim_circ_buffer_new(512); userparts = g_strsplit(username, "@", 2); gaim_connection_set_display_name(gc, userparts[0]); irc->server = g_strdup(userparts[1]); g_strfreev(userparts); irc->buddies = g_hash_table_new_full((GHashFunc)irc_nick_hash, (GEqualFunc)irc_nick_equal, NULL, (GDestroyNotify)irc_buddy_free); irc->cmds = g_hash_table_new(g_str_hash, g_str_equal); irc_cmd_table_build(irc); irc->msgs = g_hash_table_new(g_str_hash, g_str_equal); irc_msg_table_build(irc); gaim_connection_update_progress(gc, _("Connecting"), 1, 2); if (gaim_account_get_bool(account, "ssl", FALSE)) { if (gaim_ssl_is_supported()) { irc->gsc = gaim_ssl_connect(account, irc->server, gaim_account_get_int(account, "port", IRC_DEFAULT_SSL_PORT), irc_login_cb_ssl, irc_ssl_connect_failure, gc); } else { gaim_connection_error(gc, _("SSL support unavailable")); return; } } if (!irc->gsc) { if (gaim_proxy_connect(gc, account, irc->server, gaim_account_get_int(account, "port", IRC_DEFAULT_PORT), irc_login_cb, gc) == NULL) { gaim_connection_error(gc, _("Couldn't create socket")); return; } } }
static gboolean receiving_im_msg_cb(GaimAccount *account, char **sender, char **buffer, int *flags, void *data) { gaim_debug_misc("signals test", "receiving-im-msg (%s, %s, %s, %d)\n", gaim_account_get_username(account), *sender, *buffer, *flags); return FALSE; }
static void cvr_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd) { GaimAccount *account; account = cmdproc->session->account; msn_cmdproc_send(cmdproc, "USR", "TWN I %s", gaim_account_get_username(account)); }
void GaimChatMngr::ChatAddUsersCbk(GaimConversation *conv, GList *users, gboolean new_arrivals) { GList *l; GaimAccount *gAccount = gaim_conversation_get_account(conv); const char *gPrclId = gaim_account_get_protocol_id(gAccount); IMAccount *account = _accountMngr->FindIMAccount(gaim_account_get_username(gAccount), GaimIMPrcl::GetEnumIMProtocol(gPrclId)); mConvInfo_t *mConv = NULL; IMChatSession *chatSession = NULL; GaimIMChat *mChat = FindIMChat(*account); if (!mChat) LOG_FATAL("Can't find IMChat !"); mConv = (mConvInfo_t *) conv->ui_data; chatSession = (IMChatSession *) mConv->conv_session; for (l = users; l != NULL; l = l->next) { GaimConvChatBuddy *gCCBuddy = (GaimConvChatBuddy *) l->data; if (gCCBuddy && strcmp(gaim_account_get_username(gAccount), (char *) gCCBuddy->name)) { std::string buddy((char *) gCCBuddy->name); IMContact imContact(*account, buddy); if (chatSession->getIMContactSet().find(imContact) != chatSession->getIMContactSet().end()) { LOG_DEBUG("IMContact for " + imContact.getContactId() + " already in IMContactSet"); } else { ((IMContactSet &) chatSession->getIMContactSet()).insert(imContact); if (chatSession->getIMContactSet().size() == 1) mChat->newIMChatSessionCreatedEvent(*mChat, *chatSession); LOG_DEBUG("IMContact " + imContact.getContactId() + " added to IMContactSet"); } mChat->contactAddedEvent(*mChat, *chatSession, imContact); } } }
/* **************** IMWRAPPER/GAIM INTERFACE ****************** */ GaimIMChat *GaimChatMngr::FindIMChatByGaimConv(void *gConv) { GaimAccount *gAccount = gaim_conversation_get_account((GaimConversation *) gConv); const char *gPrclId = gaim_account_get_protocol_id(gAccount); IMAccount *account = _accountMngr->FindIMAccount(gaim_account_get_username(gAccount), GaimIMPrcl::GetEnumIMProtocol(gPrclId)); GaimIMChat *mChat = FindIMChat(*account); return mChat; }
static gboolean receiving_chat_msg_cb(GaimAccount *account, char **sender, char **buffer, GaimConversation *chat, void *data) { gaim_debug_misc("signals test", "receiving-chat-msg (%s, %s, %s, %s)\n", gaim_account_get_username(account), *sender, *buffer, gaim_conversation_get_name(chat)); return FALSE; }
static void gaim_pounces_write(FILE *fp, GaimPounce *pounce) { GaimAccount *pouncer; GaimPounceEvent events; char *pouncer_name; pouncer = gaim_pounce_get_pouncer(pounce); events = gaim_pounce_get_events(pounce); pouncer_name = g_markup_escape_text(gaim_account_get_username(pouncer), -1); fprintf(fp, " <pounce ui='%s'>\n", pounce->ui_type); fprintf(fp, " <account protocol='%s'>%s</account>\n", pouncer->protocol_id, pouncer_name); fprintf(fp, " <pouncee>%s</pouncee>\n", gaim_pounce_get_pouncee(pounce)); fprintf(fp, " <events>\n"); if (events & GAIM_POUNCE_SIGNON) fprintf(fp, " <event type='sign-on'/>\n"); if (events & GAIM_POUNCE_SIGNOFF) fprintf(fp, " <event type='sign-off'/>\n"); if (events & GAIM_POUNCE_AWAY) fprintf(fp, " <event type='away'/>\n"); if (events & GAIM_POUNCE_AWAY_RETURN) fprintf(fp, " <event type='return-from-away'/>\n"); if (events & GAIM_POUNCE_IDLE) fprintf(fp, " <event type='idle'/>\n"); if (events & GAIM_POUNCE_IDLE_RETURN) fprintf(fp, " <event type='return-from-idle'/>\n"); if (events & GAIM_POUNCE_TYPING) fprintf(fp, " <event type='start-typing'/>\n"); if (events & GAIM_POUNCE_TYPING_STOPPED) fprintf(fp, " <event type='stop-typing'/>\n"); fprintf(fp, " </events>\n"); fprintf(fp, " <actions>\n"); g_hash_table_foreach(pounce->actions, write_action_parameter_list, fp); fprintf(fp, " </actions>\n"); if (gaim_pounce_get_save(pounce)) fprintf(fp, " <save/>\n"); fprintf(fp, " </pounce>\n"); g_free(pouncer_name); }
void GaimChatMngr::ChatRemoveUsersCbk(GaimConversation *conv, GList *users) { GList *l; GaimAccount *gAccount = gaim_conversation_get_account(conv); const char *gPrclId = gaim_account_get_protocol_id(gAccount); IMAccount *account = _accountMngr->FindIMAccount(gaim_account_get_username(gAccount), GaimIMPrcl::GetEnumIMProtocol(gPrclId)); mConvInfo_t *mConv = NULL; IMChatSession *chatSession = NULL; GaimIMChat *mChat = FindIMChat(*account); if (!mChat) LOG_FATAL("Can't find IMChat !"); mConv = (mConvInfo_t *) conv->ui_data; chatSession = (IMChatSession *) mConv->conv_session; for (l = users; l != NULL; l = l->next) { if (strcmp(gaim_account_get_username(gAccount), (char *) l->data)) { std::string buddy((char *) l->data); IMContact imContact(*account, buddy); if (chatSession->getIMContactSet().find(imContact) == chatSession->getIMContactSet().end()) { LOG_ERROR("IMContact for " + imContact.getContactId() + " not in IMContactSet"); } else { LOG_DEBUG("IMContact " + imContact.getContactId() + " removed from IMContactSet"); mChat->contactRemovedEvent(*mChat, *chatSession, buddy); } } } }
void GaimChatMngr::CreateConversationCbk(GaimConversation *conv, bool userCreated) { GaimAccount *gAccount = gaim_conversation_get_account(conv); GaimConversationType chatType = gaim_conversation_get_type(conv); const char *gPrclId = gaim_account_get_protocol_id(gAccount); IMAccount *account = _accountMngr->FindIMAccount(gaim_account_get_username(gAccount), GaimIMPrcl::GetEnumIMProtocol(gPrclId)); GaimIMChat *mChat = FindIMChat(*account); mConvInfo_t *mConv; if (chatType == GAIM_CONV_TYPE_IM) { IMChatSession *chatSession = NULL; // Check if it's a jabber contact, and remove his ressource std::string contactId = cleanContactId(std::string(gaim_conversation_get_name(conv)), GaimIMPrcl::GetEnumIMProtocol(gPrclId)); IMContact imContact(*account, contactId); mConv = mChat->CreateChatSession(userCreated, *mChat); mConv->gaim_conv_session = conv; conv->ui_data = mConv; chatSession = (IMChatSession *) mConv->conv_session; ((IMContactSet &) chatSession->getIMContactSet()).insert(imContact); mChat->newIMChatSessionCreatedEvent(*mChat, *chatSession); mChat->contactAddedEvent(*mChat, *chatSession, imContact); } else if (chatType == GAIM_CONV_TYPE_CHAT) { int id = GetGaimConversationId(gaim_conversation_get_name(conv)); if ((mConv = mChat->FindChatStructById(id)) == NULL) { mConv = mChat->CreateChatSession(userCreated, *mChat); } if (mConv->gaim_conv_session) gaim_conversation_destroy((GaimConversation *)mConv->gaim_conv_session); mConv->gaim_conv_session = conv; conv->ui_data = mConv; } }
void gaim_connection_register(GaimConnection *gc) { GaimAccount *account; GaimConnectionUiOps *ops; GaimPluginProtocolInfo *prpl_info = NULL; g_return_if_fail(gc != NULL); gaim_debug(GAIM_DEBUG_INFO, "connection", "Registering. gc = %p\n", gc); ops = gaim_get_connection_ui_ops(); if (gc->prpl != NULL) prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl); else { gchar *message = g_strdup_printf(_("Missing protocol plugin for %s"), gaim_account_get_username(gaim_connection_get_account(gc))); gaim_debug(GAIM_DEBUG_ERROR, "connection", "Could not get prpl info for %p\n", gc); gaim_notify_error(NULL, _("Registration Error"), message, NULL); g_free(message); return; } account = gaim_connection_get_account(gc); if (gaim_connection_get_state(gc) != GAIM_DISCONNECTED) return; gaim_connection_set_state(gc, GAIM_CONNECTING); connections = g_list_append(connections, gc); gaim_signal_emit(gaim_connections_get_handle(), "signing-on", gc); /* set this so we don't auto-reconnect after registering */ gc->wants_to_die = TRUE; gaim_debug(GAIM_DEBUG_INFO, "connection", "Calling register_user\n"); prpl_info->register_user(account); }
void msn_show_sync_issue(MsnSession *session, const char *passport, const char *group_name) { GaimConnection *gc; GaimAccount *account; MsnAddRemData *data; char *msg, *reason; account = session->account; gc = gaim_account_get_connection(account); data = g_new0(MsnAddRemData, 1); data->who = g_strdup(passport); data->group = g_strdup(group_name); data->gc = gc; msg = g_strdup_printf(_("Buddy list synchronization issue in %s (%s)"), gaim_account_get_username(account), gaim_account_get_protocol_name(account)); if (group_name != NULL) { reason = g_strdup_printf(_("%s on the local list is " "inside the group \"%s\" but not on " "the server list. " "Do you want this buddy to be added?"), passport, group_name); } else { reason = g_strdup_printf(_("%s is on the local list but " "not on the server list. " "Do you want this buddy to be added?"), passport); } gaim_request_action(gc, NULL, msg, reason, GAIM_DEFAULT_ACTION_NONE, data, 2, _("Yes"), G_CALLBACK(msn_add_cb), _("No"), G_CALLBACK(msn_rem_cb)); g_free(reason); g_free(msg); }
/** * Write the given OdcFrame to a ByteStream and send it out * on the established PeerConnection. */ static void peer_odc_send(PeerConnection *conn, OdcFrame *frame) { GaimAccount *account; const char *username; size_t length; ByteStream bs; gaim_debug_info("oscar", "Outgoing ODC frame to %s with " "type=0x%04x, flags=0x%04x, payload length=%u\n", conn->sn, frame->type, frame->flags, frame->payload.len); account = gaim_connection_get_account(conn->od->gc); username = gaim_account_get_username(account); memcpy(frame->sn, username, strlen(username)); memcpy(frame->cookie, conn->cookie, 8); length = 76; byte_stream_new(&bs, length + frame->payload.len); byte_stream_putraw(&bs, conn->magic, 4); byte_stream_put16(&bs, length); byte_stream_put16(&bs, frame->type); byte_stream_put16(&bs, frame->subtype); byte_stream_put16(&bs, 0x0000); byte_stream_putraw(&bs, frame->cookie, 8); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, 0x0000); byte_stream_put32(&bs, frame->payload.len); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, frame->encoding); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, frame->flags); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, 0x0000); byte_stream_putraw(&bs, frame->sn, 32); byte_stream_putraw(&bs, frame->payload.data, frame->payload.len); peer_connection_send(conn, &bs); g_free(bs.data); }
static void group_error_helper(MsnSession *session, const char *msg, int group_id, int error) { GaimAccount *account; GaimConnection *gc; char *reason = NULL; char *title = NULL; account = session->account; gc = gaim_account_get_connection(account); if (error == 224) { if (group_id == 0) { return; } else { const char *group_name; group_name = msn_userlist_find_group_name(session->userlist, group_id); reason = g_strdup_printf(_("%s is not a valid group."), group_name); } } else { reason = g_strdup(_("Unknown error.")); } title = g_strdup_printf(_("%s on %s (%s)"), msg, gaim_account_get_username(account), gaim_account_get_protocol_name(account)); gaim_notify_error(gc, NULL, title, reason); g_free(title); g_free(reason); }
void GaimPresenceMngr::UpdateAccountStatus(GaimAccount *gAccount, GaimStatus *old, GaimStatus *newstatus) { GaimIMPresence *mIMPresence = NULL; const char *gPrclId = gaim_account_get_protocol_id(gAccount); IMAccount *account = _accountMngr->FindIMAccount(gaim_account_get_username(gAccount), GaimIMPrcl::GetEnumIMProtocol(gPrclId)); if (!account) return; mIMPresence = FindIMPresence(*account); if (!mIMPresence) { LOG_FATAL("IMPresence not found!"); return; } mIMPresence->myPresenceStatusEvent(*mIMPresence, EnumPresenceState::MyPresenceStatusOk, ""); }
static void authorize_add_cb(struct _jabber_add_permit *jap) { if(g_list_find(gaim_connections_get_all(), jap->gc)) { GaimBuddy *buddy = NULL; jabber_presence_subscription_set(jap->gc->proto_data, jap->who, "subscribed"); buddy = gaim_find_buddy(jap->gc->account, jap->who); if (buddy) { JabberBuddy *jb = NULL; jb = jabber_buddy_find(jap->js, jap->who, TRUE); if ((jb->subscription & JABBER_SUB_TO) == 0) { char *buffer = NULL; struct _jabber_add_permit *jap2 = g_new0(struct _jabber_add_permit, 1); jap2->gc = jap->gc; jap2->who = g_strdup(jap->who); /* XXX: Tidy this up when not in string freeze */ buffer = g_strdup_printf(_("%s%s%s%s has made %s his or her buddy%s%s%s"), jap->who, "", "", "", (gaim_connection_get_display_name(jap->gc) != NULL ? gaim_connection_get_display_name(jap->gc) : gaim_account_get_username(jap->gc->account)), ".", "", _("\n\nDo you wish to add him or her to your buddy list?")); gaim_request_action(NULL, NULL, _("Add buddy to your list?"), buffer, GAIM_DEFAULT_ACTION_NONE, jap2, 2, _("Add"), G_CALLBACK(add_user_cb), _("Cancel"), G_CALLBACK(free_jabber_add_permit)); g_free(buffer); } else
void GaimChatMngr::WriteConvCbk(GaimConversation *conv, const char *name, const char *alias, const char *message, GaimMessageFlags flags, time_t mtime) { if ((flags & GAIM_MESSAGE_RECV)) { mConvInfo_t *mConv = (mConvInfo_t *)conv->ui_data; GaimIMChat *mIMChat = FindIMChatByGaimConv(conv); // Prevent from double message during a chat session if (strcmp(gaim_account_get_username(conv->account), name) == 0) return; // Check if it's a jabber contact, and remove his ressource GaimAccount *gAccount = gaim_conversation_get_account(conv); const char *gPrclId = gaim_account_get_protocol_id(gAccount); std::string contactId = cleanContactId(name, GaimIMPrcl::GetEnumIMProtocol(gPrclId)); mIMChat->messageReceivedEvent(*mIMChat, *((IMChatSession *)(mConv->conv_session)), contactId, std::string(message)); } }
void gaim_connection_connect(GaimConnection *gc) { GaimAccount *account; GaimConnectionUiOps *ops; GaimPluginProtocolInfo *prpl_info = NULL; g_return_if_fail(gc != NULL); gaim_debug(GAIM_DEBUG_INFO, "connection", "Connecting. gc = %p\n", gc); ops = gaim_get_connection_ui_ops(); if (gc->prpl != NULL) prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl); else { gchar *message = g_strdup_printf(_("Missing protocol plugin for %s"), gaim_account_get_username(gaim_connection_get_account(gc))); gaim_debug(GAIM_DEBUG_ERROR, "connection", "Could not get prpl info for %p\n", gc); gaim_notify_error(NULL, _("Connection Error"), message, NULL); g_free(message); return; } account = gaim_connection_get_account(gc); if (gaim_connection_get_state(gc) != GAIM_DISCONNECTED) return; if (!(prpl_info->options & OPT_PROTO_NO_PASSWORD) && !(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL) && gaim_account_get_password(account) == NULL) { gchar *primary; gchar *escaped; const gchar *username = gaim_account_get_username(account); gaim_debug(GAIM_DEBUG_INFO, "connection", "Requesting password\n"); gaim_connection_destroy(gc); escaped = g_markup_escape_text(username, strlen(username)); primary = g_strdup_printf(_("Enter password for %s"), escaped); gaim_request_input(gc, NULL, primary, NULL, NULL, FALSE, TRUE, _("OK"), G_CALLBACK(request_pass_ok_cb), _("Cancel"), NULL, account); g_free(primary); g_free(escaped); return; } gaim_connection_set_state(gc, GAIM_CONNECTING); connections = g_list_append(connections, gc); gaim_signal_emit(gaim_connections_get_handle(), "signing-on", gc); gaim_debug(GAIM_DEBUG_INFO, "connection", "Calling serv_login\n"); serv_login(account); }