1 /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
2 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Brian Bruns
3 * Copyright (C) 2004-2015 Ziglio Frediano
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
19 */
20
21 #include <config.h>
22
23 #include <stdarg.h>
24 #include <stdio.h>
25
26 #include <freetds/time.h>
27
28 #if HAVE_SYS_TYPES_H
29 #include <sys/types.h>
30 #endif /* HAVE_SYS_TYPES_H */
31
32 #if HAVE_ERRNO_H
33 #include <errno.h>
34 #endif /* HAVE_ERRNO_H */
35
36 #if HAVE_UNISTD_H
37 #include <unistd.h>
38 #endif /* HAVE_UNISTD_H */
39
40 #if HAVE_STDLIB_H
41 #include <stdlib.h>
42 #endif /* HAVE_STDLIB_H */
43
44 #if HAVE_STRING_H
45 #include <string.h>
46 #endif /* HAVE_STRING_H */
47
48 #if HAVE_SYS_SOCKET_H
49 #include <sys/socket.h>
50 #endif /* HAVE_SYS_SOCKET_H */
51
52 #if HAVE_NETINET_IN_H
53 #include <netinet/in.h>
54 #endif /* HAVE_NETINET_IN_H */
55
56 #if HAVE_NETINET_TCP_H
57 #include <netinet/tcp.h>
58 #endif /* HAVE_NETINET_TCP_H */
59
60 #if HAVE_ARPA_INET_H
61 #include <arpa/inet.h>
62 #endif /* HAVE_ARPA_INET_H */
63
64 #if HAVE_SYS_IOCTL_H
65 #include <sys/ioctl.h>
66 #endif /* HAVE_SYS_IOCTL_H */
67
68 #if HAVE_SELECT_H
69 #include <sys/select.h>
70 #endif /* HAVE_SELECT_H */
71
72 #if HAVE_POLL_H
73 #include <poll.h>
74 #endif /* HAVE_POLL_H */
75
76 #include <freetds/tds.h>
77 #include <freetds/string.h>
78 #include <freetds/tls.h>
79 #include "replacements.h"
80
81 #include <signal.h>
82 #include <assert.h>
83
84 /* error is always returned */
85 #define TDSSELERR 0
86 #define TDSPOLLURG 0x8000u
87
88 #if ENABLE_ODBC_MARS
89 static void tds_check_cancel(TDSCONNECTION *conn);
90 #endif
91
92
93 /**
94 * \addtogroup network
95 * @{
96 */
97
98 #ifdef _WIN32
99 int
tds_socket_init(void)100 tds_socket_init(void)
101 {
102 WSADATA wsadata;
103
104 return WSAStartup(MAKEWORD(1, 1), &wsadata);
105 }
106
107 void
tds_socket_done(void)108 tds_socket_done(void)
109 {
110 WSACleanup();
111 }
112 #endif
113
114 #if !defined(SOL_TCP) && (defined(IPPROTO_TCP) || defined(_WIN32))
115 /* fix incompatibility between MS headers */
116 # ifndef IPPROTO_TCP
117 # define IPPROTO_TCP IPPROTO_TCP
118 # endif
119 # define SOL_TCP IPPROTO_TCP
120 #endif
121
122 /* Optimize the way we send packets */
123 #undef USE_MSGMORE
124 #undef USE_CORK
125 #undef USE_NODELAY
126 /* On Linux 2.4.x we can use MSG_MORE */
127 #if defined(__linux__) && defined(MSG_MORE)
128 #define USE_MSGMORE 1
129 /* On early Linux use TCP_CORK if available */
130 #elif defined(__linux__) && defined(TCP_CORK)
131 #define USE_CORK 1
132 /* On *BSD try to use TCP_CORK */
133 /*
134 * NOPUSH flag do not behave in the same way
135 * cf ML "FreeBSD 5.0 performance problems with TCP_NOPUSH"
136 */
137 #elif (defined(__FreeBSD__) || defined(__GNU_FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)) && defined(TCP_CORK)
138 #define USE_CORK 1
139 /* otherwise use NODELAY */
140 #elif defined(TCP_NODELAY) && defined(SOL_TCP)
141 #define USE_NODELAY 1
142 /* under VMS we have to define TCP_NODELAY */
143 #elif defined(__VMS)
144 #define TCP_NODELAY 1
145 #define USE_NODELAY 1
146 #endif
147
148 #if !defined(_WIN32)
149 typedef unsigned int ioctl_nonblocking_t;
150 #else
151 typedef u_long ioctl_nonblocking_t;
152 #endif
153
154 static void
tds_addrinfo_set_port(struct tds_addrinfo * addr,unsigned int port)155 tds_addrinfo_set_port(struct tds_addrinfo *addr, unsigned int port)
156 {
157 assert(addr != NULL);
158
159 switch(addr->ai_family) {
160 case AF_INET:
161 ((struct sockaddr_in *) addr->ai_addr)->sin_port = htons(port);
162 break;
163
164 #ifdef AF_INET6
165 case AF_INET6:
166 ((struct sockaddr_in6 *) addr->ai_addr)->sin6_port = htons(port);
167 break;
168 #endif
169 }
170 }
171
172 const char*
tds_addrinfo2str(struct tds_addrinfo * addr,char * name,int namemax)173 tds_addrinfo2str(struct tds_addrinfo *addr, char *name, int namemax)
174 {
175 #ifndef NI_NUMERICHOST
176 #define NI_NUMERICHOST 0
177 #endif
178 if (!name || namemax <= 0)
179 return "";
180 if (tds_getnameinfo(addr->ai_addr, addr->ai_addrlen, name, namemax, NULL, 0, NI_NUMERICHOST) == 0)
181 return name;
182 name[0] = 0;
183 return name;
184 }
185
186 TDSERRNO
tds_open_socket(TDSSOCKET * tds,struct tds_addrinfo * addr,unsigned int port,int timeout,int * p_oserr)187 tds_open_socket(TDSSOCKET *tds, struct tds_addrinfo *addr, unsigned int port, int timeout, int *p_oserr)
188 {
189 ioctl_nonblocking_t ioctl_nonblocking;
190 SOCKLEN_T optlen;
191 TDSCONNECTION *conn = tds->conn;
192 char ipaddr[128];
193
194 int retval, len;
195 TDSERRNO tds_error = TDSECONN;
196
197 *p_oserr = 0;
198
199 tds_addrinfo_set_port(addr, port);
200 tds_addrinfo2str(addr, ipaddr, sizeof(ipaddr));
201
202 tdsdump_log(TDS_DBG_INFO1, "Connecting to %s port %d (TDS version %d.%d)\n",
203 ipaddr, port,
204 TDS_MAJOR(conn), TDS_MINOR(conn));
205
206 conn->s = socket(addr->ai_family, SOCK_STREAM, 0);
207 if (TDS_IS_SOCKET_INVALID(conn->s)) {
208 *p_oserr = sock_errno;
209 tdsdump_log(TDS_DBG_ERROR, "socket creation error: %s\n", sock_strerror(sock_errno));
210 return TDSESOCK;
211 }
212 tds->state = TDS_IDLE;
213
214 #ifdef SO_KEEPALIVE
215 len = 1;
216 setsockopt(conn->s, SOL_SOCKET, SO_KEEPALIVE, (const void *) &len, sizeof(len));
217 #endif
218
219 #if defined(TCP_KEEPIDLE) && defined(TCP_KEEPINTVL)
220 len = 40;
221 setsockopt(conn->s, SOL_TCP, TCP_KEEPIDLE, (const void *) &len, sizeof(len));
222 len = 2;
223 setsockopt(conn->s, SOL_TCP, TCP_KEEPINTVL, (const void *) &len, sizeof(len));
224 #endif
225
226 #if defined(__APPLE__) && defined(SO_NOSIGPIPE)
227 len = 1;
228 if (setsockopt(conn->s, SOL_SOCKET, SO_NOSIGPIPE, (const void *) &len, sizeof(len))) {
229 *p_oserr = sock_errno;
230 tds_connection_close(conn);
231 return TDSESOCK;
232 }
233 #endif
234
235 len = 1;
236 #if defined(USE_NODELAY) || defined(USE_MSGMORE)
237 setsockopt(conn->s, SOL_TCP, TCP_NODELAY, (const void *) &len, sizeof(len));
238 #elif defined(USE_CORK)
239 if (setsockopt(conn->s, SOL_TCP, TCP_CORK, (const void *) &len, sizeof(len)) < 0)
240 setsockopt(conn->s, SOL_TCP, TCP_NODELAY, (const void *) &len, sizeof(len));
241 #else
242 #error One should be defined
243 #endif
244
245 #ifdef DOS32X /* the other connection doesn't work on WATTCP32 */
246 if (connect(conn->s, addr->ai_addr, addr->ai_addrlen) < 0) {
247 char *message;
248
249 *p_oserr = sock_errno;
250 if (asprintf(&message, "tds_open_socket(): %s:%d", ipaddr, port) >= 0) {
251 perror(message);
252 free(message);
253 }
254 tds_connection_close(conn);
255 return TDSECONN;
256 }
257 #else
258 if (!timeout) {
259 /* A timeout of zero means wait forever; 90,000 seconds will feel like forever. */
260 timeout = 90000;
261 }
262
263 /* enable non-blocking mode */
264 ioctl_nonblocking = 1;
265 if (IOCTLSOCKET(conn->s, FIONBIO, &ioctl_nonblocking) < 0) {
266 *p_oserr = sock_errno;
267 tds_connection_close(conn);
268 return TDSEUSCT; /* close enough: "Unable to set communications timer" */
269 }
270 retval = connect(conn->s, addr->ai_addr, addr->ai_addrlen);
271 if (retval == 0) {
272 tdsdump_log(TDS_DBG_INFO2, "connection established\n");
273 } else {
274 int err = *p_oserr = sock_errno;
275 tdsdump_log(TDS_DBG_ERROR, "tds_open_socket: connect(2) returned \"%s\"\n", sock_strerror(err));
276 #if DEBUGGING_CONNECTING_PROBLEM
277 if (err != ECONNREFUSED && err != ENETUNREACH && err != TDSSOCK_EINPROGRESS) {
278 tdsdump_dump_buf(TDS_DBG_ERROR, "Contents of sockaddr_in", addr->ai_addr, addr->ai_addrlen);
279 tdsdump_log(TDS_DBG_ERROR, " sockaddr_in:\t"
280 "%s = %x\n"
281 "\t\t\t%s = %x\n"
282 "\t\t\t%s = %s\n"
283 , "sin_family", addr->ai_family
284 , "port", port
285 , "address", ipaddr
286 );
287 }
288 #endif
289 if (err != TDSSOCK_EINPROGRESS)
290 goto not_available;
291
292 *p_oserr = TDSSOCK_ETIMEDOUT;
293 if (tds_select(tds, TDSSELWRITE|TDSSELERR, timeout) <= 0) {
294 tds_error = TDSECONN;
295 goto not_available;
296 }
297 }
298 #endif /* not DOS32X */
299
300 /* check socket error */
301 optlen = sizeof(len);
302 len = 0;
303 if (tds_getsockopt(conn->s, SOL_SOCKET, SO_ERROR, (char *) &len, &optlen) != 0) {
304 *p_oserr = sock_errno;
305 tdsdump_log(TDS_DBG_ERROR, "getsockopt(2) failed: %s\n", sock_strerror(sock_errno));
306 goto not_available;
307 }
308 if (len != 0) {
309 *p_oserr = len;
310 tdsdump_log(TDS_DBG_ERROR, "getsockopt(2) reported: %s\n", sock_strerror(len));
311 goto not_available;
312 }
313
314 tdsdump_log(TDS_DBG_ERROR, "tds_open_socket() succeeded\n");
315 return TDSEOK;
316
317 not_available:
318
319 tds_connection_close(conn);
320 tdsdump_log(TDS_DBG_ERROR, "tds_open_socket() failed\n");
321 return tds_error;
322 }
323
324 /**
325 * Close current socket
326 * for last socket close entire connection
327 * for MARS send FIN request
328 */
329 void
tds_close_socket(TDSSOCKET * tds)330 tds_close_socket(TDSSOCKET * tds)
331 {
332 if (!IS_TDSDEAD(tds)) {
333 #if ENABLE_ODBC_MARS
334 TDSCONNECTION *conn = tds->conn;
335 unsigned n = 0, count = 0;
336 tds_mutex_lock(&conn->list_mtx);
337 for (; n < conn->num_sessions; ++n)
338 if (TDSSOCKET_VALID(conn->sessions[n]))
339 ++count;
340 if (count > 1)
341 tds_append_fin(tds);
342 tds_mutex_unlock(&conn->list_mtx);
343 if (count <= 1) {
344 tds_disconnect(tds);
345 tds_connection_close(conn);
346 } else {
347 tds_set_state(tds, TDS_DEAD);
348 }
349 #else
350 tds_disconnect(tds);
351 if ( !TDS_IS_SOCKET_INVALID(tds_get_s(tds))
352 && CLOSESOCKET(tds_get_s(tds)) == -1)
353 tdserror(tds_get_ctx(tds), tds, TDSECLOS, sock_errno);
354 tds_set_s(tds, INVALID_SOCKET);
355 tds_set_state(tds, TDS_DEAD);
356 #endif
357 }
358 }
359
360 #if ENABLE_ODBC_MARS
361 void
tds_connection_close(TDSCONNECTION * conn)362 tds_connection_close(TDSCONNECTION *conn)
363 {
364 unsigned n = 0;
365
366 if (!TDS_IS_SOCKET_INVALID(conn->s)) {
367 /* TODO check error ?? how to return it ?? */
368 CLOSESOCKET(conn->s);
369 conn->s = INVALID_SOCKET;
370 }
371
372 tds_mutex_lock(&conn->list_mtx);
373 for (; n < conn->num_sessions; ++n)
374 if (TDSSOCKET_VALID(conn->sessions[n]))
375 tds_set_state(conn->sessions[n], TDS_DEAD);
376 tds_mutex_unlock(&conn->list_mtx);
377 }
378 #endif
379
380 /**
381 * Select on a socket until it's available or the timeout expires.
382 * Meanwhile, call the interrupt function.
383 * \return >0 ready descriptors
384 * 0 timeout
385 * <0 error (cf. errno). Caller should close socket and return failure.
386 * This function does not call tdserror or close the socket because it can't know the context in which it's being called.
387 */
388 int
tds_select(TDSSOCKET * tds,unsigned tds_sel,int timeout_seconds)389 tds_select(TDSSOCKET * tds, unsigned tds_sel, int timeout_seconds)
390 {
391 int rc, seconds;
392 unsigned int poll_seconds;
393
394 assert(tds != NULL);
395 assert(timeout_seconds >= 0);
396
397 /*
398 * The select loop.
399 * If an interrupt handler is installed, we iterate once per second,
400 * else we try once, timing out after timeout_seconds (0 == never).
401 * If select(2) is interrupted by a signal (e.g. press ^C in sqsh), we timeout.
402 * (The application can retry if desired by installing a signal handler.)
403 *
404 * We do not measure current time against end time, to avoid being tricked by ntpd(8) or similar.
405 * Instead, we just count down.
406 *
407 * We exit on the first of these events:
408 * 1. a descriptor is ready. (return to caller)
409 * 2. select(2) returns an important error. (return to caller)
410 * A timeout of zero says "wait forever". We do that by passing a NULL timeval pointer to select(2).
411 */
412 poll_seconds = (tds_get_ctx(tds) && tds_get_ctx(tds)->int_handler)? 1 : timeout_seconds;
413 for (seconds = timeout_seconds; timeout_seconds == 0 || seconds > 0; seconds -= poll_seconds) {
414 struct pollfd fds[2];
415 int timeout = poll_seconds ? poll_seconds * 1000 : -1;
416
417 if (TDS_IS_SOCKET_INVALID(tds_get_s(tds)))
418 return -1;
419
420 if ((tds_sel & TDSSELREAD) != 0 && tds->conn->tls_session && tds_ssl_pending(tds->conn))
421 return POLLIN;
422
423 fds[0].fd = tds_get_s(tds);
424 fds[0].events = tds_sel;
425 fds[0].revents = 0;
426 fds[1].fd = tds->conn->s_signaled;
427 fds[1].events = POLLIN;
428 fds[1].revents = 0;
429 rc = poll(fds, 2, timeout);
430
431 if (rc > 0 ) {
432 if (fds[0].revents & POLLERR) {
433 set_sock_errno(TDSSOCK_ECONNRESET);
434 return -1;
435 }
436 rc = fds[0].revents;
437 if (fds[1].revents) {
438 #if ENABLE_ODBC_MARS
439 tds_check_cancel(tds->conn);
440 #endif
441 rc |= TDSPOLLURG;
442 }
443 return rc;
444 }
445
446 if (rc < 0) {
447 switch (sock_errno) {
448 case TDSSOCK_EINTR:
449 case EAGAIN:
450 case TDSSOCK_EINPROGRESS:
451 /* FIXME this should be global maximun, not loop one */
452 seconds += poll_seconds;
453 break; /* let interrupt handler be called */
454 default: /* documented: EFAULT, EBADF, EINVAL */
455 tdsdump_log(TDS_DBG_ERROR, "error: poll(2) returned %d, \"%s\"\n",
456 sock_errno, sock_strerror(sock_errno));
457 return rc;
458 }
459 }
460
461 assert(rc == 0 || (rc < 0 && sock_errno == TDSSOCK_EINTR));
462
463 if (tds_get_ctx(tds) && tds_get_ctx(tds)->int_handler) { /* interrupt handler installed */
464 /*
465 * "If hndlintr() returns INT_CANCEL, DB-Library sends an attention token [TDS_BUFSTAT_ATTN]
466 * to the server. This causes the server to discontinue command processing.
467 * The server may send additional results that have already been computed.
468 * When control returns to the mainline code, the mainline code should do
469 * one of the following:
470 * - Flush the results using dbcancel
471 * - Process the results normally"
472 */
473 int timeout_action = (*tds_get_ctx(tds)->int_handler) (tds_get_parent(tds));
474 switch (timeout_action) {
475 case TDS_INT_CONTINUE: /* keep waiting */
476 continue;
477 case TDS_INT_CANCEL: /* abort the current command batch */
478 /* FIXME tell tds_goodread() not to call tdserror() */
479 return 0;
480 default:
481 tdsdump_log(TDS_DBG_NETWORK,
482 "tds_select: invalid interupt handler return code: %d\n", timeout_action);
483 return -1;
484 }
485 }
486 /*
487 * We can reach here if no interrupt handler was installed and we either timed out or got EINTR.
488 * We cannot be polling, so we are about to drop out of the loop.
489 */
490 assert(poll_seconds == timeout_seconds);
491 }
492
493 return 0;
494 }
495
496 /**
497 * Read from an OS socket
498 * @TODO remove tds, save error somewhere, report error in another way
499 * @returns 0 if blocking, <0 error >0 bytes read
500 */
501 static ssize_t
tds_socket_read(TDSCONNECTION * conn,TDSSOCKET * tds,unsigned char * buf,size_t buflen)502 tds_socket_read(TDSCONNECTION * conn, TDSSOCKET *tds, unsigned char *buf, size_t buflen)
503 {
504 ssize_t len;
505 int err;
506
507 /* read directly from socket*/
508 len = READSOCKET(conn->s, buf, buflen);
509 if (len > 0)
510 return len;
511
512 err = sock_errno;
513 if (len < 0 && TDSSOCK_WOULDBLOCK(err))
514 return 0;
515
516 /* detect connection close */
517 tds_connection_close(conn);
518 tdserror(conn->tds_ctx, tds, len == 0 ? TDSESEOF : TDSEREAD, len == 0 ? 0 : err);
519 return -1;
520 }
521
522 /**
523 * Write to an OS socket
524 * @returns 0 if blocking, <0 error >0 bytes readed
525 */
526 static ssize_t
tds_socket_write(TDSCONNECTION * conn,TDSSOCKET * tds,const unsigned char * buf,size_t buflen,int last)527 tds_socket_write(TDSCONNECTION *conn, TDSSOCKET *tds, const unsigned char *buf, size_t buflen, int last)
528 {
529 int err;
530 ssize_t len;
531
532 #ifdef USE_MSGMORE
533 len = send(conn->s, buf, buflen, last ? MSG_NOSIGNAL : MSG_NOSIGNAL|MSG_MORE);
534 /* In case the kernel does not support MSG_MORE, try again without it */
535 if (len < 0 && errno == EINVAL && !last)
536 len = send(conn->s, buf, buflen, MSG_NOSIGNAL);
537 #elif defined(__APPLE__) && defined(SO_NOSIGPIPE)
538 len = send(conn->s, buf, buflen, 0);
539 #else
540 len = WRITESOCKET(conn->s, buf, buflen);
541 #endif
542 if (len > 0)
543 return len;
544
545 err = sock_errno;
546 if (0 == len || TDSSOCK_WOULDBLOCK(err) || err == TDSSOCK_EINTR)
547 return 0;
548
549 assert(len < 0);
550
551 /* detect connection close */
552 tdsdump_log(TDS_DBG_NETWORK, "send(2) failed: %d (%s)\n", err, sock_strerror(err));
553 tds_connection_close(conn);
554 tdserror(conn->tds_ctx, tds, TDSEWRIT, err);
555 return -1;
556 }
557
558 #if ENABLE_ODBC_MARS
559 static void
tds_check_cancel(TDSCONNECTION * conn)560 tds_check_cancel(TDSCONNECTION *conn)
561 {
562 TDSSOCKET *tds;
563 int rc;
564 ssize_t len;
565 char to_cancel[16];
566
567 len = READSOCKET(conn->s_signaled, to_cancel, sizeof(to_cancel));
568 do {
569 /* no cancel found */
570 if (len <= 0) return;
571 } while(!to_cancel[--len]);
572
573 do {
574 unsigned n = 0;
575
576 rc = TDS_SUCCESS;
577 tds_mutex_lock(&conn->list_mtx);
578 /* Here we scan all list searching for sessions that should send cancel packets */
579 for (; n < conn->num_sessions; ++n)
580 if (TDSSOCKET_VALID(tds=conn->sessions[n]) && tds->in_cancel == 1) {
581 /* send cancel */
582 tds->in_cancel = 2;
583 tds_mutex_unlock(&conn->list_mtx);
584 rc = tds_append_cancel(tds);
585 tds_mutex_lock(&conn->list_mtx);
586 if (rc != TDS_SUCCESS)
587 break;
588 }
589 tds_mutex_unlock(&conn->list_mtx);
590 /* for all failed */
591 /* this must be done outside loop cause it can alter list */
592 /* this must be done unlocked cause it can lock again */
593 if (rc != TDS_SUCCESS)
594 tds_close_socket(tds);
595 } while(rc != TDS_SUCCESS);
596 }
597 #endif
598
599 /**
600 * Loops until we have received some characters
601 * return -1 on failure
602 */
603 ssize_t
tds_goodread(TDSSOCKET * tds,unsigned char * buf,size_t buflen)604 tds_goodread(TDSSOCKET * tds, unsigned char *buf, size_t buflen)
605 {
606 if (tds == NULL || buf == NULL || buflen < 1)
607 return -1;
608
609 for (;;) {
610 ssize_t len;
611 int err;
612
613 /* FIXME this block writing from other sessions */
614 len = tds_select(tds, TDSSELREAD, tds->query_timeout);
615 #if !ENABLE_ODBC_MARS
616 if (len > 0 && (len & TDSPOLLURG)) {
617 char buf[32];
618 READSOCKET(tds->conn->s_signaled, buf, sizeof(buf));
619 /* send cancel */
620 if (tds->in_cancel == 1)
621 tds_put_cancel(tds);
622 continue;
623 }
624 #endif
625 if (len > 0) {
626 len = tds_socket_read(tds->conn, tds, buf, buflen);
627 if (len == 0)
628 continue;
629 return len;
630 }
631
632 /* error */
633 if (len < 0) {
634 if (TDSSOCK_WOULDBLOCK(sock_errno)) /* shouldn't happen, but OK */
635 continue;
636 err = sock_errno;
637 tds_connection_close(tds->conn);
638 tdserror(tds_get_ctx(tds), tds, TDSEREAD, err);
639 return -1;
640 }
641
642 /* timeout */
643 switch (tdserror(tds_get_ctx(tds), tds, TDSETIME, sock_errno)) {
644 case TDS_INT_CONTINUE:
645 break;
646 default:
647 case TDS_INT_CANCEL:
648 tds_close_socket(tds);
649 return -1;
650 }
651 }
652 }
653
654 ssize_t
tds_connection_read(TDSSOCKET * tds,unsigned char * buf,size_t buflen)655 tds_connection_read(TDSSOCKET * tds, unsigned char *buf, size_t buflen)
656 {
657 TDSCONNECTION *conn = tds->conn;
658
659 if (conn->tls_session)
660 return tds_ssl_read(conn, buf, buflen);
661
662 #if ENABLE_ODBC_MARS
663 return tds_socket_read(conn, tds, buf, buflen);
664 #else
665 return tds_goodread(tds, buf, buflen);
666 #endif
667 }
668
669 /**
670 * \param tds the famous socket
671 * \param buffer data to send
672 * \param buflen bytes in buffer
673 * \param last 1 if this is the last packet, else 0
674 * \return length written (>0), <0 on failure
675 */
676 ssize_t
tds_goodwrite(TDSSOCKET * tds,const unsigned char * buffer,size_t buflen,unsigned char last)677 tds_goodwrite(TDSSOCKET * tds, const unsigned char *buffer, size_t buflen, unsigned char last)
678 {
679 ssize_t len;
680 size_t sent = 0;
681
682 assert(tds && buffer);
683
684 while (sent < buflen) {
685 /* TODO if send buffer is full we block receive !!! */
686 len = tds_select(tds, TDSSELWRITE, tds->query_timeout);
687
688 if (len > 0) {
689 len = tds_socket_write(tds->conn, tds, buffer + sent, buflen - sent, last);
690 if (len == 0)
691 continue;
692 if (len < 0)
693 return len;
694
695 sent += len;
696 continue;
697 }
698
699 /* error */
700 if (len < 0) {
701 int err = sock_errno;
702 if (TDSSOCK_WOULDBLOCK(err)) /* shouldn't happen, but OK, retry */
703 continue;
704 tdsdump_log(TDS_DBG_NETWORK, "select(2) failed: %d (%s)\n", err, sock_strerror(err));
705 tds_connection_close(tds->conn);
706 tdserror(tds_get_ctx(tds), tds, TDSEWRIT, err);
707 return -1;
708 }
709
710 /* timeout */
711 tdsdump_log(TDS_DBG_NETWORK, "tds_goodwrite(): timed out, asking client\n");
712 switch (tdserror(tds_get_ctx(tds), tds, TDSETIME, sock_errno)) {
713 case TDS_INT_CONTINUE:
714 break;
715 default:
716 case TDS_INT_CANCEL:
717 tds_close_socket(tds);
718 return -1;
719 }
720 }
721
722 #ifdef USE_CORK
723 /* force packet flush */
724 if (last) {
725 int opt;
726 TDS_SYS_SOCKET sock = tds_get_s(tds);
727 opt = 0;
728 setsockopt(sock, SOL_TCP, TCP_CORK, (const void *) &opt, sizeof(opt));
729 opt = 1;
730 setsockopt(sock, SOL_TCP, TCP_CORK, (const void *) &opt, sizeof(opt));
731 }
732 #endif
733
734 return (int) sent;
735 }
736
737 ssize_t
tds_connection_write(TDSSOCKET * tds,unsigned char * buf,size_t buflen,int final)738 tds_connection_write(TDSSOCKET *tds, unsigned char *buf, size_t buflen, int final)
739 {
740 ssize_t sent;
741 TDSCONNECTION *conn = tds->conn;
742
743 #if !defined(_WIN32) && !defined(MSG_NOSIGNAL) && !defined(DOS32X) && (!defined(__APPLE__) || !defined(SO_NOSIGPIPE))
744 void (*oldsig) (int);
745
746 oldsig = signal(SIGPIPE, SIG_IGN);
747 if (oldsig == SIG_ERR) {
748 tdsdump_log(TDS_DBG_WARN, "TDS: Warning: Couldn't set SIGPIPE signal to be ignored\n");
749 }
750 #endif
751
752 if (conn->tls_session)
753 sent = tds_ssl_write(conn, buf, buflen);
754 else
755 #if ENABLE_ODBC_MARS
756 sent = tds_socket_write(conn, tds, buf, buflen, final);
757 #else
758 sent = tds_goodwrite(tds, buf, buflen, final);
759 #endif
760
761 #if !defined(_WIN32) && !defined(MSG_NOSIGNAL) && !defined(DOS32X) && (!defined(__APPLE__) || !defined(SO_NOSIGPIPE))
762 if (signal(SIGPIPE, oldsig) == SIG_ERR) {
763 tdsdump_log(TDS_DBG_WARN, "TDS: Warning: Couldn't reset SIGPIPE signal to previous value\n");
764 }
765 #endif
766 return sent;
767 }
768
769 /**
770 * Get port of all instances
771 * @return default port number or 0 if error
772 * @remark experimental, cf. MC-SQLR.pdf.
773 */
774 int
tds7_get_instance_ports(FILE * output,struct tds_addrinfo * addr)775 tds7_get_instance_ports(FILE *output, struct tds_addrinfo *addr)
776 {
777 int num_try;
778 ioctl_nonblocking_t ioctl_nonblocking;
779 struct pollfd fd;
780 int retval;
781 TDS_SYS_SOCKET s;
782 char msg[16*1024];
783 size_t msg_len = 0;
784 int port = 0;
785 char ipaddr[128];
786
787
788 tds_addrinfo_set_port(addr, 1434);
789 tds_addrinfo2str(addr, ipaddr, sizeof(ipaddr));
790
791 tdsdump_log(TDS_DBG_ERROR, "tds7_get_instance_ports(%s)\n", ipaddr);
792
793 /* create an UDP socket */
794 if (TDS_IS_SOCKET_INVALID(s = socket(addr->ai_family, SOCK_DGRAM, 0))) {
795 tdsdump_log(TDS_DBG_ERROR, "socket creation error: %s\n", sock_strerror(sock_errno));
796 return 0;
797 }
798
799 /*
800 * on cluster environment is possible that reply packet came from
801 * different IP so do not filter by ip with connect
802 */
803
804 ioctl_nonblocking = 1;
805 if (IOCTLSOCKET(s, FIONBIO, &ioctl_nonblocking) < 0) {
806 CLOSESOCKET(s);
807 return 0;
808 }
809
810 /*
811 * Request the instance's port from the server.
812 * There is no easy way to detect if port is closed so we always try to
813 * get a reply from server 16 times.
814 */
815 for (num_try = 0; num_try < 16 && msg_len == 0; ++num_try) {
816 /* send the request */
817 msg[0] = 3;
818 sendto(s, msg, 1, 0, addr->ai_addr, addr->ai_addrlen);
819
820 fd.fd = s;
821 fd.events = POLLIN;
822 fd.revents = 0;
823
824 retval = poll(&fd, 1, 1000);
825
826 /* on interrupt ignore */
827 if (retval < 0 && sock_errno == TDSSOCK_EINTR)
828 continue;
829
830 if (retval == 0) { /* timed out */
831 #if 1
832 tdsdump_log(TDS_DBG_ERROR, "tds7_get_instance_port: timed out on try %d of 16\n", num_try);
833 continue;
834 #else
835 int rc;
836 tdsdump_log(TDS_DBG_INFO1, "timed out\n");
837
838 switch(rc = tdserror(NULL, NULL, TDSETIME, 0)) {
839 case TDS_INT_CONTINUE:
840 continue; /* try again */
841
842 default:
843 tdsdump_log(TDS_DBG_ERROR, "error: client error handler returned %d\n", rc);
844 case TDS_INT_CANCEL:
845 CLOSESOCKET(s);
846 return 0;
847 }
848 #endif
849 }
850 if (retval < 0)
851 break;
852
853 /* got data, read and parse */
854 if ((msg_len = recv(s, msg, sizeof(msg) - 1, 0)) > 3 && msg[0] == 5) {
855 char *name, sep[2] = ";", *save;
856
857 /* assure null terminated */
858 msg[msg_len] = 0;
859 tdsdump_dump_buf(TDS_DBG_INFO1, "instance info", msg, msg_len);
860
861 if (0) { /* To debug, print the whole string. */
862 char *p;
863
864 for (*sep = '\n', p=msg+3; p < msg + msg_len; p++) {
865 if( *p == ';' )
866 *p = *sep;
867 }
868 fputs(msg + 3, output);
869 }
870
871 /*
872 * Parse and print message.
873 */
874 name = strtok_r(msg+3, sep, &save);
875 while (name && output) {
876 int i;
877 static const char *names[] = { "ServerName", "InstanceName", "IsClustered", "Version",
878 "tcp", "np", "via" };
879
880 for (i=0; name && i < TDS_VECTOR_SIZE(names); i++) {
881 const char *value = strtok_r(NULL, sep, &save);
882
883 if (strcmp(name, names[i]) != 0)
884 fprintf(output, "error: expecting '%s', found '%s'\n", names[i], name);
885 if (value)
886 fprintf(output, "%15s %s\n", name, value);
887 else
888 break;
889
890 name = strtok_r(NULL, sep, &save);
891
892 if (name && strcmp(name, names[0]) == 0)
893 break;
894 }
895 if (name)
896 fprintf(output, "\n");
897 }
898 }
899 }
900 CLOSESOCKET(s);
901 tdsdump_log(TDS_DBG_ERROR, "default instance port is %d\n", port);
902 return port;
903 }
904
905 /**
906 * Get port of given instance
907 * @return port number or 0 if error
908 */
909 int
tds7_get_instance_port(struct tds_addrinfo * addr,const char * instance)910 tds7_get_instance_port(struct tds_addrinfo *addr, const char *instance)
911 {
912 int num_try;
913 ioctl_nonblocking_t ioctl_nonblocking;
914 struct pollfd fd;
915 int retval;
916 TDS_SYS_SOCKET s;
917 char msg[1024];
918 size_t msg_len;
919 int port = 0;
920 char ipaddr[128];
921
922 tds_addrinfo_set_port(addr, 1434);
923 tds_addrinfo2str(addr, ipaddr, sizeof(ipaddr));
924
925 tdsdump_log(TDS_DBG_ERROR, "tds7_get_instance_port(%s, %s)\n", ipaddr, instance);
926
927 /* create an UDP socket */
928 if (TDS_IS_SOCKET_INVALID(s = socket(addr->ai_family, SOCK_DGRAM, 0))) {
929 tdsdump_log(TDS_DBG_ERROR, "socket creation error: %s\n", sock_strerror(sock_errno));
930 return 0;
931 }
932
933 /*
934 * on cluster environment is possible that reply packet came from
935 * different IP so do not filter by ip with connect
936 */
937
938 ioctl_nonblocking = 1;
939 if (IOCTLSOCKET(s, FIONBIO, &ioctl_nonblocking) < 0) {
940 CLOSESOCKET(s);
941 return 0;
942 }
943
944 /*
945 * Request the instance's port from the server.
946 * There is no easy way to detect if port is closed so we always try to
947 * get a reply from server 16 times.
948 */
949 for (num_try = 0; num_try < 16; ++num_try) {
950 /* send the request */
951 msg[0] = 4;
952 tds_strlcpy(msg + 1, instance, sizeof(msg) - 1);
953 sendto(s, msg, (int)strlen(msg) + 1, 0, addr->ai_addr, addr->ai_addrlen);
954
955 fd.fd = s;
956 fd.events = POLLIN;
957 fd.revents = 0;
958
959 retval = poll(&fd, 1, 1000);
960
961 /* on interrupt ignore */
962 if (retval < 0 && sock_errno == TDSSOCK_EINTR)
963 continue;
964
965 if (retval == 0) { /* timed out */
966 #if 1
967 tdsdump_log(TDS_DBG_ERROR, "tds7_get_instance_port: timed out on try %d of 16\n", num_try);
968 continue;
969 #else
970 int rc;
971 tdsdump_log(TDS_DBG_INFO1, "timed out\n");
972
973 switch(rc = tdserror(NULL, NULL, TDSETIME, 0)) {
974 case TDS_INT_CONTINUE:
975 continue; /* try again */
976
977 default:
978 tdsdump_log(TDS_DBG_ERROR, "error: client error handler returned %d\n", rc);
979 case TDS_INT_CANCEL:
980 CLOSESOCKET(s);
981 return 0;
982 }
983 #endif
984 }
985 if (retval < 0)
986 break;
987
988 /* TODO pass also connection and set instance/servername ?? */
989
990 /* got data, read and parse */
991 if ((msg_len = recv(s, msg, sizeof(msg) - 1, 0)) > 3 && msg[0] == 5) {
992 char *p;
993 long l = 0;
994 int instance_ok = 0, port_ok = 0;
995
996 /* assure null terminated */
997 msg[msg_len] = 0;
998 tdsdump_dump_buf(TDS_DBG_INFO1, "instance info", msg, msg_len);
999
1000 /*
1001 * Parse message and check instance name and port.
1002 * We don't check servername cause it can be very different from the client's.
1003 */
1004 for (p = msg + 3;;) {
1005 char *name, *value;
1006
1007 name = p;
1008 p = strchr(p, ';');
1009 if (!p)
1010 break;
1011 *p++ = 0;
1012
1013 value = name;
1014 if (*name) {
1015 value = p;
1016 p = strchr(p, ';');
1017 if (!p)
1018 break;
1019 *p++ = 0;
1020 }
1021
1022 if (strcasecmp(name, "InstanceName") == 0) {
1023 if (strcasecmp(value, instance) != 0)
1024 break;
1025 instance_ok = 1;
1026 } else if (strcasecmp(name, "tcp") == 0) {
1027 l = strtol(value, &p, 10);
1028 if (l > 0 && l <= 0xffff && *p == 0)
1029 port_ok = 1;
1030 }
1031 }
1032 if (port_ok && instance_ok) {
1033 port = l;
1034 break;
1035 }
1036 }
1037 }
1038 CLOSESOCKET(s);
1039 tdsdump_log(TDS_DBG_ERROR, "instance port is %d\n", port);
1040 return port;
1041 }
1042
1043 #if defined(_WIN32)
1044 const char *
tds_prwsaerror(int erc)1045 tds_prwsaerror( int erc )
1046 {
1047 switch(erc) {
1048 case WSAEINTR: /* 10004 */
1049 return "WSAEINTR: Interrupted function call.";
1050 case WSAEACCES: /* 10013 */
1051 return "WSAEACCES: Permission denied.";
1052 case WSAEFAULT: /* 10014 */
1053 return "WSAEFAULT: Bad address.";
1054 case WSAEINVAL: /* 10022 */
1055 return "WSAEINVAL: Invalid argument.";
1056 case WSAEMFILE: /* 10024 */
1057 return "WSAEMFILE: Too many open files.";
1058 case WSAEWOULDBLOCK: /* 10035 */
1059 return "WSAEWOULDBLOCK: Resource temporarily unavailable.";
1060 case WSAEINPROGRESS: /* 10036 */
1061 return "WSAEINPROGRESS: Operation now in progress.";
1062 case WSAEALREADY: /* 10037 */
1063 return "WSAEALREADY: Operation already in progress.";
1064 case WSAENOTSOCK: /* 10038 */
1065 return "WSAENOTSOCK: Socket operation on nonsocket.";
1066 case WSAEDESTADDRREQ: /* 10039 */
1067 return "WSAEDESTADDRREQ: Destination address required.";
1068 case WSAEMSGSIZE: /* 10040 */
1069 return "WSAEMSGSIZE: Message too long.";
1070 case WSAEPROTOTYPE: /* 10041 */
1071 return "WSAEPROTOTYPE: Protocol wrong type for socket.";
1072 case WSAENOPROTOOPT: /* 10042 */
1073 return "WSAENOPROTOOPT: Bad protocol option.";
1074 case WSAEPROTONOSUPPORT: /* 10043 */
1075 return "WSAEPROTONOSUPPORT: Protocol not supported.";
1076 case WSAESOCKTNOSUPPORT: /* 10044 */
1077 return "WSAESOCKTNOSUPPORT: Socket type not supported.";
1078 case WSAEOPNOTSUPP: /* 10045 */
1079 return "WSAEOPNOTSUPP: Operation not supported.";
1080 case WSAEPFNOSUPPORT: /* 10046 */
1081 return "WSAEPFNOSUPPORT: Protocol family not supported.";
1082 case WSAEAFNOSUPPORT: /* 10047 */
1083 return "WSAEAFNOSUPPORT: Address family not supported by protocol family.";
1084 case WSAEADDRINUSE: /* 10048 */
1085 return "WSAEADDRINUSE: Address already in use.";
1086 case WSAEADDRNOTAVAIL: /* 10049 */
1087 return "WSAEADDRNOTAVAIL: Cannot assign requested address.";
1088 case WSAENETDOWN: /* 10050 */
1089 return "WSAENETDOWN: Network is down.";
1090 case WSAENETUNREACH: /* 10051 */
1091 return "WSAENETUNREACH: Network is unreachable.";
1092 case WSAENETRESET: /* 10052 */
1093 return "WSAENETRESET: Network dropped connection on reset.";
1094 case WSAECONNABORTED: /* 10053 */
1095 return "WSAECONNABORTED: Software caused connection abort.";
1096 case WSAECONNRESET: /* 10054 */
1097 return "WSAECONNRESET: Connection reset by peer.";
1098 case WSAENOBUFS: /* 10055 */
1099 return "WSAENOBUFS: No buffer space available.";
1100 case WSAEISCONN: /* 10056 */
1101 return "WSAEISCONN: Socket is already connected.";
1102 case WSAENOTCONN: /* 10057 */
1103 return "WSAENOTCONN: Socket is not connected.";
1104 case WSAESHUTDOWN: /* 10058 */
1105 return "WSAESHUTDOWN: Cannot send after socket shutdown.";
1106 case WSAETIMEDOUT: /* 10060 */
1107 return "WSAETIMEDOUT: Connection timed out.";
1108 case WSAECONNREFUSED: /* 10061 */
1109 return "WSAECONNREFUSED: Connection refused.";
1110 case WSAEHOSTDOWN: /* 10064 */
1111 return "WSAEHOSTDOWN: Host is down.";
1112 case WSAEHOSTUNREACH: /* 10065 */
1113 return "WSAEHOSTUNREACH: No route to host.";
1114 case WSAEPROCLIM: /* 10067 */
1115 return "WSAEPROCLIM: Too many processes.";
1116 case WSASYSNOTREADY: /* 10091 */
1117 return "WSASYSNOTREADY: Network subsystem is unavailable.";
1118 case WSAVERNOTSUPPORTED: /* 10092 */
1119 return "WSAVERNOTSUPPORTED: Winsock.dll version out of range.";
1120 case WSANOTINITIALISED: /* 10093 */
1121 return "WSANOTINITIALISED: Successful WSAStartup not yet performed.";
1122 case WSAEDISCON: /* 10101 */
1123 return "WSAEDISCON: Graceful shutdown in progress.";
1124 case WSATYPE_NOT_FOUND: /* 10109 */
1125 return "WSATYPE_NOT_FOUND: Class type not found.";
1126 case WSAHOST_NOT_FOUND: /* 11001 */
1127 return "WSAHOST_NOT_FOUND: Host not found.";
1128 case WSATRY_AGAIN: /* 11002 */
1129 return "WSATRY_AGAIN: Nonauthoritative host not found.";
1130 case WSANO_RECOVERY: /* 11003 */
1131 return "WSANO_RECOVERY: This is a nonrecoverable error.";
1132 case WSANO_DATA: /* 11004 */
1133 return "WSANO_DATA: Valid name, no data record of requested type.";
1134 case WSA_INVALID_HANDLE: /* OS dependent */
1135 return "WSA_INVALID_HANDLE: Specified event object handle is invalid.";
1136 case WSA_INVALID_PARAMETER: /* OS dependent */
1137 return "WSA_INVALID_PARAMETER: One or more parameters are invalid.";
1138 case WSA_IO_INCOMPLETE: /* OS dependent */
1139 return "WSA_IO_INCOMPLETE: Overlapped I/O event object not in signaled state.";
1140 case WSA_IO_PENDING: /* OS dependent */
1141 return "WSA_IO_PENDING: Overlapped operations will complete later.";
1142 case WSA_NOT_ENOUGH_MEMORY: /* OS dependent */
1143 return "WSA_NOT_ENOUGH_MEMORY: Insufficient memory available.";
1144 case WSA_OPERATION_ABORTED: /* OS dependent */
1145 return "WSA_OPERATION_ABORTED: Overlapped operation aborted.";
1146 #if defined(WSAINVALIDPROCTABLE)
1147 case WSAINVALIDPROCTABLE: /* OS dependent */
1148 return "WSAINVALIDPROCTABLE: Invalid procedure table from service provider.";
1149 #endif
1150 #if defined(WSAINVALIDPROVIDER)
1151 case WSAINVALIDPROVIDER: /* OS dependent */
1152 return "WSAINVALIDPROVIDER: Invalid service provider version number.";
1153 #endif
1154 #if defined(WSAPROVIDERFAILEDINIT)
1155 case WSAPROVIDERFAILEDINIT: /* OS dependent */
1156 return "WSAPROVIDERFAILEDINIT: Unable to initialize a service provider.";
1157 #endif
1158 case WSASYSCALLFAILURE: /* OS dependent */
1159 return "WSASYSCALLFAILURE: System call failure.";
1160 }
1161 return "undocumented WSA error code";
1162 }
1163 #endif
1164
1165 /** @} */
1166
1167