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 fb_connection_destroy(FacebookConnection *fbconn)
{
fbconn->fba->conns = g_slist_remove(fbconn->fba->conns, fbconn);
if (fbconn->request != NULL)
g_string_free(fbconn->request, TRUE);
g_free(fbconn->rx_buf);
if (fbconn->connect_data != NULL)
purple_proxy_connect_cancel(fbconn->connect_data);
if (fbconn->ssl_conn != NULL)
purple_ssl_close(fbconn->ssl_conn);
if (fbconn->fd >= 0) {
close(fbconn->fd);
}
if (fbconn->input_watcher > 0)
purple_input_remove(fbconn->input_watcher);
g_free(fbconn->hostname);
g_free(fbconn);
}
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;
}
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 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 void
close_impl (PnNode *conn)
{
g_return_if_fail (conn);
if (conn->status == PN_NODE_STATUS_CLOSED) {
pn_log ("already closed: %p", conn);
return;
}
pn_log ("begin");
pn_info ("closing '%s'", conn->name);
pn_debug ("conn=%p,name=%s", conn, conn->name);
conn->status = PN_NODE_STATUS_CLOSED;
g_free (conn->hostname);
conn->hostname = NULL;
if (conn->next) {
pn_node_close (conn->next);
goto leave;
}
#if defined(USE_GIO)
if (conn->socket_conn) {
g_object_unref(conn->socket_conn);
conn->socket_conn = NULL;
}
#else
#if defined(HAVE_LIBPURPLE)
if (conn->connect_data) {
purple_proxy_connect_cancel (conn->connect_data);
conn->connect_data = NULL;
}
#endif
if (conn->read_watch)
{
g_source_remove (conn->read_watch);
conn->read_watch = 0;
}
#endif
if (conn->stream)
{
pn_info ("stream shutdown: %p", conn->stream);
pn_stream_free (conn->stream);
conn->stream = NULL;
}
else
pn_error ("not connected: conn=%p", conn);
leave:
conn->status = PN_NODE_STATUS_CLOSED;
pn_log ("end");
}
/**
* 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;
}
/* clean up qq_data structure and all its components
* always used before a redirectly connection */
void qq_disconnect(PurpleConnection *gc)
{
qq_data *qd;
g_return_if_fail(gc != NULL && gc->proto_data != NULL);
qd = (qq_data *) gc->proto_data;
purple_debug_info("QQ", "Disconnecting...\n");
if (qd->network_watcher > 0) {
purple_debug_info("QQ", "Remove network watcher\n");
purple_timeout_remove(qd->network_watcher);
qd->network_watcher = 0;
}
/* finish all I/O */
if (qd->fd >= 0 && qd->is_login) {
qq_request_logout(gc);
}
/* not connected */
if (qd->conn_data != NULL) {
purple_debug_info("QQ", "Connect cancel\n");
purple_proxy_connect_cancel(qd->conn_data);
qd->conn_data = NULL;
}
#ifndef purple_proxy_connect_udp
if (qd->udp_can_write_handler) {
purple_input_remove(qd->udp_can_write_handler);
qd->udp_can_write_handler = 0;
}
if (qd->udp_query_data != NULL) {
purple_debug_info("QQ", "destroy udp_query_data\n");
purple_dnsquery_destroy(qd->udp_query_data);
qd->udp_query_data = NULL;
}
#endif
connection_free_all(qd);
qd->fd = -1;
qq_trans_remove_all(gc);
memset(qd->ld.random_key, 0, sizeof(qd->ld.random_key));
memset(qd->ld.pwd_md5, 0, sizeof(qd->ld.pwd_md5));
memset(qd->ld.pwd_twice_md5, 0, sizeof(qd->ld.pwd_twice_md5));
memset(qd->ld.login_key, 0, sizeof(qd->ld.login_key));
memset(qd->session_key, 0, sizeof(qd->session_key));
memset(qd->session_md5, 0, sizeof(qd->session_md5));
qd->my_local_ip.s_addr = 0;
qd->my_local_port = 0;
qd->my_ip.s_addr = 0;
qd->my_port = 0;
qq_room_data_free_all(gc);
qq_buddy_data_free_all(gc);
}
gboolean connect_to_server(PurpleConnection *gc, gchar *server, gint port)
{
PurpleAccount *account ;
qq_data *qd;
g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, FALSE);
account = purple_connection_get_account(gc);
qd = (qq_data *) gc->proto_data;
if (server == NULL || server[0] == '\0' || port == 0) {
purple_connection_error_reason(gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("Invalid server or port"));
return FALSE;
}
purple_connection_update_progress(gc, _("Connecting to server"), 1, QQ_CONNECT_STEPS);
purple_debug_info("QQ", "Connect to %s:%d\n", server, port);
if (qd->conn_data != NULL) {
purple_proxy_connect_cancel(qd->conn_data);
qd->conn_data = NULL;
}
#ifdef purple_proxy_connect_udp
if (qd->use_tcp) {
qd->conn_data = purple_proxy_connect(gc, account, server, port, connect_cb, gc);
} else {
qd->conn_data = purple_proxy_connect_udp(gc, account, server, port, connect_cb, gc);
}
if ( qd->conn_data == NULL ) {
purple_debug_error("QQ", "Couldn't create socket\n");
return FALSE;
}
#else
/* QQ connection via UDP/TCP.
* Now use Purple proxy function to provide TCP proxy support,
* and qq_udp_proxy.c to add UDP proxy support (thanks henry) */
if(qd->use_tcp) {
qd->conn_data = purple_proxy_connect(gc, account, server, port, connect_cb, gc);
if ( qd->conn_data == NULL ) {
purple_debug_error("QQ", "Unable to connect.\n");
return FALSE;
}
return TRUE;
}
purple_debug_info("QQ", "UDP Connect to %s:%d\n", server, port);
qd->udp_query_data = purple_dnsquery_a(server, port, udp_host_resolved, gc);
if ( qd->udp_query_data == NULL ) {
purple_debug_error("QQ", "Could not resolve hostname\n");
return FALSE;
}
#endif
return TRUE;
}
/**
* We tried to make an outgoing connection to a remote user. It
* either connected or failed to connect.
*/
static void
peer_connection_common_established_cb(gpointer data, gint source, const gchar *error_message, gboolean verified)
{
PeerConnection *conn;
conn = data;
if (verified)
conn->verified_connect_data = NULL;
else
conn->client_connect_data = NULL;
if (source < 0)
{
if ((conn->verified_connect_data == NULL) &&
(conn->client_connect_data == NULL))
{
/* Our parallel connection attemps have both failed. */
peer_connection_trynext(conn);
}
return;
}
purple_timeout_remove(conn->connect_timeout_timer);
conn->connect_timeout_timer = 0;
if (conn->client_connect_data != NULL)
{
purple_proxy_connect_cancel(conn->client_connect_data);
conn->client_connect_data = NULL;
}
if (conn->verified_connect_data != NULL)
{
purple_proxy_connect_cancel(conn->verified_connect_data);
conn->verified_connect_data = NULL;
}
conn->fd = source;
peer_connection_finalize_connection(conn);
}
/*
* This callback will be called when we're unable to connect to
* the remote host in DC_OUTGOING_TIMEOUT seconds.
*/
gboolean
msn_dc_outgoing_connection_timeout_cb(gpointer data)
{
MsnDirectConn *dc = data;
purple_debug_info("msn", "msn_dc_outgoing_connection_timeout_cb %p\n", dc);
g_return_val_if_fail(dc != NULL, FALSE);
dc->connect_timeout_handle = 0;
if (dc->connect_data != NULL) {
purple_proxy_connect_cancel(dc->connect_data);
dc->connect_data = NULL;
}
if (dc->ext_ip && dc->ext_port) {
/* Try external IP/port if available. */
dc->connect_data = purple_proxy_connect(
NULL,
dc->slpcall->slplink->session->account,
dc->ext_ip,
dc->ext_port,
msn_dc_connected_to_peer_cb,
dc
);
g_free(dc->ext_ip);
dc->ext_ip = NULL;
if (dc->connect_data) {
dc->connect_timeout_handle = purple_timeout_add_seconds(
DC_OUTGOING_TIMEOUT,
msn_dc_outgoing_connection_timeout_cb,
dc
);
} else {
/*
* Connection failed
* Fall back to SB transfer
*/
msn_dc_outgoing_connection_timeout_cb(dc);
}
} else {
/*
* Both internal and external connection attempts failed.
* Fall back to SB transfer.
*/
msn_dc_fallback_to_sb(dc);
}
return FALSE;
}
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_timeout_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);
}
static void
purple_socket_cancel(PurpleSocket *ps)
{
if (ps->inpa > 0)
purple_input_remove(ps->inpa);
ps->inpa = 0;
if (ps->tls_connection != NULL) {
purple_ssl_close(ps->tls_connection);
ps->fd = -1;
}
ps->tls_connection = NULL;
if (ps->raw_connection != NULL)
purple_proxy_connect_cancel(ps->raw_connection);
ps->raw_connection = NULL;
if (ps->fd > 0)
close(ps->fd);
ps->fd = 0;
}
static void
bonjour_free_xfer(PurpleXfer *xfer)
{
XepXfer *xf;
if(xfer == NULL) {
purple_debug_info("bonjour", "bonjour-free-xfer-null.\n");
return;
}
purple_debug_info("bonjour", "bonjour-free-xfer-%p.\n", xfer);
xf = (XepXfer*)xfer->data;
if(xf != NULL) {
BonjourData *bd = (BonjourData*)xf->data;
if(bd != NULL) {
bd->xfer_lists = g_slist_remove(bd->xfer_lists, xfer);
purple_debug_info("bonjour", "B free xfer from lists(%p).\n", bd->xfer_lists);
}
if (xf->proxy_connection != NULL)
purple_proxy_connect_cancel(xf->proxy_connection);
if (xf->proxy_info != NULL)
purple_proxy_info_destroy(xf->proxy_info);
if (xf->listen_data != NULL)
purple_network_listen_cancel(xf->listen_data);
g_free(xf->iq_id);
g_free(xf->jid);
g_free(xf->proxy_host);
g_free(xf->buddy_ip);
g_free(xf->sid);
xmlnode_free_tree(xf->streamhost);
g_free(xf);
xfer->data = NULL;
}
purple_debug_info("bonjour", "Need close socket=%d.\n", xfer->fd);
}
void
msn_httpconn_disconnect(MsnHttpConn *httpconn)
{
g_return_if_fail(httpconn != NULL);
if (!httpconn->connected)
return;
if (httpconn->connect_data != NULL)
{
purple_proxy_connect_cancel(httpconn->connect_data);
httpconn->connect_data = NULL;
}
if (httpconn->timer)
{
purple_timeout_remove(httpconn->timer);
httpconn->timer = 0;
}
if (httpconn->inpa > 0)
{
purple_input_remove(httpconn->inpa);
httpconn->inpa = 0;
}
close(httpconn->fd);
httpconn->fd = -1;
g_free(httpconn->rx_buf);
httpconn->rx_buf = NULL;
httpconn->rx_len = 0;
httpconn->connected = FALSE;
/* msn_servconn_disconnect(httpconn->servconn); */
}
void
msn_dc_destroy(MsnDirectConn *dc)
{
MsnSlpLink *slplink;
if (purple_debug_is_verbose())
purple_debug_info("msn", "msn_dc_destroy %p\n", dc);
g_return_if_fail(dc != NULL);
if (dc->slpcall != NULL)
dc->slpcall->wait_for_socket = FALSE;
slplink = dc->slplink;
if (slplink) {
slplink->dc = NULL;
if (slplink->swboard == NULL)
msn_slplink_unref(slplink);
}
g_free(dc->msg_body);
if (dc->prev_ack) {
msn_slpmsg_destroy(dc->prev_ack);
}
if (dc->listen_data != NULL) {
purple_network_listen_cancel(dc->listen_data);
}
if (dc->connect_data != NULL) {
purple_proxy_connect_cancel(dc->connect_data);
}
if (dc->listenfd != -1) {
purple_network_remove_port_mapping(dc->listenfd);
close(dc->listenfd);
}
if (dc->listenfd_handle != 0) {
purple_input_remove(dc->listenfd_handle);
}
if (dc->connect_timeout_handle != 0) {
purple_timeout_remove(dc->connect_timeout_handle);
}
if (dc->fd != -1) {
close(dc->fd);
}
if (dc->send_handle != 0) {
purple_input_remove(dc->send_handle);
}
if (dc->recv_handle != 0) {
purple_input_remove(dc->recv_handle);
}
g_free(dc->in_buffer);
if (dc->out_queue != NULL) {
while (!g_queue_is_empty(dc->out_queue))
msn_dc_destroy_packet( g_queue_pop_head(dc->out_queue) );
g_queue_free(dc->out_queue);
}
g_free(dc->ext_ip);
if (dc->timeout_handle != 0) {
purple_timeout_remove(dc->timeout_handle);
}
g_free(dc);
}
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;
}
