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; }