static void fx_login(PurpleAccount *account)
{
PurplePresence *presence;
PurpleConnection *pc = purple_account_get_connection(account);
const gchar *mobileno = purple_account_get_username(account);
const gchar *password = purple_connection_get_password(pc);
const gchar *status_id;
fetion_account *ac = session_new(account);
/* construct a user object */
ac->user = fetion_user_new(mobileno, password);
ac->account = account;
ac->gc = pc;
ac->chan_ready = 1;
purple_connection_set_protocol_data(pc, ac);
presence = purple_account_get_presence(account);
status_id = get_status_id(ac->user->state);
if(ac->user->state == 0) status_id = "Hidden";
purple_presence_set_status_active(presence, status_id, TRUE);
purple_connection_update_progress(pc, "Connecting", 1, 2);
purple_ssl_connect(ac->account, SSI_SERVER,
PURPLE_SSL_DEFAULT_PORT,
(PurpleSslInputFunction)ssi_auth_action,
(PurpleSslErrorFunction)0, ac);
}
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 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 waprpl_close(PurpleConnection * gc)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
if (wconn->rh)
purple_input_remove(wconn->rh);
if (wconn->wh)
purple_input_remove(wconn->wh);
if (wconn->fd >= 0)
close(wconn->fd);
if (wconn->waAPI)
waAPI_delete(wconn->waAPI);
wconn->waAPI = NULL;
g_free(wconn);
purple_connection_set_protocol_data(gc, 0);
}
static void fx_close(PurpleConnection *gc)
{
fetion_account *ses;
fetion_account *ac = purple_connection_get_protocol_data(gc);
purple_input_remove(ac->conn);
close(ac->sk);
g_free(ac->data);
ac->data = (gchar*)0;
while(sessions) {
ses = (fetion_account*)(sessions->data);
session_remove(ses);
session_destroy(ses);
}
fetion_user_free(ac->user);
ac->user = NULL;
purple_connection_set_protocol_data(gc, NULL);
}
static void
skypeweb_login(PurpleAccount *account)
{
PurpleConnection *pc = purple_account_get_connection(account);
SkypeWebAccount *sa = g_new0(SkypeWebAccount, 1);
PurpleConnectionFlags flags;
purple_connection_set_protocol_data(pc, sa);
if (!purple_ssl_is_supported()) {
purple_connection_error (pc,
PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT,
_("Server requires TLS/SSL for login. No TLS/SSL support found."));
return;
}
flags = purple_connection_get_flags(pc);
flags |= PURPLE_CONNECTION_FLAG_HTML | PURPLE_CONNECTION_FLAG_NO_BGCOLOR | PURPLE_CONNECTION_FLAG_NO_FONTSIZE;
purple_connection_set_flags(pc, flags);
if (!SKYPEWEB_BUDDY_IS_MSN(purple_account_get_username(account))) {
sa->username = g_ascii_strdown(purple_account_get_username(account), -1);
}
sa->account = account;
sa->pc = pc;
sa->cookie_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
sa->hostname_ip_cache = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
sa->sent_messages_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
sa->waiting_conns = g_queue_new();
sa->messages_host = g_strdup(SKYPEWEB_DEFAULT_MESSAGES_HOST);
if(strchr(purple_account_get_username(account), '@')) {
//Has an email address for a username, probably a microsoft account?
skypeweb_begin_oauth_login(sa);
} else {
skypeweb_begin_web_login(sa);
}
purple_signal_connect(purple_conversations_get_handle(), "conversation-updated", pc, PURPLE_CALLBACK(skypeweb_mark_conv_seen), NULL);
}
static void plainprpl_login(PurpleAccount *account)
{
PurpleConnection *gc = purple_account_get_connection(account);
purple_debug_info("plainprpl", "logging in %s\n", account->username);
purple_connection_update_progress(gc, _("Connecting"), 0, 2);
purple_connection_update_progress(gc, _("Connected"), 1, 2);
purple_connection_set_state(gc, PURPLE_CONNECTED);
/* Setup plugin data */
plain_plugin_state *pstate = g_new0(plain_plugin_state, 1);
/* General account data */
const char *listen_af = purple_account_get_string(account, "listen_af", NULL);
const char *listen_port = purple_account_get_string(account, "listen_port", NULL);
//check port
if (listen_port == NULL || atoi(listen_port) < 1 || atoi(listen_port) >= 65535) {
listen_port = PLAIN_DEFAULT_PORT_STR;
purple_account_set_string(account, "listen_port", listen_port);
}
//check protocol
if (listen_af == NULL || (strcmp(listen_af, "ipv4") && strcmp(listen_af, "ipv6"))) {
listen_af = "ipv4";
purple_account_set_string(account, "listen_port", listen_af);
}
/* Select the address to listen on */
const char *listen_addr = (strcmp(listen_af, "ipv4") == 0) ? "0.0.0.0" : "::1";
pstate->sockaf = str_to_af(listen_af);
pstate->sockfd = net_bind("plainprpl", listen_addr, listen_port, NULL, IPPROTO_UDP, pstate->sockaf);
if (pstate->sockfd < 0) {
purple_debug_info("plainprpl", "Failed to bind to %s\n", listen_addr);
g_free(pstate);
//TODO: diable plugin
return;
} else {
purple_debug_info("plainprpl", "Bind to %s\n", listen_addr);
}
pstate->receive_timer = purple_timeout_add(80, plain_receive, gc);
purple_connection_set_protocol_data(gc, pstate);
/* Attach buddy data to each buddy */
GSList *list = purple_find_buddies(account, NULL);
purple_debug_info("plainprpl", "Buddies to load: %d\n", g_slist_length(list));
GSList *iter = list;
while (iter) {
PurpleBuddy *buddy = iter->data;
//purple_debug_info("plainprpl", "#plainprpl_login: attach custom data to buddy: %s\n", buddy->name);
assert(purple_buddy_get_protocol_data(buddy) == NULL);
const char *addr_str = purple_blist_node_get_string(PURPLE_BLIST_NODE(buddy), "addr_str");
if (addr_str != NULL && strlen(addr_str)) {
add_buddy_sdata(buddy, pstate);
} else {
purple_debug_info("plainprpl", "Empty address for buddy: %s\n", buddy->name);
}
/* Set offline by default */
purple_prpl_got_user_status(account, buddy->name, PLAIN_STATUS_OFFLINE, NULL);
iter = iter->next;
}
g_slist_free(list);
/* Call the on_login script - if it is set */
const char *on_login = purple_account_get_string(account, "on_login", NULL);
exec_process(on_login, NULL, NULL, gc, NULL);
}
