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_timeout_remove(servconn->timeout_handle);
msn_cmdproc_destroy(servconn->cmdproc);
g_free(servconn);
}
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);
}
/**
* 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 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);
}
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 gboolean
peer_connection_destroy_cb(gpointer data)
{
PeerConnection *conn;
conn = data;
purple_request_close_with_handle(conn);
peer_connection_close(conn);
if (conn->checksum_data != NULL)
peer_oft_checksum_destroy(conn->checksum_data);
if (conn->xfer != NULL)
{
PurpleXferStatusType status;
conn->xfer->data = NULL;
status = purple_xfer_get_status(conn->xfer);
if ((status != PURPLE_XFER_STATUS_DONE) &&
(status != PURPLE_XFER_STATUS_CANCEL_LOCAL) &&
(status != PURPLE_XFER_STATUS_CANCEL_REMOTE))
{
if ((conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_CLOSED) ||
(conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_REFUSED))
purple_xfer_cancel_remote(conn->xfer);
else
purple_xfer_cancel_local(conn->xfer);
}
purple_xfer_unref(conn->xfer);
conn->xfer = NULL;
}
g_free(conn->bn);
g_free(conn->error_message);
g_free(conn->proxyip);
g_free(conn->clientip);
g_free(conn->verifiedip);
g_free(conn->xferdata.name);
purple_circ_buffer_destroy(conn->buffer_outgoing);
conn->od->peer_connections = g_slist_remove(conn->od->peer_connections, conn);
g_free(conn);
return FALSE;
}
void
jabber_bosh_connection_destroy(PurpleBOSHConnection *conn)
{
int i;
g_free(conn->host);
g_free(conn->path);
if (conn->send_timer)
purple_timeout_remove(conn->send_timer);
purple_circ_buffer_destroy(conn->pending);
for (i = 0; i < NUM_HTTP_CONNECTIONS; ++i) {
if (conn->connections[i])
jabber_bosh_http_connection_destroy(conn->connections[i]);
}
g_free(conn);
}
static void
jabber_bosh_http_connection_destroy(PurpleHTTPConnection *conn)
{
if (conn->read_buf)
g_string_free(conn->read_buf, TRUE);
if (conn->write_buf)
purple_circ_buffer_destroy(conn->write_buf);
if (conn->readh)
purple_input_remove(conn->readh);
if (conn->writeh)
purple_input_remove(conn->writeh);
if (conn->psc)
purple_ssl_close(conn->psc);
if (conn->fd >= 0)
close(conn->fd);
purple_proxy_connect_cancel_with_handle(conn);
g_free(conn);
}
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);
purple_circ_buffer_destroy(httpconn->tx_buf);
if (httpconn->tx_handler > 0)
purple_input_remove(httpconn->tx_handler);
g_free(httpconn);
}
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);
}
static void
peer_connection_close(PeerConnection *conn)
{
if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
peer_odc_close(conn);
else if (conn->type == OSCAR_CAPABILITY_SENDFILE)
peer_oft_close(conn);
if (conn->verified_connect_data != NULL)
{
purple_proxy_connect_cancel(conn->verified_connect_data);
conn->verified_connect_data = NULL;
}
if (conn->client_connect_data != NULL)
{
purple_proxy_connect_cancel(conn->client_connect_data);
conn->client_connect_data = NULL;
}
if (conn->listen_data != NULL)
{
purple_network_listen_cancel(conn->listen_data);
conn->listen_data = NULL;
}
if (conn->connect_timeout_timer != 0)
{
purple_timeout_remove(conn->connect_timeout_timer);
conn->connect_timeout_timer = 0;
}
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->listenerfd >= 0)
{
close(conn->listenerfd);
conn->listenerfd = -1;
}
if (conn->fd >= 0)
{
close(conn->fd);
conn->fd = -1;
}
g_free(conn->buffer_incoming.data);
conn->buffer_incoming.data = NULL;
conn->buffer_incoming.len = 0;
conn->buffer_incoming.offset = 0;
purple_circ_buffer_destroy(conn->buffer_outgoing);
conn->buffer_outgoing = purple_circ_buffer_new(0);
conn->flags &= ~PEER_CONNECTION_FLAG_IS_INCOMING;
}
