/**
* \param tds the famous socket
* \param buffer data to send
* \param buflen bytes in buffer
* \param last 1 if this is the last packet, else 0
* \return length written (>0), <0 on failure
*/
int
tds_goodwrite(TDSSOCKET * tds, const unsigned char *buffer, size_t buflen)
{
int len;
size_t sent = 0;
assert(tds && buffer);
while (sent < buflen) {
/* TODO if send buffer is full we block receive !!! */
len = tds_select(tds, TDSSELWRITE, tds->query_timeout);
if (len > 0) {
len = tds_socket_write(tds->conn, tds, buffer + sent, buflen - sent);
if (len == 0)
continue;
if (len < 0)
return len;
sent += len;
continue;
}
/* error */
if (len < 0) {
int err = sock_errno;
char *errstr;
if (TDSSOCK_WOULDBLOCK(err)) /* shouldn't happen, but OK, retry */
continue;
errstr = sock_strerror(err);
tdsdump_log(TDS_DBG_NETWORK, "select(2) failed: %d (%s)\n", err, errstr);
sock_strerror_free(errstr);
tds_connection_close(tds->conn);
tdserror(tds_get_ctx(tds), tds, TDSEWRIT, err);
return -1;
}
/* timeout */
tdsdump_log(TDS_DBG_NETWORK, "tds_goodwrite(): timed out, asking client\n");
switch (tdserror(tds_get_ctx(tds), tds, TDSETIME, sock_errno)) {
case TDS_INT_CONTINUE:
break;
default:
case TDS_INT_CANCEL:
tds_close_socket(tds);
return -1;
}
}
return (int) sent;
}
/**
* Loops until we have received some characters
* return -1 on failure
*/
int
tds_goodread(TDSSOCKET * tds, unsigned char *buf, int buflen)
{
if (tds == NULL || buf == NULL || buflen < 1)
return -1;
for (;;) {
int len, err;
/* FIXME this block writing from other sessions */
len = tds_select(tds, TDSSELREAD, tds->query_timeout);
#if !ENABLE_ODBC_MARS
if (len > 0 && (len & TDSPOLLURG)) {
char buf[32];
READSOCKET(tds->conn->s_signaled, buf, sizeof(buf));
/* send cancel */
if (!tds->in_cancel)
tds_put_cancel(tds);
continue;
}
#endif
if (len > 0) {
len = tds_socket_read(tds->conn, tds, buf, buflen);
if (len == 0)
continue;
return len;
}
/* error */
if (len < 0) {
if (TDSSOCK_WOULDBLOCK(sock_errno)) /* shouldn't happen, but OK */
continue;
err = sock_errno;
tds_connection_close(tds->conn);
tdserror(tds_get_ctx(tds), tds, TDSEREAD, err);
return -1;
}
/* timeout */
switch (tdserror(tds_get_ctx(tds), tds, TDSETIME, sock_errno)) {
case TDS_INT_CONTINUE:
break;
default:
case TDS_INT_CANCEL:
tds_close_socket(tds);
return -1;
}
}
}
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;
}
TDSERRNO
tds_open_socket(TDSSOCKET *tds, struct addrinfo *addr, unsigned int port, int timeout, int *p_oserr)
{
ioctl_nonblocking_t ioctl_nonblocking;
SOCKLEN_T optlen;
TDSCONNECTION *conn = tds->conn;
char ipaddr[128];
int retval, len;
TDSERRNO tds_error = TDSECONN;
*p_oserr = 0;
tds_addrinfo_set_port(addr, port);
tds_addrinfo2str(addr, ipaddr, sizeof(ipaddr));
tdsdump_log(TDS_DBG_INFO1, "Connecting to %s port %d (TDS version %d.%d)\n",
ipaddr, port,
TDS_MAJOR(conn), TDS_MINOR(conn));
conn->s = socket(addr->ai_family, SOCK_STREAM, 0);
if (TDS_IS_SOCKET_INVALID(conn->s)) {
char *errstr = sock_strerror(*p_oserr = sock_errno);
tdsdump_log(TDS_DBG_ERROR, "socket creation error: %s\n", errstr);
sock_strerror_free(errstr);
return TDSESOCK;
}
tds->state = TDS_IDLE;
#ifdef SO_KEEPALIVE
len = 1;
setsockopt(conn->s, SOL_SOCKET, SO_KEEPALIVE, (const void *) &len, sizeof(len));
#endif
#if defined(TCP_KEEPIDLE) && defined(TCP_KEEPINTVL)
len = 40;
setsockopt(conn->s, SOL_TCP, TCP_KEEPIDLE, (const void *) &len, sizeof(len));
len = 2;
setsockopt(conn->s, SOL_TCP, TCP_KEEPINTVL, (const void *) &len, sizeof(len));
#endif
#if defined(__APPLE__) && defined(SO_NOSIGPIPE)
len = 1;
if (setsockopt(conn->s, SOL_SOCKET, SO_NOSIGPIPE, (const void *) &len, sizeof(len))) {
*p_oserr = sock_errno;
tds_connection_close(conn);
return TDSESOCK;
}
#endif
len = 1;
#if defined(USE_NODELAY)
setsockopt(conn->s, SOL_TCP, TCP_NODELAY, (const void *) &len, sizeof(len));
#elif defined(USE_CORK)
if (setsockopt(conn->s, SOL_TCP, TCP_CORK, (const void *) &len, sizeof(len)) < 0)
setsockopt(conn->s, SOL_TCP, TCP_NODELAY, (const void *) &len, sizeof(len));
#else
#error One should be defined
#endif
#ifdef DOS32X /* the other connection doesn't work on WATTCP32 */
if (connect(conn->s, addr->ai_addr, addr->ai_addrlen) < 0) {
char *message;
*p_oserr = sock_errno;
if (asprintf(&message, "tds_open_socket(): %s:%d", ipaddr, port) >= 0) {
perror(message);
free(message);
}
tds_connection_close(conn);
return TDSECONN;
}
#else
if (!timeout) {
/* A timeout of zero means wait forever; 90,000 seconds will feel like forever. */
timeout = 90000;
}
/* enable non-blocking mode */
ioctl_nonblocking = 1;
if (IOCTLSOCKET(conn->s, FIONBIO, &ioctl_nonblocking) < 0) {
*p_oserr = sock_errno;
tds_connection_close(conn);
return TDSEUSCT; /* close enough: "Unable to set communications timer" */
}
retval = connect(conn->s, addr->ai_addr, addr->ai_addrlen);
if (retval == 0) {
tdsdump_log(TDS_DBG_INFO2, "connection established\n");
} else {
int err = *p_oserr = sock_errno;
char *errstr = sock_strerror(err);
tdsdump_log(TDS_DBG_ERROR, "tds_open_socket: connect(2) returned \"%s\"\n", errstr);
sock_strerror_free(errstr);
#if DEBUGGING_CONNECTING_PROBLEM
if (err != ECONNREFUSED && err != ENETUNREACH && err != TDSSOCK_EINPROGRESS) {
tdsdump_dump_buf(TDS_DBG_ERROR, "Contents of sockaddr_in", addr->ai_addr, addr->ai_addrlen);
tdsdump_log(TDS_DBG_ERROR, " sockaddr_in:\t"
"%s = %x\n"
"\t\t\t%s = %x\n"
"\t\t\t%s = %s\n"
, "sin_family", addr->ai_family
, "port", port
, "address", ipaddr
);
}
#endif
if (err != TDSSOCK_EINPROGRESS)
goto not_available;
*p_oserr = TDSSOCK_ETIMEDOUT;
if (tds_select(tds, TDSSELWRITE|TDSSELERR, timeout) == 0) {
tds_error = TDSECONN;
goto not_available;
}
}
#endif /* not DOS32X */
/* check socket error */
optlen = sizeof(len);
len = 0;
if (tds_getsockopt(conn->s, SOL_SOCKET, SO_ERROR, (char *) &len, &optlen) != 0) {
char *errstr = sock_strerror(*p_oserr = sock_errno);
tdsdump_log(TDS_DBG_ERROR, "getsockopt(2) failed: %s\n", errstr);
sock_strerror_free(errstr);
goto not_available;
}
if (len != 0) {
char *errstr = sock_strerror(*p_oserr = len);
tdsdump_log(TDS_DBG_ERROR, "getsockopt(2) reported: %s\n", errstr);
sock_strerror_free(errstr);
goto not_available;
}
tdsdump_log(TDS_DBG_ERROR, "tds_open_socket() succeeded\n");
return TDSEOK;
not_available:
tds_connection_close(conn);
tdsdump_log(TDS_DBG_ERROR, "tds_open_socket() failed\n");
return tds_error;
}
static int
tds_goodwrite(TDSSOCKET * tds, const unsigned char *buffer, int len, unsigned char last)
{
double start, now;
const unsigned char *p = buffer;
int rc;
assert(tds && buffer);
if (TDS_IS_SOCKET_INVALID(tds->s))
return -1;
while (p - buffer < len) {
start = GetTimeMark();
now = start;
if ((rc = tds_select(tds, TDSSELWRITE, tds->query_timeout, start)) > 0) {
int err;
size_t remaining = len - (p - buffer);
#ifdef USE_MSGMORE
ssize_t nput = send(tds->s, p, remaining, last ? MSG_NOSIGNAL : MSG_NOSIGNAL|MSG_MORE);
/* In case the kernel does not support MSG_MORE, try again without it */
if (nput < 0 && errno == EINVAL && !last)
nput = send(tds->s, p, remaining, MSG_NOSIGNAL);
#elif defined(__APPLE__) && defined(SO_NOSIGPIPE)
ssize_t nput = send(tds->s, p, remaining, 0);
#else
ssize_t nput = WRITESOCKET(tds->s, p, remaining);
#endif
if (nput > 0) {
p += nput;
continue;
}
err = sock_errno;
if (0 == nput || TDSSOCK_WOULDBLOCK(err) || err == TDSSOCK_EINTR)
continue;
assert(nput < 0);
tdsdump_log(TDS_DBG_NETWORK, "send(2) failed: %d (%s)\n",
err, strerror(err));
tds_report_error(tds->tds_ctx, tds, err, 20017,
"Write to SQL Server failed");
tds_close_socket(tds);
return -1;
} else if (rc < 0) {
int err = sock_errno;
if (TDSSOCK_WOULDBLOCK(err)) /* shouldn't happen, but OK, retry */
continue;
tdsdump_log(TDS_DBG_NETWORK, "select(2) failed: %d (%s)\n",
err, strerror(err));
tds_report_error(tds->tds_ctx, tds, err, 20005,
"select/send finished with error");
tds_close_socket(tds);
return -1;
} else { /* timeout */
now = GetTimeMark();
if (tds->query_timeout && (now - start) >= tds->query_timeout) {
tds_client_msg(tds->tds_ctx, tds, 20002, 6, 0, 0,
"Writing to SQL server exceeded timeout");
tds_close_socket(tds);
return -1;
}
tdsdump_log(TDS_DBG_NETWORK, "tds_goodwrite(): timed out, asking client\n");
switch (rc = tds_client_msg(tds->tds_ctx, tds, 20002, 6, 0, 0,
"Writing to SQL server exceeded timeout")) {
case TDS_INT_CONTINUE:
continue;
case TDS_INT_TIMEOUT:
/*
* "Cancel the operation ... but leave the dbproc in working condition."
* We must try to send the cancel packet, else we have to abandon the dbproc.
* If it can't be done, a harder error e.g. ECONNRESET will bubble up.
*/
tds_send_cancel(tds);
continue;
default:
case TDS_INT_CANCEL:
tds_close_socket(tds);
return -1;
}
assert(0); /* not reached */
}
assert(0); /* not reached */
}
#ifdef USE_CORK
/* force packet flush */
if (last) {
int opt;
opt = 0;
setsockopt(tds->s, SOL_TCP, TCP_CORK, (const void *) &opt, sizeof(opt));
opt = 1;
setsockopt(tds->s, SOL_TCP, TCP_CORK, (const void *) &opt, sizeof(opt));
}
#endif
return 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;
}
int
tds_open_socket(TDSSOCKET * tds, const char *ip_addr, unsigned int port, int timeout)
{
struct sockaddr_in sin;
#if !defined(DOS32X)
unsigned long ioctl_blocking = 1;
time_t start;
int retval;
#endif
int len;
int x_errno;
char ip[20];
sin.sin_addr.s_addr = inet_addr(ip_addr);
if (sin.sin_addr.s_addr == INADDR_NONE) {
tdsdump_log(TDS_DBG_ERROR, "inet_addr() failed, IP = %s\n", ip_addr);
return TDS_FAIL;
}
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
tdsdump_log(TDS_DBG_INFO1, "Connecting to %s port %d.\n", tds_inet_ntoa_r(sin.sin_addr, ip, sizeof(ip)), ntohs(sin.sin_port));
if (TDS_IS_SOCKET_INVALID(tds->s = socket(AF_INET, SOCK_STREAM, 0))) {
tds_report_error(tds->tds_ctx, tds, sock_errno, 20008, "Unable to open socket");
return TDS_FAIL;
}
#ifdef SO_KEEPALIVE
len = 1;
setsockopt(tds->s, SOL_SOCKET, SO_KEEPALIVE, (const void *) &len, sizeof(len));
#endif
len = 1;
#if defined(USE_NODELAY) || defined(USE_MSGMORE)
setsockopt(tds->s, SOL_TCP, TCP_NODELAY, (const void *) &len, sizeof(len));
#elif defined(USE_CORK)
if (setsockopt(tds->s, SOL_TCP, TCP_CORK, (const void *) &len, sizeof(len)) < 0)
setsockopt(tds->s, SOL_TCP, TCP_NODELAY, (const void *) &len, sizeof(len));
#else
#error One should be defined
#endif
#ifdef DOS32X /* the other connection doesn't work on WATTCP32 */
if (connect(tds->s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
char *message;
if (asprintf(&message, "src/tds/login.c: tds_connect: %s:%d", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)) >= 0) {
perror(message);
free(message);
}
tds_client_msg(tds->tds_ctx, tds, 20009, 9, 0, 0, "Server is unavailable or does not exist.");
tds_free_socket(tds);
return TDS_FAIL;
}
#else
/* Jeff's hack *** START OF NEW CODE *** */
if (!timeout)
/* I don't think anybody complains... */
timeout = 90000;
start = time(NULL);
/* enable no-blocking mode */
ioctl_blocking = 1;
if (IOCTLSOCKET(tds->s, FIONBIO, &ioctl_blocking) < 0) {
tds_close_socket(tds);
return TDS_FAIL;
}
retval = connect(tds->s, (struct sockaddr *) &sin, sizeof(sin));
x_errno = sock_errno;
if (retval < 0 && x_errno == TDSSOCK_EINPROGRESS)
retval = 0;
/* if retval < 0 (error) fall through */
if (tds_select(tds, TDSSELWRITE|TDSSELERR, timeout, (double)start) <= 0) {
tds_close_socket(tds);
tds_client_msg(tds->tds_ctx, tds, 20015, 6, 0, 0, "SQL Server connection timed out.");
return TDS_FAIL;
}
#endif
/* END OF NEW CODE */
if (retval < 0) {
tds_report_error(tds->tds_ctx, tds, x_errno, 20009, "Server is unavailable or does not exist");
tds_close_socket(tds);
return TDS_FAIL;
}
return TDS_SUCCEED;
}
static TDSERRNO
tds_connect_socket(TDSSOCKET *tds, struct addrinfo *addr, unsigned int port, int timeout, int *p_oserr)
{
SOCKLEN_T optlen;
TDSCONNECTION *conn = tds->conn;
char ipaddr[128];
int retval, len;
tds_addrinfo_set_port(addr, port);
tds_addrinfo2str(addr, ipaddr, sizeof(ipaddr));
if (TDS_IS_SOCKET_INVALID(conn->s))
return TDSECONN;
*p_oserr = 0;
tdsdump_log(TDS_DBG_INFO1, "Connecting to %s port %d (TDS version %d.%d)\n",
ipaddr, port,
TDS_MAJOR(conn), TDS_MINOR(conn));
#ifdef DOS32X /* the other connection doesn't work on WATTCP32 */
if (connect(conn->s, addr->ai_addr, addr->ai_addrlen) < 0) {
*p_oserr = sock_errno;
tdsdump_log(TDS_DBG_ERROR, "tds_open_socket(): %s:%d", ipaddr, port);
return TDSECONN;
}
#else
if (!timeout) {
/* A timeout of zero means wait forever; 90,000 seconds will feel like forever. */
timeout = 90000;
}
if ((*p_oserr = tds_socket_set_nonblocking(conn->s)) != 0) {
tds_connection_close(conn);
return TDSEUSCT; /* close enough: "Unable to set communications timer" */
}
retval = connect(conn->s, addr->ai_addr, addr->ai_addrlen);
if (retval == 0) {
tdsdump_log(TDS_DBG_INFO2, "connection established\n");
} else {
int err = *p_oserr = sock_errno;
char *errstr = sock_strerror(err);
tdsdump_log(TDS_DBG_ERROR, "tds_open_socket: connect(2) returned \"%s\"\n", errstr);
sock_strerror_free(errstr);
#if DEBUGGING_CONNECTING_PROBLEM
if (err != ECONNREFUSED && err != ENETUNREACH && err != TDSSOCK_EINPROGRESS) {
tdsdump_dump_buf(TDS_DBG_ERROR, "Contents of sockaddr_in", addr->ai_addr, addr->ai_addrlen);
tdsdump_log(TDS_DBG_ERROR, " sockaddr_in:\t"
"%s = %x\n"
"\t\t\t%s = %x\n"
"\t\t\t%s = %s\n"
, "sin_family", addr->ai_family
, "port", port
, "address", ipaddr
);
}
#endif
if (err != TDSSOCK_EINPROGRESS)
return TDSECONN;
*p_oserr = TDSSOCK_ETIMEDOUT;
if (tds_select(tds, TDSSELWRITE|TDSSELERR, timeout) == 0)
return TDSECONN;
}
#endif /* not DOS32X */
/* check socket error */
optlen = sizeof(len);
len = 0;
if (tds_getsockopt(conn->s, SOL_SOCKET, SO_ERROR, (char *) &len, &optlen) != 0) {
char *errstr = sock_strerror(*p_oserr = sock_errno);
tdsdump_log(TDS_DBG_ERROR, "getsockopt(2) failed: %s\n", errstr);
sock_strerror_free(errstr);
return TDSECONN;
}
if (len != 0) {
char *errstr = sock_strerror(*p_oserr = len);
tdsdump_log(TDS_DBG_ERROR, "getsockopt(2) reported: %s\n", errstr);
sock_strerror_free(errstr);
return TDSECONN;
}
return TDSEOK;
}
