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