/**
* Close current socket
* for last socket close entire connection
* for MARS send FIN request
*/
void
tds_close_socket(TDSSOCKET * tds)
{
if (!IS_TDSDEAD(tds)) {
#if ENABLE_ODBC_MARS
TDSCONNECTION *conn = tds->conn;
unsigned n = 0, count = 0;
tds_mutex_lock(&conn->list_mtx);
for (; n < conn->num_sessions; ++n)
if (TDSSOCKET_VALID(conn->sessions[n]))
++count;
if (count > 1)
tds_append_fin(tds);
tds_mutex_unlock(&conn->list_mtx);
if (count <= 1) {
tds_disconnect(tds);
tds_connection_close(conn);
} else {
tds_set_state(tds, TDS_DEAD);
}
#else
tds_disconnect(tds);
if (CLOSESOCKET(tds_get_s(tds)) == -1)
tdserror(tds_get_ctx(tds), tds, TDSECLOS, sock_errno);
tds_set_s(tds, INVALID_SOCKET);
tds_set_state(tds, TDS_DEAD);
#endif
}
}
static void
tds_check_cancel(TDSCONNECTION *conn)
{
TDSSOCKET *tds;
int rc;
if (!tds_connection_signaled(conn))
return;
do {
unsigned n = 0;
rc = TDS_SUCCESS;
tds_mutex_lock(&conn->list_mtx);
/* Here we scan all list searching for sessions that should send cancel packets */
for (; n < conn->num_sessions; ++n)
if (TDSSOCKET_VALID(tds=conn->sessions[n]) && tds->in_cancel == 1) {
/* send cancel */
tds->in_cancel = 2;
tds_mutex_unlock(&conn->list_mtx);
rc = tds_append_cancel(tds);
tds_mutex_lock(&conn->list_mtx);
if (rc != TDS_SUCCESS)
break;
}
tds_mutex_unlock(&conn->list_mtx);
/* for all failed */
/* this must be done outside loop cause it can alter list */
/* this must be done unlocked cause it can lock again */
if (rc != TDS_SUCCESS)
tds_close_socket(tds);
} while(rc != TDS_SUCCESS);
}
void
tds_connection_close(TDSCONNECTION *conn)
{
unsigned n = 0;
if (!TDS_IS_SOCKET_INVALID(conn->s)) {
/* TODO check error ?? how to return it ?? */
CLOSESOCKET(conn->s);
conn->s = INVALID_SOCKET;
}
tds_mutex_lock(&conn->list_mtx);
for (; n < conn->num_sessions; ++n)
if (TDSSOCKET_VALID(conn->sessions[n]))
tds_set_state(conn->sessions[n], TDS_DEAD);
tds_mutex_unlock(&conn->list_mtx);
}
static void
tds_connection_network(TDSCONNECTION *conn, TDSSOCKET *tds, int send)
{
assert(!conn->in_net_tds);
conn->in_net_tds = tds;
tds_mutex_unlock(&conn->list_mtx);
for (;;) {
/* wait packets or update */
int rc = tds_select(tds, conn->send_packets ? TDSSELREAD|TDSSELWRITE : TDSSELREAD, tds->query_timeout);
if (rc < 0) {
/* FIXME better error report */
tds_connection_close(conn);
break;
}
/* change notify */
/* TODO async */
if (!rc) { /* timeout */
tdsdump_log(TDS_DBG_INFO1, "timeout\n");
switch (rc = tdserror(tds_get_ctx(tds), tds, TDSETIME, sock_errno)) {
case TDS_INT_CONTINUE:
continue;
default:
case TDS_INT_CANCEL:
tds_close_socket(tds);
}
break;
}
/*
* we must write first to catch write errors as
* write errors, not as read
*/
/* something to send */
if (conn->send_packets && (rc & POLLOUT) != 0) {
TDSSOCKET *s;
short sid = tds_packet_write(conn);
if (sid == tds->sid) break; /* return to caller */
tds_mutex_lock(&conn->list_mtx);
if (sid >= 0 && sid < conn->num_sessions) {
s = conn->sessions[sid];
if (TDSSOCKET_VALID(s))
tds_cond_signal(&s->packet_cond);
}
tds_mutex_unlock(&conn->list_mtx);
/* avoid using a possible closed connection */
continue;
}
/* received */
if (rc & POLLIN) {
TDSPACKET *packet;
TDSSOCKET *s;
/* try to read a packet */
tds_packet_read(conn, tds);
packet = conn->recv_packet;
if (!packet || conn->recv_pos < packet->len) continue;
conn->recv_packet = NULL;
conn->recv_pos = 0;
tdsdump_dump_buf(TDS_DBG_NETWORK, "Received packet", packet->buf, packet->len);
tds_mutex_lock(&conn->list_mtx);
if (packet->sid >= 0 && packet->sid < conn->num_sessions) {
s = conn->sessions[packet->sid];
if (TDSSOCKET_VALID(s)) {
/* append to correct session */
if (packet->buf[0] == TDS72_SMP && packet->buf[1] != TDS_SMP_DATA)
tds_packet_cache_add(conn, packet);
else
tds_append_packet(&conn->packets, packet);
packet = NULL;
/* notify */
tds_cond_signal(&s->packet_cond);
}
}
tds_mutex_unlock(&conn->list_mtx);
tds_free_packets(packet);
/* if we are receiving return the packet */
if (!send) break;
}
}
tds_mutex_lock(&conn->list_mtx);
conn->in_net_tds = NULL;
}
