static void
nexus_write_cb(gpointer data, gint source, PurpleInputCondition cond)
{
MsnNexus *nexus = data;
gssize len, total_len;
total_len = strlen(nexus->write_buf);
len = purple_ssl_write(nexus->gsc,
nexus->write_buf + nexus->written_len,
total_len - nexus->written_len);
if (len < 0 && errno == EAGAIN)
return;
else if (len <= 0) {
purple_input_remove(nexus->input_handler);
nexus->input_handler = 0;
/* TODO: notify of the error */
return;
}
nexus->written_len += len;
if (nexus->written_len < total_len)
return;
purple_input_remove(nexus->input_handler);
nexus->input_handler = 0;
g_free(nexus->write_buf);
nexus->write_buf = NULL;
nexus->written_len = 0;
nexus->written_cb(nexus, source, 0);
}
void
msn_servconn_destroy(MsnServConn *servconn)
{
g_return_if_fail(servconn != NULL);
if (servconn->processing)
{
servconn->wasted = TRUE;
return;
}
msn_servconn_disconnect(servconn);
if (servconn->destroy_cb)
servconn->destroy_cb(servconn);
if (servconn->httpconn != NULL)
msn_httpconn_destroy(servconn->httpconn);
g_free(servconn->host);
purple_circ_buffer_destroy(servconn->tx_buf);
if (servconn->tx_handler > 0)
purple_input_remove(servconn->tx_handler);
if (servconn->timeout_handle > 0)
purple_input_remove(servconn->timeout_handle);
msn_cmdproc_destroy(servconn->cmdproc);
g_free(servconn);
}
/**
* Close (but not free) a connection.
*
* This cancels any currently pending connection attempt,
* closes any open fd and frees the auth cookie.
*
* @param conn The connection to close.
*/
void
flap_connection_close(OscarData *od, FlapConnection *conn)
{
if (conn->connect_data != NULL)
{
purple_proxy_connect_cancel(conn->connect_data);
conn->connect_data = NULL;
}
if (conn->gsc != NULL && conn->gsc->connect_data != NULL)
{
purple_ssl_close(conn->gsc);
conn->gsc = NULL;
}
if (conn->new_conn_data != NULL)
{
if (conn->type == SNAC_FAMILY_CHAT)
{
oscar_chat_destroy(conn->new_conn_data);
conn->new_conn_data = NULL;
}
}
if ((conn->fd >= 0 || conn->gsc != NULL)
&& conn->type == SNAC_FAMILY_LOCATE)
flap_connection_send_close(od, conn);
if (conn->watcher_incoming != 0)
{
purple_input_remove(conn->watcher_incoming);
conn->watcher_incoming = 0;
}
if (conn->watcher_outgoing != 0)
{
purple_input_remove(conn->watcher_outgoing);
conn->watcher_outgoing = 0;
}
if (conn->fd >= 0)
{
close(conn->fd);
conn->fd = -1;
}
if (conn->gsc != NULL)
{
purple_ssl_close(conn->gsc);
conn->gsc = NULL;
}
g_free(conn->buffer_incoming.data.data);
conn->buffer_incoming.data.data = NULL;
purple_circ_buffer_destroy(conn->buffer_outgoing);
conn->buffer_outgoing = NULL;
}
static void http_connection_disconnected(PurpleHTTPConnection *conn)
{
gboolean had_requests = FALSE;
/*
* Well, then. Fine! I never liked you anyway, server! I was cheating on you
* with AIM!
*/
conn->state = HTTP_CONN_OFFLINE;
if (conn->psc) {
purple_ssl_close(conn->psc);
conn->psc = NULL;
} else if (conn->fd >= 0) {
close(conn->fd);
conn->fd = -1;
}
if (conn->readh) {
purple_input_remove(conn->readh);
conn->readh = 0;
}
if (conn->writeh) {
purple_input_remove(conn->writeh);
conn->writeh = 0;
}
had_requests = (conn->requests > 0);
if (had_requests && conn->read_buf->len == 0) {
purple_debug_error("jabber", "bosh: Adjusting BOSHconn requests (%d) to %d\n",
conn->bosh->requests, conn->bosh->requests - conn->requests);
conn->bosh->requests -= conn->requests;
conn->requests = 0;
}
if (conn->bosh->pipelining) {
/* Hmmmm, fall back to multiple connections */
jabber_bosh_disable_pipelining(conn->bosh);
}
if (!had_requests)
/* If the server disconnected us without any requests, let's
* just wait until we have something to send before we reconnect
*/
return;
if (++conn->bosh->failed_connections == MAX_FAILED_CONNECTIONS) {
purple_connection_error_reason(conn->bosh->js->gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("Unable to establish a connection with the server"));
} else {
/* No! Please! Take me back. It was me, not you! I was weak! */
http_connection_connect(conn);
}
}
void
msn_servconn_disconnect(MsnServConn *servconn)
{
g_return_if_fail(servconn != NULL);
if (servconn->connect_data != NULL)
{
purple_proxy_connect_cancel(servconn->connect_data);
servconn->connect_data = NULL;
}
if (!servconn->connected)
{
/* We could not connect. */
if (servconn->disconnect_cb != NULL)
servconn->disconnect_cb(servconn);
return;
}
if (servconn->session->http_method)
{
/* Fake disconnection. */
if (servconn->disconnect_cb != NULL)
servconn->disconnect_cb(servconn);
return;
}
if (servconn->inpa > 0)
{
purple_input_remove(servconn->inpa);
servconn->inpa = 0;
}
if (servconn->timeout_handle > 0)
{
purple_input_remove(servconn->timeout_handle);
servconn->timeout_handle = 0;
}
close(servconn->fd);
servconn->rx_buf = NULL;
servconn->rx_len = 0;
servconn->payload_len = 0;
servconn->connected = FALSE;
if (servconn->disconnect_cb != NULL)
servconn->disconnect_cb(servconn);
}
/* just in case you were wondering, this is why DCC is gay */
static void irc_dccsend_send_read(gpointer data, int source, PurpleInputCondition cond)
{
PurpleXfer *xfer = data;
struct irc_xfer_send_data *xd = purple_xfer_get_protocol_data(xfer);
char buffer[64];
int len;
len = read(source, buffer, sizeof(buffer));
if (len < 0 && errno == EAGAIN)
return;
else if (len <= 0) {
/* XXX: Shouldn't this be canceling the transfer? */
purple_input_remove(xd->inpa);
xd->inpa = 0;
return;
}
xd->rxqueue = g_realloc(xd->rxqueue, len + xd->rxlen);
memcpy(xd->rxqueue + xd->rxlen, buffer, len);
xd->rxlen += len;
while (1) {
gint32 val;
size_t acked;
if (xd->rxlen < 4)
break;
memcpy(&val, xd->rxqueue, sizeof(val));
acked = ntohl(val);
xd->rxlen -= 4;
if (xd->rxlen) {
unsigned char *tmp = g_memdup(xd->rxqueue + 4, xd->rxlen);
g_free(xd->rxqueue);
xd->rxqueue = tmp;
} else {
g_free(xd->rxqueue);
xd->rxqueue = NULL;
}
if ((goffset)acked >= purple_xfer_get_size(xfer)) {
purple_input_remove(xd->inpa);
xd->inpa = 0;
purple_xfer_set_completed(xfer, TRUE);
purple_xfer_end(xfer);
return;
}
}
}
static void http_connection_disconnected(PurpleHTTPConnection *conn)
{
/*
* Well, then. Fine! I never liked you anyway, server! I was cheating on you
* with AIM!
*/
conn->state = HTTP_CONN_OFFLINE;
if (conn->psc) {
purple_ssl_close(conn->psc);
conn->psc = NULL;
} else if (conn->fd >= 0) {
close(conn->fd);
conn->fd = -1;
}
if (conn->readh) {
purple_input_remove(conn->readh);
conn->readh = 0;
}
if (conn->writeh) {
purple_input_remove(conn->writeh);
conn->writeh = 0;
}
if (conn->requests > 0 && conn->read_buf->len == 0) {
purple_debug_error("jabber", "bosh: Adjusting BOSHconn requests (%d) to %d\n",
conn->bosh->requests, conn->bosh->requests - conn->requests);
conn->bosh->requests -= conn->requests;
conn->requests = 0;
}
if (conn->bosh->pipelining) {
/* Hmmmm, fall back to multiple connections */
conn->bosh->pipelining = FALSE;
if (conn->bosh->connections[1] == NULL) {
conn->bosh->connections[1] = jabber_bosh_http_connection_init(conn->bosh);
http_connection_connect(conn->bosh->connections[1]);
}
}
if (++conn->bosh->failed_connections == MAX_FAILED_CONNECTIONS) {
purple_connection_error_reason(conn->bosh->js->gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("Unable to establish a connection with the server"));
} else {
/* No! Please! Take me back. It was me, not you! I was weak! */
http_connection_connect(conn);
}
}
static void irc_close(PurpleConnection *gc)
{
struct irc_conn *irc = gc->proto_data;
if (irc == NULL)
return;
if (irc->gsc || (irc->fd >= 0))
irc_cmd_quit(irc, "quit", NULL, NULL);
if (gc->inpa)
purple_input_remove(gc->inpa);
g_free(irc->inbuf);
if (irc->gsc) {
purple_ssl_close(irc->gsc);
} else if (irc->fd >= 0) {
close(irc->fd);
}
if (irc->timer)
purple_timeout_remove(irc->timer);
g_hash_table_destroy(irc->cmds);
g_hash_table_destroy(irc->msgs);
g_hash_table_destroy(irc->buddies);
if (irc->motd)
g_string_free(irc->motd, TRUE);
g_free(irc->server);
if (irc->writeh)
purple_input_remove(irc->writeh);
purple_circ_buffer_destroy(irc->outbuf);
g_free(irc->mode_chars);
g_free(irc->reqnick);
#ifdef HAVE_CYRUS_SASL
if (irc->sasl_conn) {
sasl_dispose(&irc->sasl_conn);
irc->sasl_conn = NULL;
}
g_free(irc->sasl_cb);
if(irc->sasl_mechs)
g_string_free(irc->sasl_mechs, TRUE);
#endif
g_free(irc);
}
/*
* 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
msn_dc_send_cb(gpointer data, gint fd, PurpleInputCondition cond)
{
MsnDirectConn *dc = data;
MsnDirectConnPacket *p;
int bytes_to_send;
int bytes_sent;
g_return_if_fail(dc != NULL);
g_return_if_fail(fd != -1);
if (g_queue_is_empty(dc->out_queue)) {
if (dc->send_handle != 0) {
purple_input_remove(dc->send_handle);
dc->send_handle = 0;
}
return;
}
p = g_queue_peek_head(dc->out_queue);
if (dc->msg_pos < 0) {
/* First we send the length of the packet */
guint32 len = GUINT32_TO_LE(p->length);
bytes_sent = send(fd, &len, 4, 0);
if (bytes_sent < 0) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
return;
purple_debug_warning("msn", "msn_dc_send_cb: send error\n");
msn_dc_destroy(dc);
return;
}
dc->msg_pos = 0;
}
bytes_to_send = p->length - dc->msg_pos;
bytes_sent = send(fd, p->data + dc->msg_pos, bytes_to_send, 0);
if (bytes_sent < 0) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
return;
purple_debug_warning("msn", "msn_dc_send_cb: send error\n");
msn_dc_destroy(dc);
return;
}
dc->progress = TRUE;
dc->msg_pos += bytes_sent;
if (dc->msg_pos == p->length) {
if (p->sent_cb != NULL)
p->sent_cb(p);
g_queue_pop_head(dc->out_queue);
msn_dc_destroy_packet(p);
dc->msg_pos = -1;
}
}
static void ycht_packet_send_write_cb(gpointer data, gint source, PurpleInputCondition cond)
{
YchtConn *ycht = data;
int ret, writelen;
const gchar *output = NULL;
writelen = purple_circular_buffer_get_max_read(ycht->txbuf);
if (writelen == 0) {
purple_input_remove(ycht->tx_handler);
ycht->tx_handler = 0;
return;
}
output = purple_circular_buffer_get_output(ycht->txbuf);
ret = write(ycht->fd, output, writelen);
if (ret < 0 && errno == EAGAIN)
return;
else if (ret <= 0) {
/* TODO: error handling */
/*
gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
g_strerror(errno));
purple_connection_error(purple_account_get_connection(irc->account),
PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
g_free(tmp);
*/
return;
}
purple_circular_buffer_mark_read(ycht->txbuf, ret);
}
void
purple_ssl_close(PurpleSslConnection *gsc)
{
PurpleSslOps *ops;
g_return_if_fail(gsc != NULL);
purple_request_close_with_handle(gsc);
purple_notify_close_with_handle(gsc);
ops = purple_ssl_get_ops();
(ops->close)(gsc);
if (gsc->connect_data != NULL)
purple_proxy_connect_cancel(gsc->connect_data);
if (gsc->inpa > 0)
purple_input_remove(gsc->inpa);
if (gsc->fd >= 0)
close(gsc->fd);
g_free(gsc->host);
g_free(gsc);
}
void UploadPortrait_cb(gpointer data, gint source, const gchar * error_message)
{
struct fetion_account_data *sip = data;
gsize max_write;
gssize written;
max_write = purple_circ_buffer_get_max_read(sip->icon_buf);
if (max_write == 0) {
purple_input_remove(sip->icon_handler);
sip->icon_handler = 0;
return;
}
written = write(source, sip->icon_buf->outptr, max_write);
purple_debug_info("fetion:", "UploadPortrait[%d][%d]", max_write,
written);
if (written < 0 && errno == EAGAIN)
written = 0;
else if (written <= 0) {
/*TODO: do we really want to disconnect on a failure to write? */
purple_connection_error_reason(sip->gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("Could not write"));
return;
}
purple_circ_buffer_mark_read(sip->icon_buf, written);
}
void steam_connection_destroy(SteamConnection *steamcon)
{
steamcon->sa->conns = g_slist_remove(steamcon->sa->conns, steamcon);
if (steamcon->request != NULL)
g_string_free(steamcon->request, TRUE);
g_free(steamcon->rx_buf);
if (steamcon->connect_data != NULL)
purple_proxy_connect_cancel(steamcon->connect_data);
if (steamcon->ssl_conn != NULL)
purple_ssl_close(steamcon->ssl_conn);
if (steamcon->fd >= 0) {
close(steamcon->fd);
}
if (steamcon->input_watcher > 0)
purple_input_remove(steamcon->input_watcher);
g_free(steamcon->url);
g_free(steamcon->hostname);
g_free(steamcon);
}
static gboolean
purple_upnp_discover_timeout(gpointer data)
{
UPnPDiscoveryData* dd = data;
if (dd->inpa)
purple_input_remove(dd->inpa);
if (dd->tima > 0)
purple_timeout_remove(dd->tima);
dd->inpa = 0;
dd->tima = 0;
if (dd->retry_count < NUM_UDP_ATTEMPTS) {
/* TODO: We probably shouldn't be incrementing retry_count in two places */
dd->retry_count++;
purple_upnp_discover_send_broadcast(dd);
} else {
if (dd->fd != -1)
close(dd->fd);
control_info.status = PURPLE_UPNP_STATUS_UNABLE_TO_DISCOVER;
control_info.lookup_time = time(NULL);
control_info.service_type[0] = '\0';
g_free(control_info.control_url);
control_info.control_url = NULL;
fire_discovery_callbacks(FALSE);
g_free(dd);
}
return FALSE;
}
void
purple_xfer_end(PurpleXfer *xfer)
{
g_return_if_fail(xfer != NULL);
/* See if we are actually trying to cancel this. */
if (!purple_xfer_is_completed(xfer)) {
purple_xfer_cancel_local(xfer);
return;
}
xfer->end_time = time(NULL);
if (xfer->ops.end != NULL)
xfer->ops.end(xfer);
if (xfer->watcher != 0) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
if (xfer->fd != -1)
close(xfer->fd);
if (xfer->dest_fp != NULL) {
fclose(xfer->dest_fp);
xfer->dest_fp = NULL;
}
purple_xfer_unref(xfer);
}
static void
ssl_openssl_close(PurpleSslConnection *gsc)
{
PurpleSslOpensslData *openssl_data = PURPLE_SSL_OPENSSL_DATA(gsc);
int i;
if (openssl_data == NULL)
return;
if (openssl_data->handshake_handler)
purple_input_remove(openssl_data->handshake_handler);
if (openssl_data->ssl != NULL) {
i = SSL_shutdown(openssl_data->ssl);
if (i == 0)
SSL_shutdown(openssl_data->ssl);
SSL_free(openssl_data->ssl);
}
if (openssl_data->ssl_ctx != NULL)
SSL_CTX_free(openssl_data->ssl_ctx);
g_free(openssl_data);
gsc->private_data = NULL;
}
void
sevencup_connection_close(SevenCupConnection *scon)
{
scon->sa->conns = g_slist_remove(scon->sa->conns, scon);
if (scon->connect_data != NULL) {
purple_proxy_connect_cancel(scon->connect_data);
scon->connect_data = NULL;
}
if (scon->ssl_conn != NULL) {
purple_ssl_close(scon->ssl_conn);
scon->ssl_conn = NULL;
}
if (scon->fd >= 0) {
close(scon->fd);
scon->fd = -1;
}
if (scon->input_watcher > 0) {
purple_input_remove(scon->input_watcher);
scon->input_watcher = 0;
}
purple_timeout_remove(scon->timeout_watcher);
g_free(scon->rx_buf);
scon->rx_buf = NULL;
scon->rx_len = 0;
}
static void
irc_send_cb(gpointer data, gint source, PurpleInputCondition cond)
{
struct irc_conn *irc = data;
int ret, writelen;
writelen = purple_circ_buffer_get_max_read(irc->outbuf);
if (writelen == 0) {
purple_input_remove(irc->writeh);
irc->writeh = 0;
return;
}
ret = do_send(irc, irc->outbuf->outptr, writelen);
if (ret < 0 && errno == EAGAIN)
return;
else if (ret <= 0) {
purple_connection_error(purple_account_get_connection(irc->account),
_("Server has disconnected"));
return;
}
purple_circ_buffer_mark_read(irc->outbuf, ret);
#if 0
/* We *could* try to write more if we wrote it all */
if (ret == write_len) {
irc_send_cb(data, source, cond);
}
#endif
}
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);
g_free(wconn);
}
/*
* 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
http_connection_send_cb(gpointer data, gint source, PurpleInputCondition cond)
{
PurpleHTTPConnection *conn = data;
int ret;
int writelen = purple_circ_buffer_get_max_read(conn->write_buf);
if (writelen == 0) {
purple_input_remove(conn->writeh);
conn->writeh = 0;
return;
}
ret = http_connection_do_send(conn, conn->write_buf->outptr, writelen);
if (ret < 0 && errno == EAGAIN)
return;
else if (ret <= 0) {
/*
* 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;
}
purple_circ_buffer_mark_read(conn->write_buf, ret);
}
static void
_start_stream(gpointer data, gint source, PurpleInputCondition condition)
{
BonjourJabberConversation *bconv = data;
struct _stream_start_data *ss = bconv->stream_data;
int len, ret;
len = strlen(ss->msg);
/* Start Stream */
ret = send(source, ss->msg, len, 0);
if (ret == -1 && errno == EAGAIN)
return;
else if (ret <= 0) {
const char *err = g_strerror(errno);
PurpleConversation *conv;
const char *bname = bconv->buddy_name;
BonjourBuddy *bb = NULL;
if(bconv->pb) {
bb = purple_buddy_get_protocol_data(bconv->pb);
bname = purple_buddy_get_name(bconv->pb);
}
purple_debug_error("bonjour", "Error starting stream with buddy %s at %s error: %s\n",
bname ? bname : "(unknown)", bconv->ip, err ? err : "(null)");
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, bname, bconv->account);
if (conv != NULL)
purple_conversation_write(conv, NULL,
_("Unable to send the message, the conversation couldn't be started."),
PURPLE_MESSAGE_SYSTEM, time(NULL));
bonjour_jabber_close_conversation(bconv);
if(bb != NULL)
bb->conversation = NULL;
return;
}
/* This is EXTREMELY unlikely to happen */
if (ret < len) {
char *tmp = g_strdup(ss->msg + ret);
g_free(ss->msg);
ss->msg = tmp;
return;
}
g_free(ss->msg);
g_free(ss);
bconv->stream_data = NULL;
/* Stream started; process the send buffer if there is one */
purple_input_remove(bconv->tx_handler);
bconv->tx_handler = 0;
bconv->sent_stream_start = FULLY_SENT;
bonjour_jabber_stream_started(bconv);
}
void
msn_httpconn_destroy(MsnHttpConn *httpconn)
{
g_return_if_fail(httpconn != NULL);
purple_debug_info("msn", "destroy httpconn (%p)\n", httpconn);
if (httpconn->connected)
msn_httpconn_disconnect(httpconn);
g_free(httpconn->full_session_id);
g_free(httpconn->session_id);
g_free(httpconn->host);
while (httpconn->queue != NULL) {
MsnHttpQueueData *queue_data;
queue_data = (MsnHttpQueueData *) httpconn->queue->data;
httpconn->queue = g_list_delete_link(httpconn->queue, httpconn->queue);
g_free(queue_data->body);
g_free(queue_data);
}
purple_circ_buffer_destroy(httpconn->tx_buf);
if (httpconn->tx_handler > 0)
purple_input_remove(httpconn->tx_handler);
g_free(httpconn);
}
static void
purple_upnp_discover_udp_read(gpointer data, gint sock, PurpleInputCondition cond)
{
int len;
UPnPDiscoveryData *dd = data;
gchar buf[65536];
do {
len = recv(dd->fd, buf,
sizeof(buf) - 1, 0);
if(len >= 0) {
buf[len] = '\0';
break;
} else if(errno != EINTR) {
/* We'll either get called again, or time out */
return;
}
} while (errno == EINTR);
purple_input_remove(dd->inpa);
dd->inpa = 0;
close(dd->fd);
dd->fd = -1;
/* parse the response, and see if it was a success */
purple_upnp_parse_discover_response(buf, len, dd);
/* We'll either time out or continue successfully */
}
static void
servconn_write_cb(gpointer data, gint source, PurpleInputCondition cond)
{
MsnServConn *servconn = data;
gssize ret;
int writelen;
writelen = purple_circ_buffer_get_max_read(servconn->tx_buf);
if (writelen == 0) {
purple_input_remove(servconn->tx_handler);
servconn->tx_handler = 0;
return;
}
ret = write(servconn->fd, servconn->tx_buf->outptr, writelen);
if (ret < 0 && errno == EAGAIN)
return;
else if (ret <= 0) {
msn_servconn_got_error(servconn, MSN_SERVCONN_ERROR_WRITE, NULL);
return;
}
purple_circ_buffer_mark_read(servconn->tx_buf, ret);
servconn_timeout_renew(servconn);
}
static void connection_remove(qq_data *qd, int fd) {
qq_connection *conn = connection_find(qd, fd);
qd->openconns = g_slist_remove(qd->openconns, conn);
g_return_if_fail( conn != NULL );
purple_debug_info("QQ", "Close socket %d\n", conn->fd);
if(conn->input_handler > 0) purple_input_remove(conn->input_handler);
if(conn->can_write_handler > 0) purple_input_remove(conn->can_write_handler);
if (conn->fd >= 0) close(conn->fd);
if(conn->tcp_txbuf != NULL) purple_circ_buffer_destroy(conn->tcp_txbuf);
if (conn->tcp_rxqueue != NULL) g_free(conn->tcp_rxqueue);
g_free(conn);
}
static void
msn_soap_connection_sanitize(MsnSoapConnection *conn, gboolean disconnect)
{
if (conn->event_handle) {
purple_input_remove(conn->event_handle);
conn->event_handle = 0;
}
if (conn->run_timer) {
purple_timeout_remove(conn->run_timer);
conn->run_timer = 0;
}
if (conn->message) {
msn_soap_message_destroy(conn->message);
conn->message = NULL;
}
if (conn->buf) {
g_string_free(conn->buf, TRUE);
conn->buf = NULL;
}
if (conn->ssl && (disconnect || conn->close_when_done)) {
purple_ssl_close(conn->ssl);
conn->ssl = NULL;
}
if (conn->current_request) {
msn_soap_request_destroy(conn->current_request, FALSE);
conn->current_request = NULL;
}
}
void om_connection_destroy(OmegleConnection *omconn)
{
omconn->oma->conns = g_slist_remove(omconn->oma->conns, omconn);
if (omconn->request != NULL)
g_string_free(omconn->request, TRUE);
g_free(omconn->rx_buf);
if (omconn->connect_data != NULL)
purple_proxy_connect_cancel(omconn->connect_data);
if (omconn->ssl_conn != NULL)
purple_ssl_close(omconn->ssl_conn);
if (omconn->fd >= 0) {
close(omconn->fd);
}
if (omconn->input_watcher > 0)
purple_input_remove(omconn->input_watcher);
g_free(omconn->url);
g_free(omconn->hostname);
g_free(omconn);
}
void gfire_server_query_free(gfire_server_query *p_query)
{
if(!p_query)
return;
if(p_query->prpl_data)
purple_network_listen_cancel(p_query->prpl_data);
if(p_query->prpl_inpa)
purple_input_remove(p_query->prpl_inpa);
if(p_query->socket >= 0)
close(p_query->socket);
if(p_query->timeout)
g_source_remove(p_query->timeout);
while(p_query->cur_servers)
{
gfire_game_query_server *server = p_query->cur_servers->data;
p_query->cur_servers = g_list_delete_link(p_query->cur_servers, p_query->cur_servers);
gfire_game_server_free(server->server);
g_free(server);
}
while(!g_queue_is_empty(p_query->servers))
{
gfire_game_query_server *server = g_queue_pop_head(p_query->servers);
gfire_game_server_free(server->server);
g_free(server);
}
g_queue_free(p_query->servers);
g_free(p_query);
}
