static void
http_connection_send_request(PurpleHTTPConnection *conn, const GString *req)
{
char *data;
int ret;
size_t len;
/* Sending something to the server, restart the inactivity timer */
jabber_stream_restart_inactivity_timer(conn->bosh->js);
data = g_strdup_printf("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: %s\r\n"
"Content-Encoding: text/xml; charset=utf-8\r\n"
"Content-Length: %" G_GSIZE_FORMAT "\r\n\r\n"
"%s",
conn->bosh->path, conn->bosh->host, bosh_useragent,
req->len, req->str);
len = strlen(data);
++conn->requests;
++conn->bosh->requests;
if (purple_debug_is_unsafe() && purple_debug_is_verbose())
/* Will contain passwords for SASL PLAIN and is verbose */
purple_debug_misc("jabber", "BOSH (%p): Sending %s\n", conn, data);
else if (purple_debug_is_verbose())
purple_debug_misc("jabber", "BOSH (%p): Sending request of "
"%" G_GSIZE_FORMAT " bytes.\n", conn, len);
if (conn->writeh == 0)
ret = http_connection_do_send(conn, data, len);
else {
ret = -1;
errno = EAGAIN;
}
if (ret < 0 && errno != EAGAIN) {
/*
* TODO: Handle this better. Probably requires a PurpleBOSHConnection
* buffer that stores what is "being sent" until the
* PurpleHTTPConnection reports it is fully sent.
*/
gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
g_strerror(errno));
purple_connection_error_reason(conn->bosh->js->gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
tmp);
g_free(tmp);
return;
} else if (ret < len) {
if (ret < 0)
ret = 0;
if (conn->writeh == 0)
conn->writeh = purple_input_add(conn->psc ? conn->psc->fd : conn->fd,
PURPLE_INPUT_WRITE, http_connection_send_cb, conn);
purple_circ_buffer_append(conn->write_buf, data + ret, len - ret);
}
}
static PurpleHttpRequest *
jabber_bosh_connection_http_request_new(PurpleJabberBOSHConnection *conn,
const GString *data)
{
PurpleHttpRequest *req;
jabber_stream_restart_inactivity_timer(conn->js);
req = purple_http_request_new(conn->url);
purple_http_request_set_keepalive_pool(req, conn->kapool);
purple_http_request_set_method(req, "POST");
purple_http_request_set_timeout(req, JABBER_BOSH_TIMEOUT + 2);
purple_http_request_header_set(req, "User-Agent",
jabber_bosh_useragent);
purple_http_request_header_set(req, "Content-Encoding",
"text/xml; charset=utf-8");
purple_http_request_set_contents(req, data->str, data->len);
return req;
}
static void boot_response_cb(PurpleBOSHConnection *conn, xmlnode *node) {
JabberStream *js = conn->js;
const char *sid, *version;
const char *inactivity, *requests;
xmlnode *packet;
g_return_if_fail(node != NULL);
if (jabber_bosh_connection_error_check(conn, node))
return;
sid = xmlnode_get_attrib(node, "sid");
version = xmlnode_get_attrib(node, "ver");
inactivity = xmlnode_get_attrib(node, "inactivity");
requests = xmlnode_get_attrib(node, "requests");
if (sid) {
conn->sid = g_strdup(sid);
} else {
purple_connection_error_reason(js->gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("No session ID given"));
return;
}
if (version) {
const char *dot = strchr(version, '.');
int major, minor = 0;
purple_debug_info("jabber", "BOSH connection manager version %s\n", version);
major = atoi(version);
if (dot)
minor = atoi(dot + 1);
if (major != 1 || minor < 6) {
purple_connection_error_reason(js->gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("Unsupported version of BOSH protocol"));
return;
}
} else {
purple_debug_info("jabber", "Missing version in BOSH initiation\n");
}
if (inactivity) {
js->max_inactivity = atoi(inactivity);
if (js->max_inactivity <= 5) {
purple_debug_warning("jabber", "Ignoring bogusly small inactivity: %s\n",
inactivity);
/* Leave it at the default */
} else {
/* TODO: Can this check fail? It shouldn't */
js->max_inactivity -= 5; /* rounding */
if (js->inactivity_timer == 0) {
purple_debug_misc("jabber", "Starting BOSH inactivity timer "
"for %d secs (compensating for rounding)\n",
js->max_inactivity);
jabber_stream_restart_inactivity_timer(js);
}
}
}
if (requests)
conn->max_requests = atoi(requests);
jabber_stream_set_state(js, JABBER_STREAM_AUTHENTICATING);
/* FIXME: Depending on receiving features might break with some hosts */
packet = xmlnode_get_child(node, "features");
conn->state = BOSH_CONN_ONLINE;
conn->receive_cb = jabber_bosh_connection_received;
jabber_stream_features_parse(js, packet);
}
static void
jabber_bosh_connection_session_created(PurpleHttpConnection *http_conn,
PurpleHttpResponse *response, gpointer _bosh_conn)
{
PurpleJabberBOSHConnection *bosh_conn = _bosh_conn;
PurpleXmlNode *node, *features;
const gchar *sid, *ver, *inactivity_str;
int inactivity = 0;
bosh_conn->sc_req = NULL;
if (purple_debug_is_verbose() && purple_debug_is_unsafe()) {
purple_debug_misc("jabber-bosh",
"received (session creation): %s\n",
purple_http_response_get_data(response, NULL));
}
node = jabber_bosh_connection_parse(bosh_conn, response);
if (node == NULL)
return;
sid = purple_xmlnode_get_attrib(node, "sid");
ver = purple_xmlnode_get_attrib(node, "ver");
inactivity_str = purple_xmlnode_get_attrib(node, "inactivity");
/* requests = purple_xmlnode_get_attrib(node, "requests"); */
if (!sid) {
purple_connection_error(bosh_conn->js->gc,
PURPLE_CONNECTION_ERROR_OTHER_ERROR,
_("No BOSH session ID given"));
purple_xmlnode_free(node);
return;
}
if (ver == NULL) {
purple_debug_info("jabber-bosh", "Missing version in BOSH initiation\n");
} else if (!jabber_bosh_version_check(ver, 1, 6)) {
purple_debug_error("jabber-bosh",
"Unsupported BOSH version: %s\n", ver);
purple_connection_error(bosh_conn->js->gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("Unsupported version of BOSH protocol"));
purple_xmlnode_free(node);
return;
}
purple_debug_misc("jabber-bosh", "Session created for %p\n", bosh_conn);
bosh_conn->sid = g_strdup(sid);
if (inactivity_str)
inactivity = atoi(inactivity_str);
if (inactivity < 0 || inactivity > 3600) {
purple_debug_warning("jabber-bosh", "Ignoring invalid "
"inactivity value: %s\n", inactivity_str);
inactivity = 0;
}
if (inactivity > 0) {
inactivity -= 5; /* rounding */
if (inactivity <= 0)
inactivity = 1;
bosh_conn->js->max_inactivity = inactivity;
if (bosh_conn->js->inactivity_timer == 0) {
purple_debug_misc("jabber-bosh", "Starting inactivity "
"timer for %d secs (compensating for "
"rounding)\n", inactivity);
jabber_stream_restart_inactivity_timer(bosh_conn->js);
}
}
jabber_stream_set_state(bosh_conn->js, JABBER_STREAM_AUTHENTICATING);
/* FIXME: Depending on receiving features might break with some hosts */
features = purple_xmlnode_get_child(node, "features");
jabber_stream_features_parse(bosh_conn->js, features);
purple_xmlnode_free(node);
jabber_bosh_connection_send(bosh_conn, NULL);
}
