static int
tds_connection_put_packet(TDSSOCKET *tds, TDSPACKET *packet)
{
TDSCONNECTION *conn = tds->conn;
if (TDS_UNLIKELY(!packet)) {
tds_close_socket(tds);
return TDS_FAIL;
}
tds->out_pos = 0;
tds_mutex_lock(&conn->list_mtx);
for (;;) {
int wait_res;
if (IS_TDSDEAD(tds)) {
tdsdump_log(TDS_DBG_NETWORK, "Write attempt when state is TDS_DEAD");
break;
}
/* limit packet sending looking at sequence/window */
if (tds->send_seq <= tds->send_wnd) {
/* append packet */
tds_append_packet(&conn->send_packets, packet);
packet = NULL;
}
/* network ok ? process network */
if (!conn->in_net_tds) {
tds_connection_network(conn, tds, packet ? 0 : 1);
if (packet) continue;
/* FIXME we are not sure we sent the packet !!! */
break;
}
/* signal thread processing network to handle our packet */
/* TODO check result */
tds_wakeup_send(&conn->wakeup, 0);
/* wait local condition */
wait_res = tds_cond_timedwait(&tds->packet_cond, &conn->list_mtx, tds->query_timeout);
if (wait_res == ETIMEDOUT
&& tdserror(tds_get_ctx(tds), tds, TDSETIME, ETIMEDOUT) != TDS_INT_CONTINUE) {
tds_mutex_unlock(&conn->list_mtx);
tds_close_socket(tds);
tds_free_packets(packet);
return TDS_FAIL;
}
}
tds_mutex_unlock(&conn->list_mtx);
if (TDS_UNLIKELY(packet)) {
tds_free_packets(packet);
return TDS_FAIL;
}
if (IS_TDSDEAD(tds))
return TDS_FAIL;
return TDS_SUCCESS;
}
/**
* 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
}
}
int
tds_close_socket(TDSSOCKET * tds)
{
int rc = -1;
if (!IS_TDSDEAD(tds)) {
rc = CLOSESOCKET(tds->s);
tds->s = INVALID_SOCKET;
tds_set_state(tds, TDS_DEAD);
}
return rc;
}
/*
** Return a single byte from the input buffer
*/
unsigned char
tds_get_byte(TDSSOCKET * tds)
{
int rc;
if (tds->in_pos >= tds->in_len) {
do {
if (IS_TDSDEAD(tds) || (rc = tds_read_packet(tds)) < 0)
return 0;
} while (!rc);
}
return tds->in_buf[tds->in_pos++];
}
static void
pool_select_add_socket(SELECT_INFO *sel, TDS_POOL_SOCKET *sock)
{
/* skip dead connections */
if (IS_TDSDEAD(sock->tds))
return;
if (!sock->poll_recv && !sock->poll_send)
return;
if (tds_get_s(sock->tds) > sel->maxfd)
sel->maxfd = tds_get_s(sock->tds);
if (sock->poll_recv)
FD_SET(tds_get_s(sock->tds), &sel->rfds);
if (sock->poll_send)
FD_SET(tds_get_s(sock->tds), &sel->wfds);
}
void
pool_free_member(TDS_POOL_MEMBER * pmbr)
{
if (!IS_TDSDEAD(pmbr->tds)) {
tds_close_socket(pmbr->tds);
}
pmbr->tds = NULL;
/*
* if he is allocated disconnect the client
* otherwise we end up with broken client.
*/
if (pmbr->current_user) {
pool_free_user(pmbr->current_user);
pmbr->current_user = NULL;
}
pmbr->state = TDS_IDLE;
}
void
pool_free_member(TDS_POOL_MEMBER * pmbr)
{
TDSSOCKET *tds = pmbr->tds;
if (!IS_TDSDEAD(tds))
tds_close_socket(tds);
if (tds)
tds_free_socket(tds);
pmbr->tds = NULL;
/*
* if he is allocated disconnect the client
* otherwise we end up with broken client.
*/
if (pmbr->current_user) {
pmbr->current_user->assigned_member = NULL;
pool_free_user(pmbr->current_user);
pmbr->current_user = NULL;
}
memset(pmbr, 0, sizeof(*pmbr));
pmbr->state = TDS_IDLE;
}
/*
* pool_main_loop
* Accept new connections from clients, and handle all input from clients and
* pool members.
*/
static void
pool_main_loop(TDS_POOL * pool)
{
TDS_POOL_USER *puser;
TDS_POOL_MEMBER *pmbr;
struct sockaddr_in sin;
int s, maxfd, i;
fd_set rfds;
int socktrue = 1;
/* FIXME -- read the interfaces file and bind accordingly */
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(pool->port);
sin.sin_family = AF_INET;
if (TDS_IS_SOCKET_INVALID(s = socket(AF_INET, SOCK_STREAM, 0))) {
perror("socket");
exit(1);
}
/* don't keep addr in use from [email protected] */
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const void *) &socktrue, sizeof(socktrue));
fprintf(stderr, "Listening on port %d\n", pool->port);
if (bind(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
perror("bind");
exit(1);
}
listen(s, 5);
FD_ZERO(&rfds);
FD_SET(s, &rfds);
maxfd = s;
while (!term) {
/* fprintf(stderr, "waiting for a connect\n"); */
/* FIXME check return value */
select(maxfd + 1, &rfds, NULL, NULL, NULL);
if (term)
break;
/* process the sockets */
if (FD_ISSET(s, &rfds)) {
pool_user_create(pool, s, &sin);
}
pool_process_users(pool, &rfds);
pool_process_members(pool, &rfds);
/* back from members */
if (waiters) {
pool_schedule_waiters(pool);
}
FD_ZERO(&rfds);
/* add the listening socket to the read list */
FD_SET(s, &rfds);
maxfd = s;
/* add the user sockets to the read list */
for (i = 0; i < pool->max_users; i++) {
puser = (TDS_POOL_USER *) & pool->users[i];
/* skip dead connections */
if (!IS_TDSDEAD(puser->tds)) {
if (tds_get_s(puser->tds) > maxfd)
maxfd = tds_get_s(puser->tds);
FD_SET(tds_get_s(puser->tds), &rfds);
}
}
/* add the pool member sockets to the read list */
for (i = 0; i < pool->num_members; i++) {
pmbr = (TDS_POOL_MEMBER *) & pool->members[i];
if (!IS_TDSDEAD(pmbr->tds)) {
if (tds_get_s(pmbr->tds) > maxfd)
maxfd = tds_get_s(pmbr->tds);
FD_SET(tds_get_s(pmbr->tds), &rfds);
}
}
} /* while !term */
CLOSESOCKET(s);
for (i = 0; i < pool->max_users; i++) {
puser = (TDS_POOL_USER *) & pool->users[i];
if (!IS_TDSDEAD(puser->tds)) {
fprintf(stderr, "Closing user %d\n", i);
tds_close_socket(puser->tds);
}
}
for (i = 0; i < pool->num_members; i++) {
pmbr = (TDS_POOL_MEMBER *) & pool->members[i];
if (!IS_TDSDEAD(pmbr->tds)) {
fprintf(stderr, "Closing member %d\n", i);
tds_close_socket(pmbr->tds);
}
}
}
/**
* Read in one 'packet' from the server. This is a wrapped outer packet of
* the protocol (they bundle result packets into chunks and wrap them at
* what appears to be 512 bytes regardless of how that breaks internal packet
* up. (tetherow\@nol.org)
* @return bytes read or -1 on failure
*/
int
tds_read_packet(TDSSOCKET * tds)
{
#if ENABLE_ODBC_MARS
TDSCONNECTION *conn = tds->conn;
tds_mutex_lock(&conn->list_mtx);
for (;;) {
int wait_res;
TDSPACKET **p_packet;
if (IS_TDSDEAD(tds)) {
tdsdump_log(TDS_DBG_NETWORK, "Read attempt when state is TDS_DEAD\n");
break;
}
/* if there is a packet for me return it */
for (p_packet = &conn->packets; *p_packet; p_packet = &(*p_packet)->next)
if ((*p_packet)->sid == tds->sid)
break;
if (*p_packet) {
size_t hdr_size;
/* remove our packet from list */
TDSPACKET *packet = *p_packet;
*p_packet = packet->next;
tds_packet_cache_add(conn, tds->recv_packet);
tds_mutex_unlock(&conn->list_mtx);
packet->next = NULL;
tds->recv_packet = packet;
hdr_size = packet->buf[0] == TDS72_SMP ? sizeof(TDS72_SMP_HEADER) : 0;
tds->in_buf = packet->buf + hdr_size;
tds->in_len = packet->len - hdr_size;
tds->in_pos = 8;
tds->in_flag = tds->in_buf[0];
/* send acknowledge if needed */
if (tds->recv_seq + 2 >= tds->recv_wnd)
tds_update_recv_wnd(tds, tds->recv_seq + 4);
return tds->in_len;
}
/* network ok ? process network */
if (!conn->in_net_tds) {
tds_connection_network(conn, tds, 0);
continue;
}
/* wait local condition */
wait_res = tds_cond_timedwait(&tds->packet_cond, &conn->list_mtx, tds->query_timeout);
if (wait_res == ETIMEDOUT
&& tdserror(tds_get_ctx(tds), tds, TDSETIME, ETIMEDOUT) != TDS_INT_CONTINUE) {
tds_mutex_unlock(&conn->list_mtx);
tds_close_socket(tds);
return -1;
}
}
tds_mutex_unlock(&conn->list_mtx);
return -1;
#else /* !ENABLE_ODBC_MARS */
unsigned char *pkt = tds->in_buf, *p, *end;
if (IS_TDSDEAD(tds)) {
tdsdump_log(TDS_DBG_NETWORK, "Read attempt when state is TDS_DEAD");
return -1;
}
tds->in_len = 0;
tds->in_pos = 0;
for (p = pkt, end = p+8; p < end;) {
int len = tds_connection_read(tds, p, end - p);
if (len <= 0) {
tds_close_socket(tds);
return -1;
}
p += len;
if (p - pkt >= 4) {
unsigned pktlen = TDS_GET_A2BE(pkt+2);
/* packet must at least contains header */
if (TDS_UNLIKELY(pktlen < 8)) {
tds_close_socket(tds);
return -1;
}
if (TDS_UNLIKELY(pktlen > tds->recv_packet->capacity)) {
TDSPACKET *packet = tds_realloc_packet(tds->recv_packet, pktlen);
if (TDS_UNLIKELY(!packet)) {
tds_close_socket(tds);
return -1;
}
tds->recv_packet = packet;
pkt = packet->buf;
p = pkt + (p-tds->in_buf);
tds->in_buf = pkt;
}
end = pkt + pktlen;
}
}
/* set the received packet type flag */
tds->in_flag = pkt[0];
/* Set the length and pos (not sure what pos is used for now */
tds->in_len = p - pkt;
tds->in_pos = 8;
tdsdump_dump_buf(TDS_DBG_NETWORK, "Received packet", tds->in_buf, tds->in_len);
return tds->in_len;
#endif /* !ENABLE_ODBC_MARS */
}
/**
* Read in one 'packet' from the server. This is a wrapped outer packet of
* the protocol (they bundle result packets into chunks and wrap them at
* what appears to be 512 bytes regardless of how that breaks internal packet
* up. (tetherow\@nol.org)
* @return bytes read or -1 on failure
*/
int
tds_read_packet(TDSSOCKET * tds)
{
unsigned char header[8];
int len;
int x = 0, have, need;
if (IS_TDSDEAD(tds)) {
tdsdump_log(TDS_DBG_NETWORK, "Read attempt when state is TDS_DEAD");
return -1;
}
/*
* Read in the packet header. We use this to figure out our packet
* length
*/
/*
* Cast to int are needed because some compiler seem to convert
* len to unsigned (as FreeBSD 4.5 one)
*/
if ((len = goodread(tds, header, sizeof(header))) < (int) sizeof(header)) {
/* GW ADDED */
if (len < 0) {
tds_client_msg(tds->tds_ctx, tds, 20004, 6, 0, 0, "Read from SQL server failed.");
tds_close_socket(tds);
tds->in_len = 0;
tds->in_pos = 0;
return -1;
}
/* GW ADDED */
/*
* Not sure if this is the best way to do the error
* handling here but this is the way it is currently
* being done.
*/
tds->in_len = 0;
tds->in_pos = 0;
tds->last_packet = 1;
if (tds->state != TDS_IDLE && len == 0) {
tds_close_socket(tds);
}
return -1;
}
tdsdump_dump_buf(TDS_DBG_NETWORK, "Received header", header, sizeof(header));
#if 0
/*
* Note:
* this was done by Gregg, I don't think its the real solution (it breaks
* under 5.0, but I haven't gotten a result big enough to test this yet.
*/
if (IS_TDS42(tds)) {
if (header[0] != 0x04 && header[0] != 0x0f) {
tdsdump_log(TDS_DBG_ERROR, "Invalid packet header %d\n", header[0]);
/*
* Not sure if this is the best way to do the error
* handling here but this is the way it is currently
* being done.
*/
tds->in_len = 0;
tds->in_pos = 0;
tds->last_packet = 1;
return (-1);
}
}
#endif
/* Convert our packet length from network to host byte order */
len = ((((unsigned int) header[2]) << 8) | header[3]) - 8;
need = len;
/*
* If this packet size is the largest we have gotten allocate
* space for it
*/
if ((unsigned int)len > tds->in_buf_max) {
unsigned char *p;
if (!tds->in_buf) {
p = (unsigned char *) malloc(len);
} else {
p = (unsigned char *) realloc(tds->in_buf, len);
}
if (!p)
return -1; /* FIXME should close socket too */
tds->in_buf = p;
/* Set the new maximum packet size */
tds->in_buf_max = len;
}
/* Clean out the in_buf so we don't use old stuff by mistake */
memset(tds->in_buf, 0, tds->in_buf_max);
/* Now get exactly how many bytes the server told us to get */
have = 0;
while (need > 0) {
if ((x = goodread(tds, tds->in_buf + have, need)) < 1) {
/*
* Not sure if this is the best way to do the error
* handling here but this is the way it is currently
* being done.
*/
tds->in_len = 0;
tds->in_pos = 0;
tds->last_packet = 1;
/* FIXME should this be "if (x == 0)" ? */
if (len == 0) {
tds_close_socket(tds);
}
return (-1);
}
have += x;
need -= x;
}
if (x < 1) {
/*
* Not sure if this is the best way to do the error handling
* here but this is the way it is currently being done.
*/
tds->in_len = 0;
tds->in_pos = 0;
tds->last_packet = 1;
/* return 0 if header found but no payload */
return len ? -1 : 0;
}
/* Set the last packet flag */
if (header[1]) {
tds->last_packet = 1;
} else {
tds->last_packet = 0;
}
/* set the received packet type flag */
tds->in_flag = header[0];
/* Set the length and pos (not sure what pos is used for now */
tds->in_len = have;
tds->in_pos = 0;
tdsdump_dump_buf(TDS_DBG_NETWORK, "Received packet", tds->in_buf, tds->in_len);
return (tds->in_len);
}
/**
* Loops until we have received buflen characters
* return -1 on failure
*/
static int
tds_goodread(TDSSOCKET * tds, unsigned char *buf, int buflen, unsigned char unfinished)
{
double start, global_start;
int got = 0;
int canceled = 0;
if (buf == NULL || buflen < 1 || IS_TDSDEAD(tds))
return 0;
global_start = start = GetTimeMark();
while (buflen > 0) {
int len;
double now;
if (IS_TDSDEAD(tds))
return -1;
if ((len = tds_select(tds, TDSSELREAD, tds->query_timeout,
global_start)) > 0) {
len = READSOCKET(tds->s, buf + got, buflen);
if (len < 0 && TDSSOCK_WOULDBLOCK(sock_errno))
continue;
/* detect connection close */
if (len <= 0) {
tds_close_socket(tds);
if (len == 0) {
tds_client_msg(tds->tds_ctx, tds, 20011, 6, 0, 0,
"EOF in the socket.");
} else {
tds_report_error(tds->tds_ctx, tds, sock_errno, 20012,
"recv finished with an error.");
}
return -1;
}
} else if (len < 0) {
if (TDSSOCK_WOULDBLOCK(sock_errno)) /* shouldn't happen, but OK */
continue;
tds_close_socket(tds);
tds_report_error(tds->tds_ctx, tds, sock_errno, 20012,
"recv finished with an error.");
return -1;
} else { /* timeout */
now = GetTimeMark();
if (tds->query_timeout > 0 && now - start >= tds->query_timeout) {
int timeout_action = TDS_INT_CONTINUE;
if (canceled)
return got ? got : -1;
if (tds->query_timeout_func && tds->query_timeout)
timeout_action = (*tds->query_timeout_func)
(tds->query_timeout_param, (int)(now - global_start));
switch (timeout_action) {
case TDS_INT_EXIT:
exit(EXIT_FAILURE);
break;
case TDS_INT_CANCEL:
tds_send_cancel(tds);
canceled = 1;
/* fall through to wait while cancelling happens */
case TDS_INT_CONTINUE:
start = now;
default:
break;
}
}
}
buflen -= len;
got += len;
if (unfinished && got)
return got;
}
return got;
}
