static int
get_utf16be(const unsigned char *p, size_t len, ICONV_CHAR *out)
{
ICONV_CHAR c, c2;
if (len < 2)
return -EINVAL;
c = TDS_GET_A2BE(p);
if ((c & 0xfc00) == 0xd800) {
if (len < 4)
return -EINVAL;
c2 = TDS_GET_A2BE(p+2);
if ((c2 & 0xfc00) != 0xdc00)
return -EILSEQ;
*out = (c << 10) + c2 - ((0xd800 << 10) + 0xdc00 - 0x10000);
return 4;
}
*out = c;
return 2;
}
/**
* 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 */
}
bool
pool_packet_read(TDSSOCKET *tds)
{
int packet_len;
int readed, err;
tdsdump_log(TDS_DBG_INFO1, "tds in_len %d in_pos %d\n", tds->in_len, tds->in_pos);
/* determine how much we should read */
packet_len = 8;
if (tds->in_len >= 4)
packet_len = TDS_GET_A2BE(&tds->in_buf[2]);
if (tds->in_len >= packet_len) {
tds->in_pos = 0;
tds->in_len = 0;
packet_len = 8;
}
tdsdump_log(TDS_DBG_INFO1, "packet_len %d capacity %d\n", packet_len, tds->recv_packet->capacity);
assert(packet_len > tds->in_len);
assert(packet_len <= tds->recv_packet->capacity);
assert(tds->in_len < tds->recv_packet->capacity);
readed = read(tds_get_s(tds), &tds->in_buf[tds->in_len], packet_len - tds->in_len);
tdsdump_log(TDS_DBG_INFO1, "readed %d\n", readed);
if (readed == 0) {
/* socket closed */
tds->in_len = 0;
return false;
}
if (readed < 0) {
/* error */
err = sock_errno;
if (err == EINTR || TDSSOCK_WOULDBLOCK(err))
return true;
goto failure;
}
tds->in_len += readed;
if (tds->in_len >= 4) {
packet_len = TDS_GET_A2BE(&tds->in_buf[2]);
if (packet_len < 8)
goto failure;
tdsdump_log(TDS_DBG_INFO1, "packet_len %d in_len %d after\n", packet_len, tds->in_len);
/* resize packet if not enough */
if (packet_len > tds->recv_packet->capacity) {
TDSPACKET *packet;
packet = tds_realloc_packet(tds->recv_packet, packet_len);
if (!packet)
goto failure;
tds->in_buf = packet->buf;
tds->recv_packet = packet;
}
CHECK_TDS_EXTRA(tds);
return tds->in_len < packet_len;
}
return true;
failure:
tds->in_len = -1;
return false;
}
/* read partial packet */
static void
tds_packet_read(TDSCONNECTION *conn, TDSSOCKET *tds)
{
TDSPACKET *packet = conn->recv_packet;
int len;
/* allocate some space to read data */
if (!packet) {
conn->recv_packet = packet = tds_get_packet(conn, MAX(conn->env.block_size + sizeof(TDS72_SMP_HEADER), 512));
if (!packet) goto Memory_Error;
TDS_MARK_UNDEFINED(packet->buf, packet->capacity);
conn->recv_pos = 0;
packet->len = 8;
}
assert(conn->recv_pos < packet->len && packet->len <= packet->capacity);
len = tds_connection_read(tds, packet->buf + conn->recv_pos, packet->len - conn->recv_pos);
if (len < 0)
goto Severe_Error;
conn->recv_pos += len;
assert(conn->recv_pos <= packet->len && packet->len <= packet->capacity);
/* handle SMP */
if (conn->recv_pos > 0 && packet->buf[0] == TDS72_SMP) {
TDS72_SMP_HEADER mars_header;
short sid;
TDSSOCKET *tds;
TDS_UINT size;
if (conn->recv_pos < 16) {
packet->len = 16;
return;
}
memcpy(&mars_header, packet->buf, sizeof(mars_header));
tdsdump_dump_buf(TDS_DBG_HEADER, "Received MARS header", &mars_header, sizeof(mars_header));
sid = TDS_GET_A2LE(&mars_header.sid);
/* FIXME this is done even by caller !! */
tds = NULL;
tds_mutex_lock(&conn->list_mtx);
if (sid >= 0 && sid < conn->num_sessions)
tds = conn->sessions[sid];
tds_mutex_unlock(&conn->list_mtx);
packet->sid = sid;
if (tds == BUSY_SOCKET) {
if (mars_header.type != TDS_SMP_FIN) {
tdsdump_log(TDS_DBG_ERROR, "Received MARS with no session (%d)\n", sid);
goto Severe_Error;
}
/* check if was just a "zombie" socket */
tds_mutex_lock(&conn->list_mtx);
conn->sessions[sid] = NULL;
tds_mutex_unlock(&conn->list_mtx);
/* reset packet to initial state to reuse it */
packet->len = 8;
conn->recv_pos = 0;
return;
}
if (!tds) {
/* server sent a unknown packet, close connection */
goto Severe_Error;
}
tds->send_wnd = TDS_GET_A4LE(&mars_header.wnd);
size = TDS_GET_A4LE(&mars_header.size);
if (mars_header.type == TDS_SMP_ACK) {
if (size != sizeof(mars_header))
goto Severe_Error;
} else if (mars_header.type == TDS_SMP_DATA) {
if (size < 0x18 || size > 0xffffu + sizeof(mars_header))
goto Severe_Error;
/* avoid recursive SMP */
if (conn->recv_pos > 16 && packet->buf[16] == TDS72_SMP)
goto Severe_Error;
/* TODO is possible to put 2 TDS packet inside a single DATA ?? */
if (conn->recv_pos >= 20 && TDS_GET_A2BE(&packet->buf[18]) != size - 16)
goto Severe_Error;
tds->recv_seq = TDS_GET_A4LE(&mars_header.seq);
/*
* does not sent ACK here cause this would lead to memory waste
* if session is not able to handle all that packets
*/
} else if (mars_header.type == TDS_SMP_FIN) {
if (size != sizeof(mars_header))
goto Severe_Error;
/* this socket shold now not start another session */
// tds_set_state(tds, TDS_DEAD);
// tds->sid = -1;
} else
goto Severe_Error;
if (mars_header.type != TDS_SMP_DATA)
return;
if (packet->len < size) {
packet = tds_realloc_packet(packet, size);
if (!packet) goto Memory_Error;
conn->recv_packet = packet;
}
packet->len = size;
return;
}
assert(conn->recv_pos <= packet->len && packet->len <= packet->capacity);
/* normal packet */
if (conn->recv_pos >= 8) {
len = TDS_GET_A2BE(&packet->buf[2]);
if (len < 8)
goto Severe_Error;
if (packet->len < len) {
packet = tds_realloc_packet(packet, len);
if (!packet) goto Memory_Error;
conn->recv_packet = packet;
}
packet->len = len;
}
return;
Memory_Error:
Severe_Error:
tds_connection_close(conn);
tds_free_packets(packet);
conn->recv_packet = NULL;
}
/**
* Read part of packet. Function does not block.
* @return true if packet is not complete and we must call again,
* false on full packet or error.
*/
bool
pool_packet_read(TDSSOCKET *tds)
{
int packet_len;
int readed, err;
tdsdump_log(TDS_DBG_INFO1, "tds in_len %d in_pos %d\n", tds->in_len, tds->in_pos);
// TODO MARS
/* determine packet size */
packet_len = tds->in_len >= 4 ? TDS_GET_A2BE(&tds->in_buf[2]) : 8;
if (TDS_UNLIKELY(packet_len < 8)) {
tds->in_len = 0;
return false;
}
/* get another packet */
if (tds->in_len >= packet_len) {
tds->in_pos = 0;
tds->in_len = 0;
}
for (;;) {
/* determine packet size */
packet_len = 8;
if (tds->in_len >= 4) {
packet_len = TDS_GET_A2BE(&tds->in_buf[2]);
if (packet_len < 8)
break;
tdsdump_log(TDS_DBG_INFO1, "packet_len %d in_len %d\n", packet_len, tds->in_len);
/* resize packet if not enough */
if (packet_len > tds->recv_packet->capacity) {
TDSPACKET *packet;
packet = tds_realloc_packet(tds->recv_packet, packet_len);
if (!packet)
break;
tds->in_buf = packet->buf;
tds->recv_packet = packet;
}
CHECK_TDS_EXTRA(tds);
if (tds->in_len >= packet_len)
return false;
}
assert(packet_len > tds->in_len);
assert(packet_len <= tds->recv_packet->capacity);
assert(tds->in_len < tds->recv_packet->capacity);
readed = read(tds_get_s(tds), &tds->in_buf[tds->in_len], packet_len - tds->in_len);
tdsdump_log(TDS_DBG_INFO1, "readed %d\n", readed);
/* socket closed */
if (readed == 0)
break;
/* error */
if (readed < 0) {
err = sock_errno;
if (err == EINTR)
continue;
if (TDSSOCK_WOULDBLOCK(err))
return true;
break;
}
/* got some data */
tds->in_len += readed;
}
/* failure */
tds->in_len = 0;
return false;
}
