static void auth_cb (PnAuth *auth, void *data)
{
PnSslConn *ssl_conn;
PnNode *conn;
RoamingRequest *roaming_request = data;
ssl_conn = pn_ssl_conn_new ("ab_roaming", PN_NODE_NULL);
conn = PN_NODE (ssl_conn);
conn->session = roaming_request->roaming_session->session;
roaming_request->parser = pn_parser_new (conn);
pn_ssl_conn_set_read_cb (ssl_conn, read_cb, roaming_request);
if (!roaming_request->roaming_session->hostname)
pn_node_connect (conn, "tkrdr.storage.msn.com", 443);
else
pn_node_connect (conn, roaming_request->roaming_session->hostname, 443);
roaming_request->conn = conn;
roaming_request->open_sig_handler = g_signal_connect (conn, "open", G_CALLBACK (open_cb), roaming_request);
}
static void
connect_impl (PnNode *conn,
const gchar *hostname,
gint port)
{
g_return_if_fail (conn);
pn_log ("begin");
pn_debug ("conn=%p,name=%s", conn, conn->name);
pn_debug ("hostname=%s,port=%d", hostname, port);
pn_debug ("next=%p", conn->next);
g_free (conn->hostname);
conn->hostname = g_strdup (hostname);
conn->port = port;
if (conn->next)
{
conn->status = PN_NODE_STATUS_CONNECTING;
conn->next->prev = conn;
pn_node_connect (conn->next, hostname, port);
conn->next->prev = NULL;
}
else
{
pn_node_close (conn);
conn->status = PN_NODE_STATUS_CONNECTING;
#if defined(USE_GIO)
GSocketClient *client;
client = g_socket_client_new();
conn->socket_cancel = g_cancellable_new();
g_socket_client_connect_to_host_async(client, hostname, port,
conn->socket_cancel, connect_cb, conn);
#elif defined(HAVE_LIBPURPLE)
conn->connect_data = purple_proxy_connect (NULL, msn_session_get_user_data (conn->session),
hostname, port, connect_cb, conn);
#endif
}
pn_log ("end");
}
void
msn_nexus_connect(MsnNexus *nexus)
{
PnSslConn *ssl_conn;
PnNode *conn;
ssl_conn = pn_ssl_conn_new("nexus", PN_NODE_NULL);
conn = PN_NODE(ssl_conn);
conn->session = nexus->session;
nexus->parser = pn_parser_new(conn);
pn_ssl_conn_set_read_cb(ssl_conn, nexus_read_cb, nexus);
nexus->conn = conn;
nexus->open_handler = g_signal_connect(conn, "open", G_CALLBACK(nexus_open_cb), nexus);
nexus->error_handler = g_signal_connect(conn, "error", G_CALLBACK(close_cb), nexus);
pn_node_connect(conn, "nexus.passport.com", 443);
}
static void
got_header(MsnNexus *nexus,
const gchar *header)
{
MsnSession *session = nexus->session;
if (strstr(header, "HTTP/1.1 200 OK")) {
char *base, *c;
char *login_params;
base = strstr(header, "Authentication-Info: ");
if (!base)
goto parse_error;
base = strstr(base, "from-PP='");
base += strlen("from-PP='");
c = strchr(base, '\'');
login_params = g_strndup(base, c - base);
msn_got_login_params(session, login_params);
g_free(login_params);
msn_nexus_destroy(nexus);
session->nexus = NULL;
return;
}
else if (strstr(header, "HTTP/1.1 302")) {
/* Redirect. */
char *location, *c;
location = strstr(header, "Location: ");
if (!location)
goto parse_error;
location = strchr(location, ' ') + 1;
if ((c = strchr(location, '\r')))
*c = '\0';
/* Skip the http:// */
if ((c = strchr(location, '/')))
location = c + 2;
if ((c = strchr(location, '/'))) {
g_free(nexus->login_path);
nexus->login_path = g_strdup(c);
*c = '\0';
}
g_free(nexus->login_host);
nexus->login_host = g_strdup(location);
pn_info("reconnecting to '%s'", nexus->login_host);
pn_parser_reset(nexus->parser);
nexus->parser_state = 0;
nexus->open_handler = g_signal_connect(nexus->conn, "open", G_CALLBACK(login_open_cb), nexus);
pn_node_connect(nexus->conn, nexus->login_host, 443);
return;
}
else if (strstr(header, "HTTP/1.1 401 Unauthorized")) {
const char *tmp;
gchar *error = NULL;
if ((tmp = strstr(header, "WWW-Authenticate"))) {
if ((tmp = strstr(tmp, "cbtxt="))) {
const char *c;
char *tmp2;
tmp += strlen("cbtxt=");
c = strchr(tmp, '\n');
if (!c)
c = tmp + strlen(tmp);
tmp2 = g_strndup(tmp, c - tmp);
error = pn_url_decode(tmp2);
g_free(tmp2);
if ((tmp2 = strstr(error, " Do one of the following or try again:")) != NULL)
*tmp2 = '\0';
}
}
msn_session_set_error(session, MSN_ERROR_AUTH, error);
g_free(error);
return;
}
else if (strstr(header, "HTTP/1.1 503 Service Unavailable")) {
msn_session_set_error(session, MSN_ERROR_SERV_UNAVAILABLE, NULL);
return;
}
parse_error:
msn_session_set_error(session, MSN_ERROR_AUTH, _("nexus parse error"));
}
static void
nexus_read_cb(PnNode *conn,
gpointer data)
{
MsnNexus *nexus = data;
GIOStatus status = G_IO_STATUS_NORMAL;
gchar *str = NULL;
while (nexus->parser_state == 0) {
gsize terminator_pos;
status = pn_parser_read_line(nexus->parser, &str, NULL, &terminator_pos, NULL);
if (status == G_IO_STATUS_AGAIN)
return;
if (status != G_IO_STATUS_NORMAL) {
msn_session_set_error(nexus->session, MSN_ERROR_AUTH,
_("nexus stream error"));
return;
}
if (str) {
char *field;
str[terminator_pos] = '\0';
if ((field = get_field(str, "PassportURLs: "))) {
char *da_login;
da_login = strstr(field, "DALogin="******"DALogin="******"msnia.login.live.com");
#endif
}
}
g_free(str);
if (nexus->login_host) {
PnSslConn *ssl_conn;
PnNode *conn;
ssl_conn = pn_ssl_conn_new("login", PN_NODE_NULL);
conn = PN_NODE(ssl_conn);
conn->session = nexus->session;
if (nexus->error_handler)
g_signal_handler_disconnect(nexus->conn, nexus->error_handler);
if (nexus->open_handler)
g_signal_handler_disconnect(nexus->conn, nexus->open_handler);
g_object_unref(nexus->conn);
pn_parser_free(nexus->parser);
nexus->parser_state = 0;
nexus->parser = pn_parser_new(conn);
pn_ssl_conn_set_read_cb(ssl_conn, login_read_cb, nexus);
nexus->conn = conn;
nexus->open_handler = g_signal_connect(conn, "open", G_CALLBACK(login_open_cb), nexus);
nexus->error_handler = g_signal_connect(conn, "error", G_CALLBACK(close_cb), nexus);
pn_node_connect(conn, nexus->login_host, 443);
return;
}
}
}
}
