static void discover_status(PurpleConnection *from, PurpleConnection *to, gpointer userdata) { const char *from_username = purple_account_get_username(purple_connection_get_account(from)); const char *to_username = purple_account_get_username(purple_connection_get_account(to)); if (purple_blist_find_buddy(purple_connection_get_account(from), to_username)) { PurpleStatus *status = purple_account_get_active_status(purple_connection_get_account(to)); const char *status_id = purple_status_get_id(status); const char *message = purple_status_get_attr_string(status, "message"); if (!strcmp(status_id, NULL_STATUS_ONLINE) || !strcmp(status_id, NULL_STATUS_AWAY) || !strcmp(status_id, NULL_STATUS_OFFLINE)) { purple_debug_info("nullprpl", "%s sees that %s is %s: %s\n", from_username, to_username, status_id, message); purple_prpl_got_user_status(purple_connection_get_account(from), to_username, status_id, (message) ? "message" : NULL, message, NULL); } else { purple_debug_error("nullprpl", "%s's buddy %s has an unknown status: %s, %s", from_username, to_username, status_id, message); } } }
static void signing_on_cb(PurpleConnection *gc) { if (!console) return; gtk_combo_box_append_text(GTK_COMBO_BOX(console->dropdown), purple_account_get_username(gc->account)); console->accounts = g_list_append(console->accounts, gc); console->count++; if (console->count == 1) console->gc = gc; else gtk_widget_show_all(console->hbox); }
static PurpleRoomlist *nullprpl_roomlist_get_list(PurpleConnection *gc) { const char *username = purple_account_get_username(purple_connection_get_account(gc)); PurpleRoomlist *roomlist = purple_roomlist_new(purple_connection_get_account(gc)); GList *fields = NULL; PurpleRoomlistField *field; GList *chats; GList *seen_ids = NULL; purple_debug_info("nullprpl", "%s asks for room list; returning:\n", username); /* set up the room list */ field = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_STRING, "room", "room", TRUE /* hidden */); fields = g_list_append(fields, field); field = purple_roomlist_field_new(PURPLE_ROOMLIST_FIELD_INT, "Id", "Id", FALSE); fields = g_list_append(fields, field); purple_roomlist_set_fields(roomlist, fields); /* add each chat room. the chat ids are cached in seen_ids so that each room * is only returned once, even if multiple users are in it. */ for (chats = purple_conversations_get_chats(); chats; chats = g_list_next(chats)) { PurpleChatConversation *chat = PURPLE_CHAT_CONVERSATION(chats->data); PurpleRoomlistRoom *room; const char *name = purple_conversation_get_name(PURPLE_CONVERSATION(chat)); int id = purple_chat_conversation_get_id(chat); /* have we already added this room? */ if (g_list_find_custom(seen_ids, name, (GCompareFunc)strcmp)) continue; /* yes! try the next one. */ /* This cast is OK because this list is only staying around for the life * of this function and none of the conversations are being deleted * in that timespan. */ seen_ids = g_list_prepend(seen_ids, (char *)name); /* no, it's new. */ purple_debug_info("nullprpl", "%s (%d), ", name, id); room = purple_roomlist_room_new(PURPLE_ROOMLIST_ROOMTYPE_ROOM, name, NULL); purple_roomlist_room_add_field(roomlist, room, name); purple_roomlist_room_add_field(roomlist, room, &id); purple_roomlist_room_add(roomlist, room); } g_list_free(seen_ids); purple_timeout_add(1 /* ms */, nullprpl_finish_get_roomlist, g_object_ref(roomlist)); return roomlist; }
xmlnode * _h_elim_set_icon ( const char *name , const char *id , SEXP_VALUE *args , gpointer data ) { ASSERT_ALISTP( args, id, name ); elim_ping(); const char *aname = ALIST_VAL_STR ( args, "account-name" ); const char *proto = ALIST_VAL_STR ( args, "im-protocol" ); gpointer auid = ALIST_VAL_PTR ( args, "account-uid" ); const char *file = ALIST_VAL_STR ( args, "icon-file" ); GString *img = ALIST_VAL_DATA( args, "icon-data" ); gchar *bytes = NULL; gsize len = 0; gpointer set = NULL; PurpleAccount *acct = auid ? find_acct_by_uid( auid ) : purple_accounts_find( aname, proto ); if( !acct ) { sexp_val_free( args ); return response_error( ENXIO, id, name, "unknown account" ); } if( !img && file && *file ) { g_file_get_contents( file, &bytes, &len, NULL ); } else if( img ) { bytes = g_memdup( img->str, img->len ); len = img->len; } // the imgstore owns `bytes' after this, don't free it: set = purple_buddy_icons_set_account_icon( acct, (guchar *)bytes, len ); xmlnode *rval = xnode_new( "alist" ); AL_PTR ( rval, "account-uid" , acct ); AL_STR ( rval, "account-name", purple_account_get_username ( acct ) ); AL_STR ( rval, "im-protocol" , purple_account_get_protocol_id( acct ) ); AL_BOOL( rval, "has-icon" , set ? TRUE : FALSE ); sexp_val_free( args ); return response_value( 0, id, name, rval ); }
static void set_account_idle(PurpleAccount *account, int time_idle) { PurplePresence *presence; presence = purple_account_get_presence(account); if (purple_presence_is_idle(presence)) /* This account is already idle! */ return; purple_debug_info("idle", "Setting %s idle %d seconds\n", purple_account_get_username(account), time_idle); purple_presence_set_idle(presence, TRUE, time(NULL) - time_idle); idled_accts = g_list_prepend(idled_accts, account); }
qq_account* qq_account_new(PurpleAccount* account) { qq_account* ac = g_malloc0(sizeof(qq_account)); ac->account = account; ac->magic = QQ_MAGIC; ac->flag = 0; // this is auto increment sized array . so don't worry about it. const char* username = purple_account_get_username(account); const char* password = purple_account_get_password(account); ac->qq = lwqq_client_new(username, password); ac->js = lwqq_js_init(); ac->sys_log = purple_log_new(PURPLE_LOG_SYSTEM, "system", account, NULL, time(NULL), NULL); // add ~/.config/lwqq into search path lwqq_util_add_path(lwdb_get_config_dir()); #ifdef WITH_MOZJS lwqq_hash_add_entry(ac->qq, "hash_local", (LwqqHashFunc)hash_with_local_file, ac->js); lwqq_hash_add_entry(ac->qq, "hash_url", (LwqqHashFunc)hash_with_remote_file, ac->js); lwqq_hash_add_entry(ac->qq, "hash_db", (LwqqHashFunc)hash_with_db_url, ac); #endif ac->font.family = s_strdup("宋体"); ac->font.size = 12; ac->font.style = 0; // lwqq_async_set(ac->qq,1); #if QQ_USE_FAST_INDEX ac->qq->find_buddy_by_uin = find_buddy_by_uin; ac->qq->find_buddy_by_qqnumber = find_buddy_by_qqnumber; ac->fast_index.uin_index = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); ac->fast_index.qqnum_index = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); #endif ac->qq->dispatch = qq_dispatch; char cookie[256]; snprintf(cookie, sizeof(cookie), "%s/%s.cookie", lwdb_get_config_dir(), username); LwqqExtension* ext = lwqq_make_cookie_extension(ac->qq, cookie); ext->init(ac->qq, ext); return ac; }
static void set_account_unidle(PurpleAccount *account) { PurplePresence *presence; presence = purple_account_get_presence(account); idled_accts = g_list_remove(idled_accts, account); if (!purple_presence_is_idle(presence)) /* This account is already unidle! */ return; purple_debug_info("idle", "Setting %s unidle\n", purple_account_get_username(account)); purple_presence_set_idle(presence, FALSE, 0); }
void twitter_send_request(PurpleAccount *account, gboolean post, const char *url, const char *query_string, TwitterSendRequestSuccessFunc success_callback, TwitterSendRequestErrorFunc error_callback, gpointer data) { gchar *request; const char *pass = purple_connection_get_password(purple_account_get_connection(account)); const char *sn = purple_account_get_username(account); char *auth_text = g_strdup_printf("%s:%s", sn, pass); char *auth_text_b64 = purple_base64_encode((guchar *) auth_text, strlen(auth_text)); gboolean use_https = purple_account_get_bool(account, "use_https", FALSE) && purple_ssl_is_supported(); char *host = "twitter.com"; TwitterSendRequestData *request_data = g_new0(TwitterSendRequestData, 1); char *full_url = g_strdup_printf("%s://%s%s", use_https ? "https" : "http", host, url); request_data->account = account; request_data->user_data = data; request_data->success_func = success_callback; request_data->error_func = error_callback; g_free(auth_text); request = g_strdup_printf( "%s %s%s%s HTTP/1.0\r\n" "User-Agent: Mozilla/4.0 (compatible; MSIE 5.5)\r\n" "Host: %s\r\n" "Authorization: Basic %s\r\n" "Content-Length: %d\r\n\r\n" "%s", post ? "POST" : "GET", full_url, (!post && query_string ? "?" : ""), (!post && query_string ? query_string : ""), host, auth_text_b64, query_string && post ? strlen(query_string) : 0, query_string && post ? query_string : ""); g_free(auth_text_b64); purple_util_fetch_url_request(full_url, TRUE, "Mozilla/4.0 (compatible; MSIE 5.5)", TRUE, request, FALSE, twitter_send_request_cb, request_data); g_free(full_url); g_free(request); }
xmlnode * _h_elim_buddy_info ( const char *name , const char *id , SEXP_VALUE *args , gpointer data ) { ASSERT_ALISTP( args, id, name ); PurpleAccount *acct = NULL; PurpleConnection *conn = NULL; gpointer a_uid = NULL; gpointer b_uid = ALIST_VAL_PTR( args, "bnode-uid" ); PurpleBlistNode *bnode = find_blist_node_by_uid( b_uid, TRUE ); PurpleBlistNodeType bt = PURPLE_BLIST_OTHER_NODE; if( !bnode ) HANDLER_FAIL( args, id, name, ENOENT, "no such buddy" ); bt = purple_blist_node_get_type( bnode ); switch( bt ) { case PURPLE_BLIST_BUDDY_NODE: a_uid = purple_buddy_get_account( (PurpleBuddy *)bnode ); break; default: HANDLER_FAIL( args, id, name, EINVAL, "unsupported buddy type" ); break; } FETCH_ACCOUNT( args, id, name, acct, a_uid ); conn = purple_account_get_connection( acct ); if( !conn ) HANDLER_FAIL( args, id, name, ENXIO, "account disconnected" ); xmlnode *rval = xnode_new( "alist" ); AL_PTR ( rval, "bnode-uid" , bnode ); AL_PTR ( rval, "account-uid" , acct ); AL_STR ( rval, "account-name", purple_account_get_username ( acct ) ); AL_STR ( rval, "im-protocol" , purple_account_get_protocol_id( acct ) ); serv_get_info( conn, purple_buddy_get_name( (PurpleBuddy *)bnode ) ); sexp_val_free( args ); return response_value( 0, id, name, rval ); }
static void insert_cap_failure(CapStatistics *stats) { gchar *buddy_name = stats->buddy->name; const gchar *protocol_id = purple_account_get_protocol_id(stats->buddy->account); const gchar *account_id = purple_account_get_username(stats->buddy->account); const gchar *status_id = (stats->last_message_status_id) ? stats->last_message_status_id : purple_status_get_id(get_status_for(stats->buddy)); struct tm *current_time = localtime(&stats->last_message); int minute = current_time->tm_min + current_time->tm_hour * 60; insert_cap_msg_count_failed(buddy_name, account_id, protocol_id, minute); insert_cap_status_count_failed(buddy_name, account_id, protocol_id, status_id); stats->last_message = -1; stats->last_message_status_id = NULL; }
void msn_show_sync_issue(MsnSession *session, const char *passport, const char *group_name) { PurpleConnection *gc; PurpleAccount *account; MsnAddRemData *data; char *msg, *reason; account = session->account; gc = purple_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)"), purple_account_get_username(account), purple_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); } purple_request_action(gc, NULL, msg, reason, PURPLE_DEFAULT_ACTION_NONE, purple_connection_get_account(gc), data->who, NULL, data, 2, _("Yes"), G_CALLBACK(msn_add_cb), _("No"), G_CALLBACK(msn_rem_cb)); g_free(reason); g_free(msg); }
static void tgprpl_login (PurpleAccount * acct) { debug ("tgprpl_login()\n"); PurpleConnection *gc = purple_account_get_connection(acct); char const *username = purple_account_get_username(acct); struct tgl_state *TLS = tgl_state_alloc (); const char *dir = config_dir; struct passwd *pw = getpwuid(getuid()); size_t len = strlen (dir) + strlen (pw->pw_dir) + 2 + strlen (username); TLS->base_path = malloc (len); snprintf (TLS->base_path, len, "%s/%s/%s", pw->pw_dir, dir, username); debug ("base configuration path: '%s'", TLS->base_path); g_mkdir_with_parents(TLS->base_path, 0700); len += strlen ("/downloads"); char *ddir = malloc (len); sprintf (ddir, "%s/downloads", TLS->base_path); tgl_set_download_directory (TLS, ddir); g_mkdir_with_parents(ddir, 0700); free (ddir); tgl_set_verbosity (TLS, 4); tgl_set_rsa_key (TLS, pk_path); // create handle to store additional info for libpurple in // the new telegram instance telegram_conn *conn = g_new0(telegram_conn, 1); conn->TLS = TLS; conn->gc = gc; conn->pa = acct; conn->new_messages = g_queue_new (); conn->joining_chats = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); purple_connection_set_protocol_data (gc, conn); tgl_set_ev_base (TLS, conn); tgl_set_net_methods (TLS, &tgp_conn_methods); tgl_set_timer_methods (TLS, &tgp_timers); tgl_set_callback (TLS, &tgp_callback); tgl_register_app_id (TLS, TGP_APP_ID, TGP_APP_HASH); tgl_init (TLS); purple_connection_set_state (conn->gc, PURPLE_CONNECTING); telegram_login (TLS); }
/*------------------------------------------------------------------------ * Create a new mxit session object * * @return The MXit session object */ static struct MXitSession* mxit_create_object( PurpleAccount* account ) { PurpleConnection* con = purple_account_get_connection( account ); struct MXitSession* session = NULL; /* currently the wapsite does not handle a '+' in front of the username (mxitid) so we just strip it */ { const char* username = purple_account_get_username( account ); if ( username[0] == '+' ) { char* fixed = g_strdup( &username[1] ); purple_account_set_username( account, fixed ); g_free( fixed ); } } session = g_new0( struct MXitSession, 1 ); session->con = con; session->acc = account; /* configure the connection (reference: "libpurple/connection.h") */ purple_connection_set_protocol_data( con, session ); purple_connection_set_flags( con, PURPLE_CONNECTION_FLAG_NO_BGCOLOR | PURPLE_CONNECTION_FLAG_NO_URLDESC | PURPLE_CONNECTION_FLAG_HTML | PURPLE_CONNECTION_FLAG_SUPPORT_MOODS ); /* configure the session (reference: "libpurple/account.h") */ g_strlcpy( session->server, purple_account_get_string( account, MXIT_CONFIG_SERVER_ADDR, DEFAULT_SERVER ), sizeof( session->server ) ); g_strlcpy( session->http_server, purple_account_get_string( account, MXIT_CONFIG_HTTPSERVER, DEFAULT_HTTP_SERVER ), sizeof( session->http_server ) ); session->port = purple_account_get_int( account, MXIT_CONFIG_SERVER_PORT, DEFAULT_PORT ); g_strlcpy( session->distcode, purple_account_get_string( account, MXIT_CONFIG_DISTCODE, "" ), sizeof( session->distcode ) ); g_strlcpy( session->clientkey, purple_account_get_string( account, MXIT_CONFIG_CLIENTKEY, "" ), sizeof( session->clientkey ) ); g_strlcpy( session->dialcode, purple_account_get_string( account, MXIT_CONFIG_DIALCODE, "" ), sizeof( session->dialcode ) ); session->http = purple_account_get_bool( account, MXIT_CONFIG_USE_HTTP, FALSE ); session->iimages = g_hash_table_new( g_str_hash, g_str_equal ); session->rx_state = RX_STATE_RLEN; session->http_interval = MXIT_HTTP_POLL_MIN; session->http_last_poll = mxit_now_milli(); session->async_http_reqs = purple_http_connection_set_new(); return session; }
static void set_chat_topic_fn(PurpleChatConversation *from, PurpleChatConversation *to, int id, const char *room, gpointer userdata) { const char *topic = (const char *)userdata; const char *username = purple_account_get_username(purple_conversation_get_account(PURPLE_CONVERSATION(from))); char *msg; purple_chat_conversation_set_topic(to, username, topic); if (topic && *topic) msg = g_strdup_printf(_("%s sets topic to: %s"), username, topic); else msg = g_strdup_printf(_("%s clears topic"), username); purple_conversation_write_message(PURPLE_CONVERSATION(to), username, msg, PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG, time(NULL)); g_free(msg); }
static void connection_error_cb(PurpleConnection *gc, PurpleConnectionError err, const gchar *desc, void *data) { char* growl_msg; PurpleAccount* account = purple_connection_get_account(gc); const gchar *username = purple_account_get_username(account); int len = s_strlen((char*)desc) + s_strlen((char*)username) + 2 ; DEBUG_MSG("connection_error_cb\n"); growl_msg = malloc( len); g_snprintf(growl_msg, len, "%s\n%s", desc, username); gntp_notify("connection-error", NULL, "Connection Error", growl_msg, NULL); free(growl_msg); }
int main (int argc, char **argv) { GList *alist, *node; purple_init(); alist = purple_accounts_get_all(); for (node = alist; node != NULL; node = node->next) { PurpleAccount *account = (PurpleAccount*) node->data; char *name = purple_account_get_username(account); g_print("Name: %s\n", name); g_free(name); } g_list_free(alist); return 0; }
void PurpleContactListMngr::UpdateBuddy(PurpleBuddyList *list, PurpleBuddy *gBuddy) { IMAccount *account = NULL; PurpleAccount *gAccount = purple_buddy_get_account(gBuddy); PurplePresence *gPresence = purple_buddy_get_presence(gBuddy); const char *gPrclId = purple_account_get_protocol_id(gAccount); account = _accountMngr->FindIMAccount(purple_account_get_username(gAccount), PurpleIMPrcl::GetEnumIMProtocol(gPrclId)); if (account) { PurpleIMContactList *mIMBList = FindIMContactList(*account); PurpleIMPresence *mIMPresence = _presenceMngr->FindIMPresence(*account); if (mIMBList) { const char * groupName = FindBuddyGroup(gBuddy); if (groupName) { mIMBList->contactMovedEvent(*mIMBList, groupName, purple_buddy_get_name(gBuddy)); } } if (mIMPresence) { const char* buddy_alias = gBuddy->server_alias && *gBuddy->server_alias ? gBuddy->server_alias : gBuddy->alias; const char* statusMessage = PurpleIMPresence::getPurpleBuddyStatusMessage(gBuddy); const char* gPresenceId = PurpleIMPresence::getPurplePresenceId(gPresence); //VOXOX - JRT - 2009.07.20 - COE in this method. Is there a way to alert libpurple that we are quitting? //VOXOX - JRT - 2009.09.21 - Still here. Let's see if we can catch problem in the parameters. EnumPresenceState::PresenceState presenceState = PurplePreState::GetPresenceState(gPresenceId); std::string alias = !buddy_alias ? String::null : buddy_alias; std::string statusMsg = !statusMessage ? String::null : statusMessage; const char* from = purple_buddy_get_name(gBuddy); mIMPresence->presenceStateChangedEvent(*mIMPresence, presenceState, alias, statusMsg, from ); } } }
void msn_session_finish_login(MsnSession *session) { PurpleAccount *account; PurpleConnection *gc; PurpleStoredImage *img; const char *passport; if (session->logged_in) { /* We are probably here because of a mid-session notification server XFR * We must send a CHG now, otherwise the servers default to invisible, * and prevent things happening, like sending IMs */ msn_change_status(session); return; } account = session->account; gc = purple_account_get_connection(account); img = purple_buddy_icons_find_account_icon(session->account); msn_user_set_buddy_icon(session->user, img); purple_imgstore_unref(img); session->logged_in = TRUE; msn_change_status(session); purple_connection_set_state(gc, PURPLE_CONNECTED); /* Sync users */ msn_session_sync_users(session); /* It seems that some accounts that haven't accessed hotmail for a while * and @msn.com accounts don't automatically get the initial email * notification so we always request it on login */ passport = purple_normalize(account, purple_account_get_username(account)); if ((strstr(passport, "@hotmail.") != NULL) || (strstr(passport, "@msn.com") != NULL)) { msn_cmdproc_send(session->notification->cmdproc, "URL", "%s", "INBOX"); } }
static void nullprpl_set_chat_topic(PurpleConnection *gc, int id, const char *topic) { PurpleChatConversation *chat = purple_conversations_find_chat(gc, id); const char *last_topic; if (!chat) return; purple_debug_info("nullprpl", "%s sets topic of chat room '%s' to '%s'\n", purple_account_get_username(purple_connection_get_account(gc)), purple_conversation_get_name(PURPLE_CONVERSATION(chat)), topic); last_topic = purple_chat_conversation_get_topic(chat); if ((!topic && !last_topic) || (topic && last_topic && !strcmp(topic, last_topic))) return; /* topic is unchanged, this is a noop */ foreach_gc_in_chat(set_chat_topic_fn, gc, id, (gpointer)topic); }
void msn_request_user_display(MsnUser *user) { PurpleAccount *account; MsnSession *session; MsnSlpLink *slplink; MsnObject *obj; const char *info; session = user->userlist->session; account = session->account; slplink = msn_session_get_slplink(session, user->passport); obj = msn_user_get_object(user); info = msn_object_get_sha1(obj); if (g_ascii_strcasecmp(user->passport, purple_account_get_username(account))) { const char *url = msn_object_get_url1(obj); if (url) { PurpleHttpRequest *req; MsnFetchUserDisplayData *data = g_new0(MsnFetchUserDisplayData, 1); data->session = session; data->remote_user = user->passport; data->sha1 = info; req = purple_http_request_new(url); purple_http_request_set_max_len(req, 200*1024); purple_http_connection_set_add(session->http_reqs, purple_http_request(NULL, req, fetched_user_display, data)); purple_http_request_unref(req); } else { msn_slplink_request_object(slplink, info, got_user_display, end_user_display, obj); } } else request_own_user_display(user); }
MsnSession * msn_session_new(PurpleAccount *account) { MsnSession *session; g_return_val_if_fail(account != NULL, NULL); session = g_new0(MsnSession, 1); session->account = account; session->notification = msn_notification_new(session); session->userlist = msn_userlist_new(session); session->user = msn_user_new(session->userlist, purple_account_get_username(account), NULL); session->protocol_ver = 9; return session; }
static void _elim_notify_added ( PurpleAccount *account , const char *remote_user, const char *id , const char *alias , const char *message ) { xmlnode *alist = xnode_new( "alist" ); char *ID = new_elim_id(); fprintf( stderr, "(_elim_notify_added)\n" ); AL_STR( alist, "user" , remote_user ); AL_STR( alist, "alias" , alias ); AL_STR( alist, "message" , message ); AL_PTR( alist, "account-uid" , account ); AL_STR( alist, "account-name" , purple_account_get_username ( account ) ); AL_STR( alist, "im-protocol" , purple_account_get_protocol_id( account ) ); xmlnode *mcall = func_call( "elim-account-notify-added", ID, alist ); g_free( ID ); add_outbound_sexp( mcall ); }
static void ggp_avatar_own_got_token(PurpleConnection *gc, const gchar *token, gpointer _img) { PurpleHttpRequest *req; PurpleImage *img = _img; ggp_avatar_own_data *own_data = ggp_avatar_get_avdata(gc)->own_data; gchar *img_data, *img_data_e, *request_data; PurpleAccount *account = purple_connection_get_account(gc); uin_t uin = ggp_str_to_uin(purple_account_get_username(account)); if (img != own_data->img) { purple_debug_warning("gg", "ggp_avatar_own_got_token: " "avatar was changed in meantime\n"); return; } own_data->img = NULL; img_data = purple_base64_encode(purple_image_get_data(img), purple_image_get_size(img)); img_data_e = g_uri_escape_string(img_data, NULL, FALSE); g_free(img_data); request_data = g_strdup_printf("uin=%d&photo=%s", uin, img_data_e); g_free(img_data_e); purple_debug_misc("gg", "ggp_avatar_own_got_token: " "uploading new avatar...\n"); req = purple_http_request_new("http://avatars.nowe.gg/upload"); purple_http_request_set_max_len(req, GGP_AVATAR_RESPONSE_MAX); purple_http_request_set_method(req, "POST"); purple_http_request_header_set(req, "Authorization", token); purple_http_request_header_set(req, "From", "avatars to avatars"); purple_http_request_header_set(req, "Content-Type", "application/x-www-form-urlencoded"); purple_http_request_set_contents(req, request_data, -1); purple_http_request(gc, req, ggp_avatar_own_sent, NULL); purple_http_request_unref(req); g_free(request_data); }
static void connect_cb(MsnServConn *servconn) { MsnSwitchBoard *swboard; MsnTransaction *trans; MsnCmdProc *cmdproc; PurpleAccount *account; char *username; cmdproc = servconn->cmdproc; g_return_if_fail(cmdproc != NULL); account = cmdproc->session->account; swboard = cmdproc->data; g_return_if_fail(swboard != NULL); username = g_strdup_printf("%s;{%s}", purple_account_get_username(account), servconn->session->guid); if (msn_switchboard_is_invited(swboard)) { swboard->empty = FALSE; trans = msn_transaction_new(cmdproc, "ANS", "%s %s %s", username, swboard->auth_key, swboard->session_id); } else { trans = msn_transaction_new(cmdproc, "USR", "%s %s", username, swboard->auth_key); } msn_transaction_set_error_cb(trans, ans_usr_error); msn_transaction_set_data(trans, swboard); msn_cmdproc_send_trans(cmdproc, trans); g_free(username); }
static int nullprpl_chat_send(PurpleConnection *gc, int id, const char *message, PurpleMessageFlags flags) { const char *username = purple_account_get_username(purple_connection_get_account(gc)); PurpleChatConversation *chat = purple_conversations_find_chat(gc, id); if (chat) { purple_debug_info("nullprpl", "%s is sending message to chat room %s: %s\n", username, purple_conversation_get_name(PURPLE_CONVERSATION(chat)), message); /* send message to everyone in the chat room */ foreach_gc_in_chat(receive_chat_message, gc, id, (gpointer)message); return 0; } else { purple_debug_info("nullprpl", "tried to send message from %s to chat room #%d: %s\n" "but couldn't find chat room", username, id, message); return -1; } }
void on_ready (struct tgl_state *TLS) { debug ("on_ready().\n"); telegram_conn *conn = TLS->ev_base; purple_connection_set_state(conn->gc, PURPLE_CONNECTED); purple_connection_set_display_name(conn->gc, purple_account_get_username(conn->pa)); purple_blist_add_account(conn->pa); tggroup = purple_find_group("Telegram"); if (tggroup == NULL) { debug ("PurpleGroup = NULL, creating"); tggroup = purple_group_new ("Telegram"); purple_blist_add_group (tggroup, NULL); } debug ("seq = %d, pts = %d\n", TLS->seq, TLS->pts); tgl_do_get_difference (TLS, 0, 0, 0); tgl_do_get_dialog_list (TLS, 0, 0); tgl_do_update_contact_list (TLS, 0, 0); conn->timer = purple_timeout_add (5000, queries_timerfunc, conn); }
void PurpleContactListMngr::NewBuddyAdded(PurpleBuddy *gBuddy) { PurpleAccount *gAccount = purple_buddy_get_account(gBuddy); const char *gPrclId = purple_account_get_protocol_id(gAccount); IMAccount *account = _accountMngr->FindIMAccount(purple_account_get_username(gAccount), PurpleIMPrcl::GetEnumIMProtocol(gPrclId)); if (account == NULL) return; PurpleIMContactList *mIMContactList = FindIMContactList(*account); if (mIMContactList) { const char *groupName = FindBuddyGroup(gBuddy); if (groupName) { mIMContactList->newContactAddedEvent(*mIMContactList, groupName, purple_buddy_get_name(gBuddy)); } } }
static void cb_custom_edited(GtkCellRendererText *renderer, char *path, char *str, gpointer data) { GtkTreeIter iter; GtkTreeModel *model = (GtkTreeModel*) data; if (gtk_tree_model_get_iter_from_string(model, &iter, path)) { PurpleAccount *account; GValue value; memset(&value, 0, sizeof(value)); gtk_tree_model_get_value(model, &iter, 5, &value); assert(G_VALUE_HOLDS_POINTER(&value)); account = g_value_get_pointer(&value); g_value_unset(&value); char pref[STRLEN]; build_pref(pref, PREF_CUSTOM_FORMAT, purple_account_get_username(account), purple_account_get_protocol_name(account)); gtk_list_store_set(GTK_LIST_STORE(model), &iter, 2, str, -1); purple_prefs_set_string(pref, str); } }
static void _elim_conv_args ( xmlnode *alist, PurpleConversation *conv ) { PurpleAccount *acct = purple_conversation_get_account( conv ); const char *aname = purple_account_get_username ( acct ); const char *proto = purple_account_get_protocol_id ( acct ); const char *title = purple_conversation_get_title ( conv ); const char *cname = purple_conversation_get_name ( conv ); PurpleConnectionFlags cflag = purple_conversation_get_features( conv ); PurpleConversationType ctype = purple_conversation_get_type ( conv ); fprintf( stderr, "(_elim_conv_args)\n" ); AL_STR ( alist, "account-name" , aname ); AL_STR ( alist, "im-protocol" , proto ); AL_PTR ( alist, "account-uid" , acct ); AL_PTR ( alist, "conv-uid" , conv ); AL_STR ( alist, "conv-name" , cname ); AL_STR ( alist, "conv-title" , title ? title : cname ); AL_ENUM( alist, "conv-type" , ctype , ":conversation-type" ); AL_ENUM( alist, "conv-features", cflag , ":connection-flags" ); }
static gchar * yahoo_ft_url_gen(PurpleXfer *xfer, const gchar *host) { struct yahoo_xfer_data *xfer_data; PurpleAccount *account; g_return_val_if_fail(host != NULL, NULL); xfer_data = purple_xfer_get_protocol_data(xfer); account = purple_connection_get_account(xfer_data->gc); if (!xfer_data->is_relay) { purple_debug_fatal("yahoo", "Non-relay FT aren't tested yet\n"); return NULL; } return g_strdup_printf("http://%s/relay?token=%s&sender=%s&recver=%s", host, purple_url_encode(xfer_data->xfer_idstring_for_relay), purple_normalize(account, purple_account_get_username(account)), purple_xfer_get_remote_user(xfer)); }