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 void ggp_libgaduw_debug_handler(int level, const char * format,
va_list args)
{
PurpleDebugLevel purple_level;
char *msg;
if ((level & GG_DEBUG_NET) || (level & GG_DEBUG_FUNCTION) ||
(level & GG_DEBUG_VERBOSE))
{
if (!purple_debug_is_verbose())
return;
}
if ((level & GG_DEBUG_DUMP) || /* GG session protocol packets */
(level & GG_DEBUG_TRAFFIC)) /* HTTP traffic */
{
if (!purple_debug_is_verbose() || !purple_debug_is_unsafe())
return;
}
msg = g_strdup_vprintf(format, args);
if (level & GG_DEBUG_ERROR)
purple_level = PURPLE_DEBUG_ERROR;
else if (level & GG_DEBUG_WARNING)
purple_level = PURPLE_DEBUG_WARNING;
else
purple_level = PURPLE_DEBUG_MISC;
purple_debug(purple_level, "gg", "%s", msg);
g_free(msg);
}
static void
request_own_user_display(MsnUser *user)
{
PurpleAccount *account;
MsnSession *session;
MsnObject *my_obj = NULL;
gconstpointer data = NULL;
const char *info = NULL;
size_t len = 0;
if (purple_debug_is_verbose())
purple_debug_info("msn", "Requesting our own user display\n");
session = user->userlist->session;
account = session->account;
my_obj = msn_user_get_object(user);
if (my_obj != NULL) {
PurpleStoredImage *img = msn_object_get_image(my_obj);
data = purple_imgstore_get_data(img);
len = purple_imgstore_get_size(img);
info = msn_object_get_sha1(my_obj);
}
purple_buddy_icons_set_for_user(account, user->passport, g_memdup(data, len), len, info);
/* Free one window slot */
session->userlist->buddy_icon_window++;
if (purple_debug_is_verbose())
purple_debug_info("msn", "msn_request_user_display(): buddy_icon_window++ yields =%d\n",
session->userlist->buddy_icon_window);
msn_release_buddy_icon_request(session->userlist);
}
static void ggp_libgaduw_http_handler(gpointer _req, gint fd,
PurpleInputCondition cond)
{
ggp_libgaduw_http_req *req = _req;
if (req->h->callback(req->h) == -1 || req->h->state == GG_STATE_ERROR) {
purple_debug_error("gg", "ggp_libgaduw_http_handler: failed to "
"make http request: %d\n", req->h->error);
ggp_libgaduw_http_finish(req, FALSE);
return;
}
if (purple_debug_is_verbose()) {
purple_debug_misc("gg", "ggp_libgaduw_http_handler: got fd "
"update [check=%d, state=%d]\n", req->h->check,
req->h->state);
}
if (req->h->state != GG_STATE_DONE) {
purple_input_remove(req->inpa);
req->inpa = ggp_purplew_http_input_add(req->h,
ggp_libgaduw_http_handler, req);
return;
}
if (!req->h->data || !req->h->body) {
purple_debug_error("gg", "ggp_libgaduw_http_handler: got empty "
"http response: %d\n", req->h->error);
ggp_libgaduw_http_finish(req, FALSE);
return;
}
ggp_libgaduw_http_finish(req, TRUE);
}
void
msn_slplink_destroy(MsnSlpLink *slplink)
{
MsnSession *session;
if (purple_debug_is_verbose())
purple_debug_info("msn", "slplink_destroy: slplink(%p)\n", slplink);
g_return_if_fail(slplink != NULL);
if (slplink->swboard != NULL)
slplink->swboard->slplinks = g_list_remove(slplink->swboard->slplinks, slplink);
session = slplink->session;
#if 0
if (slplink->directconn != NULL)
msn_directconn_destroy(slplink->directconn);
#endif
while (slplink->slp_calls != NULL)
msn_slpcall_destroy(slplink->slp_calls->data);
g_queue_free(slplink->slp_msg_queue);
session->slplinks =
g_list_remove(session->slplinks, slplink);
g_free(slplink->remote_user);
g_free(slplink);
}
static void
purple_xfer_destroy(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
g_return_if_fail(xfer != NULL);
if (purple_debug_is_verbose())
purple_debug_info("xfer", "destroyed %p [%d]\n", xfer, xfer->ref);
/* Close the file browser, if it's open */
purple_request_close_with_handle(xfer);
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED)
purple_xfer_cancel_local(xfer);
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->destroy != NULL)
ui_ops->destroy(xfer);
g_free(xfer->who);
g_free(xfer->filename);
g_free(xfer->remote_ip);
g_free(xfer->local_filename);
g_hash_table_remove(xfers_data, xfer);
PURPLE_DBUS_UNREGISTER_POINTER(xfer);
xfers = g_list_remove(xfers, xfer);
g_free(xfer);
}
void
fb_util_vdebug(PurpleDebugLevel level, const gchar *format, va_list ap)
{
gboolean unsafe;
gboolean verbose;
gchar *str;
g_return_if_fail(format != NULL);
unsafe = (level & FB_UTIL_DEBUG_FLAG_UNSAFE) != 0;
verbose = (level & FB_UTIL_DEBUG_FLAG_VERBOSE) != 0;
if ((unsafe && !purple_debug_is_unsafe()) ||
(verbose && !purple_debug_is_verbose()))
{
return;
}
/* Ensure all local flags are removed */
level &= ~FB_UTIL_DEBUG_FLAG_ALL;
str = g_strdup_vprintf(format, ap);
purple_debug(level, "facebook", "%s\n", str);
g_free(str);
}
static void
connection_common_established_cb(PurpleHTTPConnection *conn)
{
purple_debug_misc("jabber", "bosh: httpconn %p re-connected\n", conn);
/* Indicate we're ready and reset some variables */
conn->state = HTTP_CONN_CONNECTED;
if (conn->requests != 0)
purple_debug_error("jabber", "bosh: httpconn %p has %d requests, != 0\n",
conn, conn->requests);
conn->requests = 0;
if (conn->read_buf) {
g_string_free(conn->read_buf, TRUE);
conn->read_buf = NULL;
}
conn->close = FALSE;
conn->headers_done = FALSE;
conn->handled_len = conn->body_len = 0;
if (purple_debug_is_verbose())
debug_dump_http_connections(conn->bosh);
if (conn->bosh->js->reinit)
jabber_bosh_connection_send(conn->bosh, PACKET_NORMAL, NULL);
else if (conn->bosh->state == BOSH_CONN_ONLINE) {
purple_debug_info("jabber", "BOSH session already exists. Trying to reuse it.\n");
if (conn->bosh->requests == 0 || conn->bosh->pending->bufused > 0) {
/* Send the pending data */
jabber_bosh_connection_send(conn->bosh, PACKET_FLUSH, NULL);
}
} else
jabber_bosh_connection_boot(conn->bosh);
}
/*
* This callback will be called when we're the server
* and somebody has connected to us in DC_INCOMING_TIMEOUT seconds.
*/
static void
msn_dc_incoming_connection_cb(gpointer data, gint listenfd, PurpleInputCondition cond)
{
MsnDirectConn *dc = data;
if (purple_debug_is_verbose())
purple_debug_info("msn", "msn_dc_incoming_connection_cb %p\n", dc);
g_return_if_fail(dc != NULL);
if (dc->connect_timeout_handle != 0) {
purple_timeout_remove(dc->connect_timeout_handle);
dc->connect_timeout_handle = 0;
}
if (dc->listenfd_handle != 0) {
purple_input_remove(dc->listenfd_handle);
dc->listenfd_handle = 0;
}
dc->fd = accept(listenfd, NULL, 0);
purple_network_remove_port_mapping(dc->listenfd);
close(dc->listenfd);
dc->listenfd = -1;
if (dc->fd != -1) {
msn_dc_init(dc);
dc->state = DC_STATE_FOO;
}
}
static void
end_user_display(MsnSlpCall *slpcall, MsnSession *session)
{
MsnUserList *userlist;
g_return_if_fail(session != NULL);
if (purple_debug_is_verbose())
purple_debug_info("msn", "End User Display\n");
userlist = session->userlist;
/* If the session is being destroyed we better stop doing anything. */
if (session->destroying)
return;
/* Delay before freeing a buddy icon window slot and requesting the next icon, if appropriate.
* If we don't delay, we'll rapidly hit the MSN equivalent of AIM's rate limiting; the server will
* send us an error 800 like so:
*
* C: NS 000: XFR 21 SB
* S: NS 000: 800 21
*/
if (userlist->buddy_icon_request_timer) {
/* Free the window slot used by this previous request */
userlist->buddy_icon_window++;
/* Clear our pending timeout */
purple_timeout_remove(userlist->buddy_icon_request_timer);
}
/* Wait BUDDY_ICON_DELAY s before freeing our window slot and requesting the next icon. */
userlist->buddy_icon_request_timer = purple_timeout_add_seconds(BUDDY_ICON_DELAY,
msn_release_buddy_icon_request_timeout, userlist);
}
MsnSwitchBoard *
msn_switchboard_new(MsnSession *session)
{
MsnSwitchBoard *swboard;
g_return_val_if_fail(session != NULL, NULL);
swboard = g_new0(MsnSwitchBoard, 1);
swboard->session = session;
swboard->servconn = msn_servconn_new(session, MSN_SERVCONN_SB);
msn_servconn_set_idle_timeout(swboard->servconn, 60);
swboard->cmdproc = swboard->servconn->cmdproc;
swboard->msg_queue = g_queue_new();
swboard->empty = TRUE;
swboard->cmdproc->data = swboard;
swboard->cmdproc->cbs_table = cbs_table;
session->switches = g_list_prepend(session->switches, swboard);
if (purple_debug_is_verbose())
purple_debug_info("msn", "switchboard new: swboard(%p)\n", swboard);
return swboard;
}
static void
msn_slplink_destroy(MsnSlpLink *slplink)
{
MsnSession *session;
if (purple_debug_is_verbose())
purple_debug_info("msn", "slplink_destroy: slplink(%p)\n", slplink);
if (slplink->swboard != NULL) {
slplink->swboard->slplinks = g_list_remove(slplink->swboard->slplinks, slplink);
slplink->swboard = NULL;
}
session = slplink->session;
if (slplink->dc != NULL) {
slplink->dc->slplink = NULL;
msn_dc_destroy(slplink->dc);
slplink->dc = NULL;
}
while (slplink->slp_calls != NULL)
msn_slpcall_destroy(slplink->slp_calls->data);
g_queue_free(slplink->slp_msg_queue);
session->slplinks =
g_list_remove(session->slplinks, slplink);
g_free(slplink->remote_user);
g_free(slplink);
}
static MsnSlpLink *
msn_slplink_new(MsnSession *session, const char *username)
{
MsnSlpLink *slplink;
g_return_val_if_fail(session != NULL, NULL);
slplink = g_new0(MsnSlpLink, 1);
if (purple_debug_is_verbose())
purple_debug_info("msn", "slplink_new: slplink(%p)\n", slplink);
slplink->session = session;
slplink->slp_seq_id = rand() % 0xFFFFFF00 + 4;
slplink->remote_user = g_strdup(username);
slplink->p2p_version = MSN_P2P_VERSION_ONE;
slplink->slp_msg_queue = g_queue_new();
session->slplinks =
g_list_append(session->slplinks, slplink);
return msn_slplink_ref(slplink);
}
/*
* This callback will be called when we're the server
* and nobody has connected us in DC_INCOMING_TIMEOUT seconds
*/
static gboolean
msn_dc_incoming_connection_timeout_cb(gpointer data) {
MsnDirectConn *dc = data;
if (purple_debug_is_verbose())
purple_debug_info("msn", "msn_dc_incoming_connection_timeout_cb %p\n", dc);
g_return_val_if_fail(dc != NULL, FALSE);
if (dc->listen_data != NULL) {
purple_network_listen_cancel(dc->listen_data);
dc->listen_data = NULL;
}
if (dc->listenfd_handle != 0) {
purple_input_remove(dc->listenfd_handle);
dc->listenfd_handle = 0;
}
if (dc->listenfd != -1) {
purple_network_remove_port_mapping(dc->listenfd);
close(dc->listenfd);
dc->listenfd = -1;
}
dc->connect_timeout_handle = 0;
msn_dc_fallback_to_sb(dc);
return FALSE;
}
static void
release_msg(MsnSwitchBoard *swboard, MsnMessage *msg)
{
MsnCmdProc *cmdproc;
MsnTransaction *trans;
char *payload;
gsize payload_len;
char flag;
g_return_if_fail(swboard != NULL);
g_return_if_fail(msg != NULL);
cmdproc = swboard->cmdproc;
payload = msn_message_gen_payload(msg, &payload_len);
if (purple_debug_is_verbose()) {
purple_debug_info("msn", "SB length:{%" G_GSIZE_FORMAT "}\n", payload_len);
msn_message_show_readable(msg, "SB SEND", FALSE);
}
flag = msn_message_get_flag(msg);
trans = msn_transaction_new(cmdproc, "MSG", "%c %" G_GSIZE_FORMAT,
flag, payload_len);
/* Data for callbacks */
msn_transaction_set_data(trans, msg);
if (flag != 'U') {
if (msg->type == MSN_MSG_TEXT)
{
msg->ack_ref = TRUE;
msn_message_ref(msg);
swboard->ack_list = g_list_append(swboard->ack_list, msg);
msn_transaction_set_timeout_cb(trans, msg_timeout);
}
else if (msg->type == MSN_MSG_SLP)
{
msg->ack_ref = TRUE;
msn_message_ref(msg);
swboard->ack_list = g_list_append(swboard->ack_list, msg);
msn_transaction_set_timeout_cb(trans, msg_timeout);
#if 0
if (msg->ack_cb != NULL)
{
msn_transaction_add_cb(trans, "ACK", msg_ack);
msn_transaction_add_cb(trans, "NAK", msg_nak);
}
#endif
}
}
trans->payload = payload;
trans->payload_len = payload_len;
msg->trans = trans;
msn_cmdproc_send_trans(cmdproc, trans);
}
void ggp_avatar_buddy_remove(PurpleConnection *gc, uin_t uin)
{
if (purple_debug_is_verbose()) {
purple_debug_misc("gg", "ggp_avatar_buddy_remove(%p, %u)\n", gc, uin);
}
purple_buddy_icons_set_for_user(purple_connection_get_account(gc),
ggp_uin_to_str(uin), NULL, 0, NULL);
}
static void
jabber_bosh_connection_send_now(PurpleJabberBOSHConnection *conn)
{
PurpleHttpRequest *req;
GString *data;
g_return_if_fail(conn != NULL);
if (conn->send_timer != 0) {
purple_timeout_remove(conn->send_timer);
conn->send_timer = 0;
}
if (conn->sid == NULL)
return;
data = g_string_new(NULL);
/* missing parameters: route, from, ack */
g_string_printf(data, "<body "
"rid='%" G_GUINT64_FORMAT "' "
"sid='%s' "
"xmlns='" NS_BOSH "' "
"xmlns:xmpp='" NS_XMPP_BOSH "' ",
++conn->rid, conn->sid);
if (conn->js->reinit && !conn->is_terminating) {
g_string_append(data, "xmpp:restart='true'/>");
conn->js->reinit = FALSE;
} else {
if (conn->is_terminating)
g_string_append(data, "type='terminate' ");
g_string_append_c(data, '>');
g_string_append_len(data, conn->send_buff->str,
conn->send_buff->len);
g_string_append(data, "</body>");
g_string_set_size(conn->send_buff, 0);
}
if (purple_debug_is_verbose() && purple_debug_is_unsafe())
purple_debug_misc("jabber-bosh", "sending: %s\n", data->str);
req = jabber_bosh_connection_http_request_new(conn, data);
g_string_free(data, TRUE);
if (conn->is_terminating) {
purple_http_request(NULL, req, NULL, NULL);
g_free(conn->sid);
conn->sid = NULL;
} else {
purple_http_connection_set_add(conn->payload_reqs,
purple_http_request(conn->js->gc, req,
jabber_bosh_connection_recv, conn));
}
purple_http_request_unref(req);
}
static PurpleHTTPConnection *
find_available_http_connection(PurpleBOSHConnection *conn)
{
int i;
if (purple_debug_is_verbose())
debug_dump_http_connections(conn);
/* Easy solution: Does everyone involved support pipelining? Hooray! Just use
* one TCP connection! */
if (conn->pipelining)
return conn->connections[0]->state == HTTP_CONN_CONNECTED ?
conn->connections[0] : NULL;
/* First loop, look for a connection that's ready */
for (i = 0; i < NUM_HTTP_CONNECTIONS; ++i) {
if (conn->connections[i] &&
conn->connections[i]->state == HTTP_CONN_CONNECTED &&
conn->connections[i]->requests == 0)
return conn->connections[i];
}
/* Second loop, is something currently connecting? If so, just queue up. */
for (i = 0; i < NUM_HTTP_CONNECTIONS; ++i) {
if (conn->connections[i] &&
conn->connections[i]->state == HTTP_CONN_CONNECTING)
return NULL;
}
/* Third loop, is something offline that we can connect? */
for (i = 0; i < NUM_HTTP_CONNECTIONS; ++i) {
if (conn->connections[i] &&
conn->connections[i]->state == HTTP_CONN_OFFLINE) {
purple_debug_info("jabber", "bosh: Reconnecting httpconn "
"(%i, %p)\n", i, conn->connections[i]);
http_connection_connect(conn->connections[i]);
return NULL;
}
}
/* Fourth loop, look for one that's NULL and create a new connection */
for (i = 0; i < NUM_HTTP_CONNECTIONS; ++i) {
if (!conn->connections[i]) {
conn->connections[i] = jabber_bosh_http_connection_init(conn);
purple_debug_info("jabber", "bosh: Creating and connecting new httpconn "
"(%i, %p)\n", i, conn->connections[i]);
http_connection_connect(conn->connections[i]);
return NULL;
}
}
purple_debug_warning("jabber", "Could not find a HTTP connection!\n");
/* None available. */
return NULL;
}
void
purple_xfer_ref(PurpleXfer *xfer)
{
g_return_if_fail(xfer != NULL);
xfer->ref++;
if (purple_debug_is_verbose())
purple_debug_info("xfer", "ref'd %p [%d]\n", xfer, xfer->ref);
}
static PurpleHTTPConnection *
find_available_http_connection(PurpleBOSHConnection *conn)
{
int i;
if (purple_debug_is_verbose()) {
for (i = 0; i < NUM_HTTP_CONNECTIONS; ++i) {
PurpleHTTPConnection *httpconn = conn->connections[i];
if (httpconn == NULL)
purple_debug_misc("jabber", "BOSH %p->connections[%d] = (nil)\n",
conn, i);
else
purple_debug_misc("jabber", "BOSH %p->connections[%d] = %p, state = %d"
", requests = %d\n", conn, i, httpconn,
httpconn->state, httpconn->requests);
}
}
/* Easy solution: Does everyone involved support pipelining? Hooray! Just use
* one TCP connection! */
if (conn->pipelining)
return conn->connections[0]->state == HTTP_CONN_CONNECTED ?
conn->connections[0] : NULL;
/* First loop, look for a connection that's ready */
for (i = 0; i < NUM_HTTP_CONNECTIONS; ++i) {
if (conn->connections[i] &&
conn->connections[i]->state == HTTP_CONN_CONNECTED &&
conn->connections[i]->requests == 0)
return conn->connections[i];
}
/* Second loop, is something currently connecting? If so, just queue up. */
for (i = 0; i < NUM_HTTP_CONNECTIONS; ++i) {
if (conn->connections[i] &&
conn->connections[i]->state == HTTP_CONN_CONNECTING)
return NULL;
}
/* Third loop, look for one that's NULL and create a new connection */
for (i = 0; i < NUM_HTTP_CONNECTIONS; ++i) {
if (!conn->connections[i]) {
purple_debug_info("jabber", "bosh: Creating and connecting new httpconn\n");
conn->connections[i] = jabber_bosh_http_connection_init(conn);
http_connection_connect(conn->connections[i]);
return NULL;
}
}
purple_debug_warning("jabber", "Could not find a HTTP connection!\n");
/* None available. */
return NULL;
}
static void ggp_pubdir_set_info_got_token(PurpleConnection *gc,
const gchar *token, gpointer _record)
{
PurpleHttpRequest *req;
ggp_pubdir_record *record = _record;
gchar *request_data;
gchar *name, *surname, *city;
uin_t uin = record->uin;
PURPLE_ASSERT_CONNECTION_IS_VALID(gc);
if (!token) {
/* TODO: notify about failure */
ggp_pubdir_record_free(record, 1);
return;
}
name = g_uri_escape_string(record->first_name, NULL, FALSE);
surname = g_uri_escape_string(record->last_name, NULL, FALSE);
city = g_uri_escape_string(record->city, NULL, FALSE);
request_data = g_strdup_printf(
"name=%s&"
"surname=%s&"
"birth=%sT10:00:00%%2B00:00&"
"birth_priv=2&"
"gender=%d&"
"gender_priv=2&"
"city=%s&"
"province=%d",
name, surname,
ggp_date_strftime("%Y-%m-%d", record->birth),
record->gender,
city,
record->province);
if (purple_debug_is_verbose() && purple_debug_is_unsafe()) {
purple_debug_misc("gg", "ggp_pubdir_set_info_got_token: "
"query [%s]\n", request_data);
}
req = purple_http_request_new(NULL);
purple_http_request_set_method(req, "PUT");
purple_http_request_set_url_printf(req,
"http://api.gadu-gadu.pl/users/%u.xml", uin);
purple_http_request_header_set(req, "Authorization", token);
purple_http_request_header_set(req, "Content-Type",
"application/x-www-form-urlencoded");
purple_http_request_set_contents(req, request_data, -1);
purple_http_request(gc, req, ggp_pubdir_set_info_got_response, NULL);
purple_http_request_unref(req);
g_free(request_data);
ggp_pubdir_record_free(record, 1);
}
MsnSlpLink *
msn_slplink_ref(MsnSlpLink *slplink)
{
g_return_val_if_fail(slplink != NULL, NULL);
slplink->refs++;
if (purple_debug_is_verbose())
purple_debug_info("msn", "slplink ref (%p)[%d]\n", slplink, slplink->refs);
return slplink;
}
MsnMessage *
msn_message_ref(MsnMessage *msg)
{
g_return_val_if_fail(msg != NULL, NULL);
msg->ref_count++;
if (purple_debug_is_verbose())
purple_debug_info("msn", "message ref (%p)[%u]\n", msg, msg->ref_count);
return msg;
}
void
msn_slplink_unref(MsnSlpLink *slplink)
{
g_return_if_fail(slplink != NULL);
slplink->refs--;
if (purple_debug_is_verbose())
purple_debug_info("msn", "slplink unref (%p)[%d]\n", slplink, slplink->refs);
if (slplink->refs == 0)
msn_slplink_destroy(slplink);
}
static void ggp_ggdrive_auth_done(PurpleHttpConnection *hc,
PurpleHttpResponse *response, gpointer user_data)
{
PurpleConnection *gc = purple_http_conn_get_purple_connection(hc);
ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc);
JsonParser *parser;
JsonObject *result;
int status = -1;
g_return_if_fail(sdata != NULL);
sdata->auth_request = NULL;
if (!purple_http_response_is_successful(response)) {
purple_debug_misc("gg", "ggp_ggdrive_auth_done: authentication "
"failed due to unsuccessful request (code = %d)\n",
purple_http_response_get_code(response));
ggp_ggdrive_auth_results(gc, FALSE);
return;
}
parser = ggp_json_parse(purple_http_response_get_data(response, NULL));
result = json_node_get_object(json_parser_get_root(parser));
result = json_object_get_object_member(result, "result");
if (json_object_has_member(result, "status"))
status = json_object_get_int_member(result, "status");
g_object_unref(parser);
if (status != 0 ) {
purple_debug_misc("gg", "ggp_ggdrive_auth_done: authentication "
"failed due to bad result (status=%d)\n", status);
if (purple_debug_is_verbose())
purple_debug_misc("gg", "ggp_ggdrive_auth_done: "
"result = %s\n",
purple_http_response_get_data(response, NULL));
ggp_ggdrive_auth_results(gc, FALSE);
return;
}
sdata->security_token = g_strdup(purple_http_response_get_header(
response, "X-gged-security-token"));
if (!sdata->security_token) {
purple_debug_misc("gg", "ggp_ggdrive_auth_done: authentication "
"failed due to missing security token header\n");
ggp_ggdrive_auth_results(gc, FALSE);
return;
}
if (purple_debug_is_unsafe())
purple_debug_misc("gg", "ggp_ggdrive_auth_done: "
"security_token=%s\n", sdata->security_token);
ggp_ggdrive_auth_results(gc, TRUE);
}
static void
purple_xfer_set_status(PurpleXfer *xfer, PurpleXferStatusType status)
{
g_return_if_fail(xfer != NULL);
if (purple_debug_is_verbose())
purple_debug_info("xfer", "Changing status of xfer %p from %s to %s\n",
xfer, purple_xfer_status_type_to_string(xfer->status),
purple_xfer_status_type_to_string(status));
if (xfer->status == status)
return;
xfer->status = status;
if(xfer->type == PURPLE_XFER_SEND) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-send-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-send-cancel", xfer);
break;
default:
break;
}
} else if(xfer->type == PURPLE_XFER_RECEIVE) {
switch(status) {
case PURPLE_XFER_STATUS_ACCEPTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-accept", xfer);
break;
case PURPLE_XFER_STATUS_STARTED:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-start", xfer);
break;
case PURPLE_XFER_STATUS_DONE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-complete", xfer);
break;
case PURPLE_XFER_STATUS_CANCEL_LOCAL:
case PURPLE_XFER_STATUS_CANCEL_REMOTE:
purple_signal_emit(purple_xfers_get_handle(), "file-recv-cancel", xfer);
break;
default:
break;
}
}
}
gboolean
purple_keyring_export_password(PurpleAccount *account, const gchar **keyring_id,
const gchar **mode, gchar **data, GError **error,
GDestroyNotify *destroy)
{
PurpleKeyring *inuse;
PurpleKeyringExportPassword export;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(keyring_id != NULL, FALSE);
g_return_val_if_fail(mode != NULL, FALSE);
g_return_val_if_fail(data != NULL, FALSE);
g_return_val_if_fail(error != NULL, FALSE);
inuse = purple_keyring_get_inuse();
if (inuse == NULL) {
PurpleKeyringFailedImport *import = g_hash_table_lookup(
purple_keyring_failed_imports, account);
if (import == NULL) {
*error = g_error_new(PURPLE_KEYRING_ERROR,
PURPLE_KEYRING_ERROR_NOKEYRING,
_("No keyring configured, cannot export "
"password info."));
purple_debug_warning("keyring",
"No keyring configured, cannot export password "
"info.\n");
return FALSE;
} else {
purple_debug_info("keyring", "No keyring configured, "
"getting fallback export data for %s.\n",
purple_keyring_print_account(account));
*keyring_id = import->keyring_id;
*mode = import->mode;
*data = g_strdup(import->data);
*destroy = (GDestroyNotify)purple_str_wipe;
return TRUE;
}
}
if (purple_debug_is_verbose()) {
purple_debug_misc("keyring",
"Exporting password for account %s from keyring %s\n",
purple_keyring_print_account(account),
purple_keyring_get_id(inuse));
}
*keyring_id = purple_keyring_get_id(inuse);
export = purple_keyring_get_export_password(inuse);
int irc_send_len(struct irc_conn *irc, const char *buf, int buflen)
{
int ret;
char *tosend = g_strdup(buf);
purple_signal_emit(_irc_plugin, "irc-sending-text", purple_account_get_connection(irc->account), &tosend);
if (tosend == NULL)
return 0;
if (!purple_strequal(tosend, buf)) {
buflen = strlen(tosend);
}
if (purple_debug_is_verbose()) {
char *clean = purple_utf8_salvage(tosend);
clean = g_strstrip(clean);
purple_debug_misc("irc", "<< %s\n", clean);
g_free(clean);
}
/* If we're not buffering writes, try to send immediately */
if (!irc->writeh)
ret = do_send(irc, tosend, buflen);
else {
ret = -1;
errno = EAGAIN;
}
/* purple_debug(PURPLE_DEBUG_MISC, "irc", "sent%s: %s",
irc->gsc ? " (ssl)" : "", tosend); */
if (ret <= 0 && errno != EAGAIN) {
PurpleConnection *gc = purple_account_get_connection(irc->account);
gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
g_strerror(errno));
purple_connection_error_reason (gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
g_free(tmp);
} else if (ret < buflen) {
if (ret < 0)
ret = 0;
if (!irc->writeh)
irc->writeh = purple_input_add(
irc->gsc ? irc->gsc->fd : irc->fd,
PURPLE_INPUT_WRITE, irc_send_cb, irc);
purple_circ_buffer_append(irc->outbuf, tosend + ret,
buflen - ret);
}
g_free(tosend);
return ret;
}
void
purple_xfer_unref(PurpleXfer *xfer)
{
g_return_if_fail(xfer != NULL);
g_return_if_fail(xfer->ref > 0);
xfer->ref--;
if (purple_debug_is_verbose())
purple_debug_info("xfer", "unref'd %p [%d]\n", xfer, xfer->ref);
if (xfer->ref == 0)
purple_xfer_destroy(xfer);
}
static void
msn_dc_send_foo(MsnDirectConn *dc)
{
MsnDirectConnPacket *p;
if (purple_debug_is_verbose())
purple_debug_info("msn", "msn_dc_send_foo %p\n", dc);
p = msn_dc_new_packet(4);
memcpy(p->data, "foo\0", 4);
msn_dc_enqueue_packet(dc, p);
}
