void
xmpp_connect() {
GError *err = NULL;
const gchar *conf_server;
LmSSL *ssl;
int use_ssl, use_tls, port;
const gchar *jid;
wantconnection = 1;
if (connection && lm_connection_is_open(connection)) {
ui_print("connect: connection alredy opened, aborting\n");
return;
}
if (connection == NULL)
connection = lm_connection_new(NULL);
use_ssl = get_settings_int(USE_SSL);
use_tls = get_settings_int(USE_TLS);
jid = get_settings_str(JID);
port = get_settings_int(PORT);
if (use_ssl || use_tls) {
if (!lm_ssl_is_supported()) {
ui_print("Error: SSL not available\n");
} else if (use_ssl && use_tls) {
ui_print("Error: You can't use ssl and tls at the same time");
} else {
ssl = lm_ssl_new(NULL, ssl_cb, NULL, NULL);
lm_ssl_use_starttls(ssl, !use_ssl, use_tls);
lm_connection_set_ssl(connection, ssl);
lm_ssl_unref(ssl);
}
}
if (!port) {
port = (use_ssl) ? LM_CONNECTION_DEFAULT_PORT_SSL
: LM_CONNECTION_DEFAULT_PORT;
}
lm_connection_set_port(connection, port);
lm_connection_set_jid(connection, jid);
lm_connection_set_keep_alive_rate(connection, 30);
lm_connection_set_disconnect_function(connection,
connection_disconnect_cb,
NULL, NULL);
conf_server = get_settings_str(SERVER);
if (!conf_server) {
ui_print("ERROR: Insufficient configuration, "
"connecting aborted (server not set)\n");
return;
} else {
if(!lm_connection_get_server(connection))
lm_connection_set_server(connection, conf_server);
}
ui_print("Opening connection to %s\n", conf_server);
if(!lm_connection_open(connection, (LmResultFunction)connection_open_cb,
NULL, NULL, &err)) {
ui_print("Error opening connection: %s\n", err->message);
g_error_free(err);
}
} /* xmpp_connect */
boolean
xmpp_connect (const char *user, const char * passwd, const char * server, unsigned short port)
{
GError * error = NULL;
LmMessage * m;
LmMessage * reply;
LmMessageNode * query;
LmMessageNode * item;
gboolean success;
lm_connection_set_server (connection, server);
lm_connection_set_port (connection, port);
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Connecting to %s..."), server);
success = lm_connection_open_and_block (connection, &error);
if (!success) goto error;
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Authenticating with JID %s..."), user);
success = lm_connection_authenticate_and_block (connection, user, passwd, CONN_XMPP_RESOURCE, &error);
if (!success) goto error;
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Connected successfully."), user);
/* Fetch roster */
m = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_GET);
query = lm_message_node_add_child (m->node, "query", NULL);
lm_message_node_set_attributes (query, "xmlns", "jabber:iq:roster", NULL);
reply = lm_connection_send_with_reply_and_block (connection, m, &error);
query = lm_message_node_get_child (reply->node, "query");
item = lm_message_node_get_child (query, "item");
while (item)
{
xmpp_user_t user;
const gchar *jid, *name;
jid = lm_message_node_get_attribute (item, "jid");
name = lm_message_node_get_attribute (item, "name");
user = intern_user (jid);
user->name = g_strdup (name);
user->status = OFFLINE;
item = item->next;
}
lm_message_unref (reply);
lm_message_unref (m);
m = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_PRESENCE, LM_MESSAGE_SUB_TYPE_AVAILABLE);
lm_connection_send(connection, m, NULL);
lm_message_unref (m);
return TRUE;
/* Error handling */
error:
g_message ("%s", error->message);
return FALSE;
}
static void
start_registration(struct register_data *rd)
{
LmConnection *lmconn;
GError *error = NULL;
lmconn = lm_connection_new(NULL);
if (rd->use_ssl) {
if (!set_ssl(lmconn, &error, NULL, FALSE))
goto err;
} else {
if (!set_ssl(lmconn, &error, NULL, TRUE))
goto err;
}
if (settings_get_bool("xmpp_use_proxy") && !set_proxy(lmconn, &error))
goto err;
if (rd->port <= 0)
rd->port = rd->use_ssl ? LM_CONNECTION_DEFAULT_PORT_SSL
: LM_CONNECTION_DEFAULT_PORT;
lm_connection_set_server(lmconn, rd->address);
lm_connection_set_port(lmconn, rd->port);
lm_connection_set_jid(lmconn, NULL);
rd->id = NULL;
rd->lmconn = lmconn;
rd->handler = NULL;
register_data = g_slist_prepend(register_data, rd);
lm_connection_set_disconnect_function(lmconn, register_lm_close_cb,
rd, NULL);
if (!lm_connection_open(lmconn, register_lm_open_cb, rd, NULL,
&error)) {
rd_cleanup(rd);
signal_emit("xmpp register error", 3, rd->username, rd->domain,
error != NULL ? error->message : NULL);
if (error != NULL)
g_error_free(error);
}
return;
err:
signal_emit("xmpp register error", 3, rd->username, rd->domain,
error != NULL ? error->message : NULL);
if (error != NULL)
g_error_free(error);
lm_connection_unref(lmconn);
}
void
LM::Account::enable ()
{
GError *error = NULL;
xmlChar* server = NULL;
unsigned port = LM_CONNECTION_DEFAULT_PORT;
LmSSL* ssl = NULL;
server = xmlGetProp (node, BAD_CAST "server");
{
xmlChar* port_str = xmlGetProp (node, BAD_CAST "port");
port = atoi ((const char*)port_str);
xmlFree (port_str);
}
{
gchar* jid = NULL;
xmlChar* user = NULL;
xmlChar* resource = NULL;
user = xmlGetProp (node, BAD_CAST "user");
resource = xmlGetProp (node, BAD_CAST "resource");
jid = g_strdup_printf ("%s@%s/%s", user, server, resource);
lm_connection_set_jid (connection, jid);
g_free (jid);
xmlFree (user);
xmlFree (resource);
}
/* FIXME: this is an ugly workaround */
if (g_strcmp0 ("gmail.com", (const char*)server) == 0)
lm_connection_set_server (connection, "xmpp.l.google.com");
else
lm_connection_set_server (connection, (const char*)server);
lm_connection_set_port (connection, port);
ssl = lm_ssl_new (NULL, NULL, NULL, NULL);
lm_ssl_use_starttls (ssl, TRUE, TRUE);
lm_connection_set_ssl(connection, ssl);
lm_ssl_unref (ssl);
if ( !lm_connection_open (connection,
(LmResultFunction)on_connection_opened_c,
this, NULL, &error)) {
gchar* message = NULL;
message = g_strdup_printf (_("error connecting (%s)"), error->message);
status = message;
g_free (message);
g_error_free (error);
} else {
status = _("connecting");
}
xmlFree (server);
xmlSetProp (node, BAD_CAST "startup", BAD_CAST "true");
trigger_saving ();
updated ();
}
SERVER_REC *
xmpp_server_init_connect(SERVER_CONNECT_REC *connrec)
{
XMPP_SERVER_REC *server;
XMPP_SERVER_CONNECT_REC *conn = (XMPP_SERVER_CONNECT_REC *)connrec;
char *recoded;
if (conn->address == NULL || conn->address[0] == '\0')
return NULL;
if (conn->nick == NULL || conn->nick[0] == '\0')
return NULL;
g_return_val_if_fail(IS_XMPP_SERVER_CONNECT(conn), NULL);
server = g_new0(XMPP_SERVER_REC, 1);
server->chat_type = XMPP_PROTOCOL;
server->user = xmpp_extract_user(conn->nick);
server->domain = xmpp_have_domain(conn->nick) ?
xmpp_extract_domain(conn->nick) : g_strdup(conn->address);
server->jid = xmpp_have_domain(conn->nick) ?
xmpp_strip_resource(conn->nick)
: g_strconcat(server->user, "@", server->domain, (void *)NULL);
server->resource = xmpp_extract_resource(conn->nick);
if (server->resource == NULL)
server->resource = g_strdup("irssi-xmpp");
server->priority = settings_get_int("xmpp_priority");
if (xmpp_priority_out_of_bound(server->priority))
server->priority = 0;
server->ping_id = NULL;
server->server_features = NULL;
server->my_resources = NULL;
server->roster = NULL;
server->msg_handlers = NULL;
server->channels_join = channels_join;
server->isnickflag = isnickflag_func;
server->ischannel = ischannel_func;
server->get_nick_flags = get_nick_flags;
server->send_message = send_message;
server->connrec = (XMPP_SERVER_CONNECT_REC *)conn;
server_connect_ref(connrec);
/* don't use irssi's sockets */
server->connrec->no_connect = TRUE;
server->connect_pid = -1;
if (server->connrec->port <= 0)
server->connrec->port = (server->connrec->use_ssl) ?
LM_CONNECTION_DEFAULT_PORT_SSL : LM_CONNECTION_DEFAULT_PORT;
if (conn->real_jid == NULL)
conn->real_jid = conn->nick;
else
g_free(conn->nick);
conn->nick = g_strdup(settings_get_bool("xmpp_set_nick_as_username") ?
server->user : server->jid);
/* init loudmouth connection structure */
server->lmconn = lm_connection_new(NULL);
lm_connection_set_server(server->lmconn, server->connrec->address);
lm_connection_set_port(server->lmconn, server->connrec->port);
recoded = xmpp_recode_out(server->jid);
lm_connection_set_jid(server->lmconn, recoded);
g_free(recoded);
lm_connection_set_keep_alive_rate(server->lmconn, 30);
server->timeout_tag = 0;
server_connect_init((SERVER_REC *)server);
server->connect_tag = 1;
return (SERVER_REC *)server;
}
