void
hangouts_auth_get_session_cookies_got_cb(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, gpointer user_data)
{
HangoutsAccount *ha = user_data;
guint64 last_event_timestamp;
gchar *sapisid_cookie = purple_http_cookie_jar_get(ha->cookie_jar, "SAPISID");
if (sapisid_cookie == NULL) {
purple_connection_error(ha->pc, PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
_("SAPISID Cookie not received"));
return;
}
//Restore the last_event_timestamp before it gets overridden by new events
last_event_timestamp = purple_account_get_int(ha->account, "last_event_timestamp_high", 0);
if (last_event_timestamp != 0) {
last_event_timestamp = (last_event_timestamp << 32) | ((guint64) purple_account_get_int(ha->account, "last_event_timestamp_low", 0) & 0xFFFFFFFF);
ha->last_event_timestamp = last_event_timestamp;
}
// SOUND THE TRUMPETS
hangouts_fetch_channel_sid(ha);
purple_connection_set_state(ha->pc, PURPLE_CONNECTION_CONNECTED);
//TODO trigger event instead
hangouts_get_self_info(ha);
hangouts_get_conversation_list(ha);
g_free(sapisid_cookie);
}
static void irc_login(PurpleAccount *account)
{
PurpleConnection *gc;
struct irc_conn *irc;
char **userparts;
const char *username = purple_account_get_username(account);
gc = purple_account_get_connection(account);
gc->flags |= PURPLE_CONNECTION_NO_NEWLINES;
if (strpbrk(username, " \t\v\r\n") != NULL) {
purple_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 = purple_circ_buffer_new(512);
userparts = g_strsplit(username, "@", 2);
purple_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);
purple_connection_update_progress(gc, _("Connecting"), 1, 2);
if (purple_account_get_bool(account, "ssl", FALSE)) {
if (purple_ssl_is_supported()) {
irc->gsc = purple_ssl_connect(account, irc->server,
purple_account_get_int(account, "port", IRC_DEFAULT_SSL_PORT),
irc_login_cb_ssl, irc_ssl_connect_failure, gc);
} else {
purple_connection_error(gc, _("SSL support unavailable"));
return;
}
}
if (!irc->gsc) {
if (purple_proxy_connect(gc, account, irc->server,
purple_account_get_int(account, "port", IRC_DEFAULT_PORT),
irc_login_cb, gc) == NULL)
{
purple_connection_error(gc, _("Couldn't create socket"));
return;
}
}
}
static void
stress_login(PurpleAccount *account) {
PurpleConnection *pc = NULL;
PurpleGroup *g = NULL;
gint n_buddies = 0, i = 0, interval = 0, maxevents = 0;
/* build our possible events from the account settings */
add_event("trigger_signon", STRESS_EVENT_SIGN_ON, STRESS_EVENT_SIGN_OFF);
add_event("trigger_idle", STRESS_EVENT_IDLE, STRESS_EVENT_UNIDLE);
add_event("trigger_away", STRESS_EVENT_AWAY, STRESS_EVENT_BACK);
add_event("trigger_typing", STRESS_EVENT_TYPING, STRESS_EVENT_STOPPED_TYPING);
add_event("send_messages", STRESS_EVENT_SEND_MESSAGE, -1);
nevents = g_list_length(events);
/* get our connection and set it as online */
pc = purple_account_get_connection(account);
purple_connection_set_state(pc, PURPLE_CONNECTED);
/* grab the account settings we need for buddies */
n_buddies = purple_account_get_int(account, "nbuddies", 50);
maxevents = purple_account_get_int(account, "maxevents", 100);
interval = (guint)purple_account_get_int(account, "interval", 500);
message_min = purple_account_get_int(account, "message_min", 16);
message_max = purple_account_get_int(account, "message_max", 128);
g = purple_group_new("prpl-stress");
for(i = 0; i < n_buddies; i++) {
PurpleBuddy *b = NULL;
StressBuddy *sb = NULL;
gchar *name = NULL;
/* create the buddy and it's name */
name = g_strdup_printf("stress-%04x", i);
b = purple_buddy_new(account, name, NULL);
g_free(name);
/* add our data to the buddy */
sb = g_new0(StressBuddy, 1);
sb->buddy = b;
sb->maxevents = maxevents;
purple_buddy_set_protocol_data(b, sb);
/* add the buddy to our list and the purple blist */
buddies = g_list_prepend(buddies, sb);
purple_blist_add_buddy(b, NULL, g, NULL);
/* add our event timer to the buddy */
sb->timer_id = g_timeout_add(interval, stress_event_cb, sb);
}
}
static void
pb_process_frame(PushBulletAccount *pba, const gchar *frame)
{
JsonParser *parser = json_parser_new();
JsonNode *root;
purple_debug_info("pushbullet", "got frame data: %s\n", frame);
if (!json_parser_load_from_data(parser, frame, -1, NULL))
{
purple_debug_error("pushbullet", "Error parsing response: %s\n", frame);
return;
}
root = json_parser_get_root(parser);
if (root != NULL) {
JsonObject *message = json_node_get_object(root);
const gchar *type = json_object_get_string_member(message, "type");
if (purple_strequal(type, "tickle")) {
pb_get_everything_since(pba, purple_account_get_int(pba->account, "last_message_timestamp", 0));
} else if (purple_strequal(type, "push")) {
JsonObject *push = json_object_get_object_member(message, "push");
//{"type":"push","targets":["stream","android","ios"],"push":{"guid":"purple6e94d282","type":"messaging_extension_reply","package_name":"com.pushbullet.android","target_device_iden":"uffvytgsjAoIRwhIL6","conversation_iden":"+6421478252","message":"test2"}}
//{"type":"push","targets":["stream"],"push":{"type":"sms_changed"}}
type = json_object_get_string_member(push, "type");
if (purple_strequal(type, "sms_changed")) {
pb_get_phone_threads(pba, NULL);
}
}
}
g_object_unref(parser);
}
void silcpurple_idle_set(PurpleConnection *gc, int idle)
{
SilcPurple sg;
SilcClient client;
SilcClientConnection conn;
SilcAttributeObjService service;
const char *server;
int port;
sg = gc->proto_data;
if (sg == NULL)
return;
client = sg->client;
if (client == NULL)
return;
conn = sg->conn;
if (conn == NULL)
return;
server = purple_account_get_string(sg->account, "server",
"silc.silcnet.org");
port = purple_account_get_int(sg->account, "port", 706),
memset(&service, 0, sizeof(service));
silc_client_attribute_del(client, conn,
SILC_ATTRIBUTE_SERVICE, NULL);
service.port = port;
g_snprintf(service.address, sizeof(service.address), "%s", server);
service.idle = idle;
silc_client_attribute_add(client, conn, SILC_ATTRIBUTE_SERVICE,
&service, sizeof(service));
}
static void yahoo_xfer_init(PurpleXfer *xfer)
{
struct yahoo_xfer_data *xfer_data;
PurpleConnection *gc;
PurpleAccount *account;
struct yahoo_data *yd;
xfer_data = xfer->data;
gc = xfer_data->gc;
yd = gc->proto_data;
account = purple_connection_get_account(gc);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) {
if (yd->jp) {
if (purple_proxy_connect(NULL, account, purple_account_get_string(account, "xferjp_host", YAHOOJP_XFER_HOST),
purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT),
yahoo_sendfile_connected, xfer) == NULL)
{
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to establish file descriptor."));
purple_xfer_cancel_remote(xfer);
}
} else {
if (purple_proxy_connect(NULL, account, purple_account_get_string(account, "xfer_host", YAHOO_XFER_HOST),
purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT),
yahoo_sendfile_connected, xfer) == NULL)
{
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to establish file descriptor."));
purple_xfer_cancel_remote(xfer);
}
}
} else {
/* TODO: Using xfer->fd like this is probably a bad thing... */
if (purple_proxy_connect(NULL, account, xfer_data->host, xfer_data->port,
yahoo_receivefile_connected, xfer) == NULL)
xfer->fd = -1;
else
xfer->fd = 0;
if (xfer->fd == -1) {
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to establish file descriptor."));
purple_xfer_cancel_remote(xfer);
}
}
}
static void
pb_got_phone_threads(PushBulletAccount *pba, JsonNode *node, gpointer user_data)
{
PurpleAccount *account = pba->account;
JsonObject *rootobj = json_node_get_object(node);
JsonObject *data = json_object_get_object_member(rootobj, "data");
JsonArray *threads = json_object_get_array_member(data, "threads");
gint i;
guint len;
gchar *device = user_data;
gint last_message_timestamp = purple_account_get_int(account, "last_message_timestamp", 0);
gint newest_phone_message_id = purple_account_get_int(account, "newest_phone_message_id", 0);
for(i = 0, len = json_array_get_length(threads); i < len; i++)
{
JsonObject *thread = json_array_get_object_element(threads, i);
const gchar *id = json_object_get_string_member(thread, "id");
JsonArray *recipients = json_object_get_array_member(thread, "recipients");
const gchar *from = NULL;
if (json_array_get_length(recipients) > 0) {
JsonObject *first_recipient = json_array_get_object_element(recipients, 0);
from = json_object_get_string_member(first_recipient, "number");
if (json_object_has_member(first_recipient, "thumbnail")) {
pb_set_base64_icon_for_buddy(json_object_get_string_member(first_recipient, "thumbnail"), purple_find_buddy(account, from));
}
}
if (from == NULL) {
continue;
}
if (json_object_has_member(thread, "latest"))
{
JsonObject *latest = json_object_get_object_member(thread, "latest");
gint64 timestamp = json_object_get_int_member(latest, "timestamp");
gint msgid = atoi(json_object_get_string_member(latest, "id"));
if (timestamp > last_message_timestamp || msgid > newest_phone_message_id) {
pb_get_phone_thread_by_id(pba, device, id, from);
}
}
}
g_free(device);
}
/** Convert point size to msim pixel height font size specification, for outgoing messages. */
static guint
msim_point_to_height(MsimSession *session, guint point)
{
guint dpi;
dpi = purple_account_get_int(session->account, "dpi", MSIM_DEFAULT_DPI);
return (guint)msim_round((dpi * 1. / POINTS_PER_INCH) * point);
}
/** Convert a msim markup font pixel height to the more usual point size, for incoming messages. */
static guint
msim_height_to_point(MsimSession *session, guint height)
{
guint dpi;
dpi = purple_account_get_int(session->account, "dpi", MSIM_DEFAULT_DPI);
return (guint)msim_round((POINTS_PER_INCH * 1. / dpi) * height);
/* See also: libpurple/protocols/bonjour/jabber.c
* _font_size_ichat_to_purple */
}
static gboolean
pb_poll_everything(PushBulletAccount *pba)
{
if (purple_account_is_connected(pba->account)) {
pb_get_everything_since(pba, purple_account_get_int(pba->account, "last_message_timestamp", 0));
return TRUE;
}
pba->everything_poll = 0;
return FALSE;
}
static void
nap_login(PurpleAccount *account) {
PurpleConnection *gc = purple_account_get_connection(account);
purple_connection_update_progress(gc, _("Connecting"), 0, NAPSTER_CONNECT_STEPS);
gc->proto_data = g_new0(struct nap_data, 1);
if (purple_proxy_connect(gc, account,
purple_account_get_string(account, "server", NAP_SERVER),
purple_account_get_int(account, "port", NAP_PORT),
nap_login_connect, gc) != 0) {
purple_connection_error(gc, _("Unable to connect."));
}
}
/*------------------------------------------------------------------------
* We now have a connection established with MXit, so we can start the
* login procedure
*
* @param session The MXit session object
*/
static void mxit_connected( struct MXitSession* session )
{
int state;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_connected\n" );
session->flags |= MXIT_FLAG_CONNECTED;
purple_connection_update_progress( session->con, _( "Logging In..." ), 2, 4 );
/* create a timer to send a ping packet if the connection is idle */
session->last_tx = mxit_now_milli();
/* encrypt the user password */
session->encpwd = mxit_encrypt_password( session );
state = purple_account_get_int( session->acc, MXIT_CONFIG_STATE, MXIT_STATE_LOGIN );
if ( state == MXIT_STATE_LOGIN ) {
/* create and send login packet */
mxit_send_login( session );
}
else {
if ( !session->profile ) {
/* we have lost the session profile, so ask the user to enter it again */
mxit_register_view( session );
}
else {
/* create and send the register packet */
mxit_send_register( session );
}
}
/* enable signals */
mxit_enable_signals( session );
#ifdef MXIT_LINK_CLICK
/* register for uri click notification */
mxit_register_uri_handler();
#endif
/* start the polling if this is a HTTP connection */
if ( session->http ) {
session->http_timer_id = purple_timeout_add_seconds( 2, mxit_manage_polling, session );
}
/* This timer might already exist if we're registering a new account */
if ( session->q_slow_timer_id == 0 ) {
/* start the tx queue manager timer */
session->q_slow_timer_id = purple_timeout_add_seconds( 2, mxit_manage_queue_slow, session );
}
}
static void waprpl_login(PurpleAccount * acct)
{
PurpleConnection *gc = purple_account_get_connection(acct);
purple_debug_info(WHATSAPP_ID, "logging in %s\n", purple_account_get_username(acct));
purple_connection_update_progress(gc, "Connecting", 0, 4);
whatsapp_connection *wconn = g_new0(whatsapp_connection, 1);
wconn->fd = -1;
wconn->sslfd = -1;
wconn->account = acct;
wconn->rh = 0;
wconn->wh = 0;
wconn->timer = 0;
wconn->connected = 0;
wconn->conv_id = 1;
wconn->gsc = 0;
wconn->sslrh = 0;
wconn->sslwh = 0;
const char *username = purple_account_get_username(acct);
const char *password = purple_account_get_password(acct);
const char *nickname = purple_account_get_string(acct, "nick", "");
wconn->waAPI = waAPI_create(username, password, nickname);
purple_connection_set_protocol_data(gc, wconn);
const char *hostname = purple_account_get_string(acct, "server", "");
int port = purple_account_get_int(acct, "port", WHATSAPP_DEFAULT_PORT);
char hn[256];
if (strlen(hostname) == 0) {
sprintf(hn, "e%d.whatsapp.net", rand() % 9 + 1);
hostname = hn;
}
if (purple_proxy_connect(gc, acct, hostname, port, waprpl_connect_cb, gc) == NULL) {
purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, "Unable to connect");
}
static int sig_con = 0;
if (!sig_con) {
sig_con = 1;
purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", _whatsapp_protocol, PURPLE_CALLBACK(waprpl_blist_node_removed), NULL);
purple_signal_connect(purple_blist_get_handle(), "blist-node-added", _whatsapp_protocol, PURPLE_CALLBACK(waprpl_blist_node_added), NULL);
}
}
static void
pb_start_polling(PushBulletAccount *pba)
{
if (!purple_account_is_connected(pba->account))
return;
if (!pba->phone_threads_poll && pba->main_sms_device) {
pb_get_phone_threads(pba, NULL);
pba->phone_threads_poll = purple_timeout_add_seconds(10, (GSourceFunc) pb_poll_phone_threads, pba);
}
if (!pba->everything_poll) {
pb_get_everything_since(pba, purple_account_get_int(pba->account, "last_message_timestamp", 0));
pba->everything_poll = purple_timeout_add_seconds(10, (GSourceFunc) pb_poll_everything, pba);
}
}
/*------------------------------------------------------------------------
* 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;
}
time_t
purple_buddy_icons_get_account_icon_timestamp(PurpleAccount *account)
{
time_t ret;
g_return_val_if_fail(account != NULL, 0);
ret = purple_account_get_int(account, "buddy_icon_timestamp", 0);
/* This deals with migration cases. */
if (ret == 0 && purple_account_get_string(account, "buddy_icon", NULL) != NULL)
{
ret = time(NULL);
purple_account_set_int(account, "buddy_icon_timestamp", ret);
}
return ret;
}
/** Convert HTML font size to point size. */
static guint
msim_purple_size_to_point(MsimSession *session, guint size)
{
gdouble scale;
guint point;
guint base;
scale = _font_scale[CLAMP(size, 1, MAX_FONT_SIZE) - 1];
base = purple_account_get_int(session->account, "base_font_size", MSIM_BASE_FONT_POINT_SIZE);
point = (guint)msim_round(scale * base);
purple_debug_info("msim", "msim_purple_size_to_point: size=%d -> %d pt\n",
size, point);
return point;
}
void flist_login(PurpleAccount *pa) {
PurpleConnection *pc = purple_account_get_connection(pa);
FListAccount *fla;
gchar **ac_split;
fla = g_new0(FListAccount, 1);
fla->pa = pa;
fla->pc = pc;
fla->all_characters = g_hash_table_new_full((GHashFunc)flist_str_hash, (GEqualFunc)flist_str_equal, g_free, (GDestroyNotify)flist_character_free);
fla->rx_buf = g_malloc0(256); fla->rx_len = 0;
pc->proto_data = fla;
ac_split = g_strsplit(purple_account_get_username(pa), ":", 2);
fla->username = g_strdup(ac_split[0]);
fla->character = g_strdup(ac_split[1]);
fla->password = g_strdup(purple_account_get_password(pa));
//we don't want to display the whole username:character thing
if(purple_account_get_alias(pa) == NULL || flist_str_equal(purple_account_get_username(pa), purple_account_get_alias(pa))) {
purple_account_set_alias(pa, fla->character);
}
/* login options */
fla->server_address = g_strdup(purple_account_get_string(pa, "server_address", "chat.f-list.net"));
fla->server_port = purple_account_get_int(pa, "server_port", FLIST_PORT);
fla->sync_bookmarks = purple_account_get_bool(pa, "sync_bookmarks", FALSE);
fla->sync_friends = purple_account_get_bool(pa, "sync_friends", TRUE);
fla->debug_mode = purple_account_get_bool(pa, "debug_mode", FALSE);
flist_channel_subsystem_load(fla);
flist_clear_filter(fla);
flist_global_kinks_load(pc);
flist_profile_load(pc);
flist_friends_load(fla);
flist_ticket_timer(fla, 0);
g_strfreev(ac_split);
}
/** Convert typographical font point size to HTML font size.
* Based on libpurple/gtkimhtml.c */
static guint
msim_point_to_purple_size(MsimSession *session, guint point)
{
guint size, this_point, base;
base = purple_account_get_int(session->account, "base_font_size", MSIM_BASE_FONT_POINT_SIZE);
for (size = 0; size < MAX_FONT_SIZE; ++size) {
this_point = (guint)msim_round(base * _font_scale[size]);
if (this_point >= point) {
purple_debug_info("msim", "msim_point_to_purple_size: %d pt -> size=%d\n",
point, size);
return size;
}
}
/* No HTML font size was this big; return largest possible. */
return this_point;
}
void ycht_connection_open(PurpleConnection *gc)
{
YchtConn *ycht;
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleAccount *account = purple_connection_get_account(gc);
ycht = g_new0(YchtConn, 1);
ycht->gc = gc;
ycht->fd = -1;
yd->ycht = ycht;
if (purple_proxy_connect(gc, account,
purple_account_get_string(account, "ycht-server", YAHOO_YCHT_HOST),
purple_account_get_int(account, "ycht-port", YAHOO_YCHT_PORT),
ycht_got_connected, ycht) == NULL)
{
ycht_connection_error(ycht, _("Unable to connect"));
return;
}
}
static void
np_socket_login(NPSession *session)
{
PurpleConnection *gc;
PurplePresence *presence;
const char *host;
gboolean http_method = FALSE;
int port;
PurpleAccount *account ;
account = session->account;
host = purple_account_get_string(account, "server", NP_IM_SERVER);
port = purple_account_get_int(account, "port", NP_IM_PORT);
// session = np_session_new(account);
purple_debug_warning("np","=====> session : %p ",session);
gc = purple_account_get_connection(account);
g_return_if_fail(gc != NULL);
gc->proto_data = session;
gc->flags |= PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_NO_BGCOLOR | PURPLE_CONNECTION_AUTO_RESP;
np_session_set_login_step(session, NP_LOGIN_STEP_START);
presence = purple_account_get_presence(account);
if (!np_session_connect(session, host, port, http_method))
purple_connection_error_reason(gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("Unable to connect"));
}
static time_t tgp_msg_oldest_relevant_ts (struct tgl_state *TLS) {
connection_data *conn = TLS->ev_base;
int days = purple_account_get_int (conn->pa, TGP_KEY_HISTORY_RETRIEVAL_THRESHOLD,
TGP_DEFAULT_HISTORY_RETRIEVAL_THRESHOLD);
return days > 0 ? tgp_time_n_days_ago (days) : 0;
}
int twitter_option_cutoff_time(PurpleAccount * account)
{
return purple_account_get_int(account, TWITTER_ONLINE_CUTOFF_TIME_HOURS, TWITTER_ONLINE_CUTOFF_TIME_HOURS_DEFAULT);
}
gint twitter_option_user_status_timeout(PurpleAccount * account)
{
return purple_account_get_int(account, TWITTER_PREF_USER_STATUS_TIMEOUT, TWITTER_PREF_USER_STATUS_TIMEOUT_DEFAULT);
}
gint twitter_option_list_max_tweets(PurpleAccount * account)
{
return purple_account_get_int(account, TWITTER_PREF_HOME_TIMELINE_MAX_TWEETS, TWITTER_PREF_HOME_TIMELINE_MAX_TWEETS_DEFAULT);
}
gint twitter_option_dms_timeout(PurpleAccount * account)
{
return purple_account_get_int(account, TWITTER_PREF_DMS_TIMEOUT, TWITTER_PREF_DMS_TIMEOUT_DEFAULT);
}
gint twitter_option_search_timeout(PurpleAccount * account)
{
return purple_account_get_int(account, TWITTER_PREF_SEARCH_TIMEOUT, TWITTER_PREF_SEARCH_TIMEOUT_DEFAULT);
}
static gboolean
exec_skype()
{
if (!connected && !in_progress)
{
in_progress = TRUE;
PurpleAccount *acct = skype_get_account(NULL);
purple_proxy_connect(acct->gc, acct, purple_account_get_string(acct, "host", "skype.robbmob.com"), purple_account_get_int(acct, "port", 5000), connect_function, acct);
g_thread_create((GThreadFunc)skype_read_thread, acct, FALSE, NULL);
purple_timeout_add_seconds(10, connection_timeout, acct);
}
return TRUE;
}
static void fb_got_notifications_cb(FacebookAccount *fba, gchar *url_text, gsize len, gpointer userdata)
{
gchar *salvaged;
time_t last_fetch_time;
time_t time_of_message;
time_t newest_message = 0;
xmlnode *channel;//VOXOX - CJC - 2009.07.06
xmlnode *rss_root;//VOXOX - CJC - 2009.07.06
xmlnode *item;//VOXOX - CJC - 2009.07.06
xmlnode *link;//VOXOX - CJC - 2009.07.06
xmlnode *title;//VOXOX - CJC - 2009.07.06
gchar *tmp;
gchar month_string[4], weekday[4];
guint year, month, day, hour, minute, second;
long timezone;
gchar *subject, *url;
month_string[3] = weekday[3] = '\0';
year = month = day = hour = minute = second = 0;
if (!url_text || !len)
return;
last_fetch_time = purple_account_get_int(fba->account, "facebook_notifications_last_fetch", 0);
/* purple_debug_info("facebook", "last fetch time: %zu\n", last_fetch_time); */
salvaged = purple_utf8_salvage(url_text);
rss_root = xmlnode_from_str(salvaged, -1);
g_free(salvaged);
if (rss_root == NULL)
{
purple_debug_error("facebook", "Could not load RSS file\n");
return;
}
channel = xmlnode_get_child(rss_root, "channel");
if (channel == NULL)
{
purple_debug_warning("facebook", "Invalid RSS feed\n");
xmlnode_free(rss_root);
return;
}
item = xmlnode_get_child(channel, "item");
if (item == NULL)
{
purple_debug_info("facebook", "No new notifications\n");
}
for (; item != NULL; item = xmlnode_get_next_twin(item))
{
xmlnode *pubDate = xmlnode_get_child(item, "pubDate");
if (!pubDate)
continue;
tmp = xmlnode_get_data_unescaped(pubDate);
/* rss times are in Thu, 19 Jun 2008 15:51:25 -1100 format */
sscanf(tmp, "%3s, %2u %3s %4u %2u:%2u:%2u %5ld", (char*)&weekday, &day, (char*)&month_string, &year, &hour, &minute, &second, &timezone);
if (g_str_equal(month_string, "Jan")) month = 0;
else if (g_str_equal(month_string, "Feb")) month = 1;
else if (g_str_equal(month_string, "Mar")) month = 2;
else if (g_str_equal(month_string, "Apr")) month = 3;
else if (g_str_equal(month_string, "May")) month = 4;
else if (g_str_equal(month_string, "Jun")) month = 5;
else if (g_str_equal(month_string, "Jul")) month = 6;
else if (g_str_equal(month_string, "Aug")) month = 7;
else if (g_str_equal(month_string, "Sep")) month = 8;
else if (g_str_equal(month_string, "Oct")) month = 9;
else if (g_str_equal(month_string, "Nov")) month = 10;
else if (g_str_equal(month_string, "Dec")) month = 11;
g_free(tmp);
/* try using pidgin's functions */
tmp = g_strdup_printf("%04u%02u%02uT%02u%02u%02u%05ld", year, month, day, hour, minute, second, timezone);
time_of_message = purple_str_to_time(tmp, FALSE, NULL, NULL, NULL);
g_free(tmp);
if (time_of_message <= 0)
{
/* there's no cross-platform, portable way of converting string to time
which doesn't need a new version of glib, so just cheat */
time_of_message = second + 60*minute + 3600*hour + 86400*day + 2592000*month + 31536000*(year-1970);
}
if (time_of_message > newest_message)
{
/* we'll keep the newest message to save */
newest_message = time_of_message;
}
if (time_of_message <= last_fetch_time)
{
/* fortunatly, rss messages are ordered from newest to oldest */
/* so if this message is older than the last one, ignore rest */
break;
}
link = xmlnode_get_child(item, "link");
if (link)
{
url = xmlnode_get_data_unescaped(link);
} else {
url = g_strdup("");
}
title = xmlnode_get_child(item, "title");
if (title)
{
subject = xmlnode_get_data_unescaped(title);
} else {
subject = g_strdup("");
}
purple_notify_email(fba->pc, subject, NULL, fba->account->username, url, NULL, NULL);
g_free(subject);
g_free(url);
}
xmlnode_free(rss_root);
if (newest_message > last_fetch_time)
{
/* update the last fetched time if we had newer messages */
purple_account_set_int(fba->account, "facebook_notifications_last_fetch", newest_message);
}
}
static void qq_login(PurpleAccount *account)
{
PurpleConnection *gc;
qq_data *qd;
PurplePresence *presence;
const gchar *version_str;
g_return_if_fail(account != NULL);
gc = purple_account_get_connection(account);
g_return_if_fail(gc != NULL);
gc->flags |= PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_NO_BGCOLOR | PURPLE_CONNECTION_AUTO_RESP;
qd = g_new0(qq_data, 1);
memset(qd, 0, sizeof(qq_data));
qd->gc = gc;
gc->proto_data = qd;
presence = purple_account_get_presence(account);
if(purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_INVISIBLE)) {
qd->login_mode = QQ_LOGIN_MODE_HIDDEN;
} else if(purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_AWAY)
|| purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_EXTENDED_AWAY)) {
qd->login_mode = QQ_LOGIN_MODE_AWAY;
} else {
qd->login_mode = QQ_LOGIN_MODE_NORMAL;
}
server_list_create(account);
purple_debug_info("QQ", "Server list has %d\n", g_list_length(qd->servers));
version_str = purple_account_get_string(account, "client_version", NULL);
qd->client_tag = QQ_CLIENT_2227; /* set default as QQ2011 */
qd->client_version = 2011;
if (version_str != NULL && strlen(version_str) != 0) {
if (strcmp(version_str, "qq2010") == 0) {
qd->client_tag = QQ_CLIENT_1E0D;
qd->client_version = 2010;
}
if (strcmp(version_str, "qq2011") == 0) {
qd->client_tag = QQ_CLIENT_2227;
qd->client_version = 2011;
}
if (strcmp(version_str, "qq2012") == 0) {
qd->client_tag = QQ_CLIENT_2227;
qd->client_version = 2012;
}
}
qd->is_show_notice = purple_account_get_bool(account, "show_notice", TRUE);
qd->is_show_news = purple_account_get_bool(account, "show_news", TRUE);
qd->is_show_chat = purple_account_get_bool(account, "show_chat", TRUE);
qd->resend_times = purple_prefs_get_int("/plugins/prpl/qq/resend_times");
if (qd->resend_times <= 1) qd->itv_config.resend = 4;
qd->itv_config.resend = purple_prefs_get_int("/plugins/prpl/qq/resend_interval");
if (qd->itv_config.resend <= 0) qd->itv_config.resend = 4;
purple_debug_info("QQ", "Resend interval %d, retries %d\n",
qd->itv_config.resend, qd->resend_times);
qd->itv_config.keep_alive = purple_account_get_int(account, "keep_alive_interval", 60);
if (qd->itv_config.keep_alive < 30) qd->itv_config.keep_alive = 40;
qd->itv_config.keep_alive /= qd->itv_config.resend;
qd->itv_count.keep_alive = qd->itv_config.keep_alive;
qd->itv_config.update = purple_account_get_int(account, "update_interval", 300);
if (qd->itv_config.update > 0) {
if (qd->itv_config.update < qd->itv_config.keep_alive) {
qd->itv_config.update = qd->itv_config.keep_alive;
}
qd->itv_config.update /= qd->itv_config.resend;
qd->itv_count.update = qd->itv_config.update;
} else {
qd->itv_config.update = 0;
}
qd->connect_watcher = purple_timeout_add_seconds(0, qq_connect_later, gc);
}