-
Notifications
You must be signed in to change notification settings - Fork 0
/
viosocket.cc
1243 lines (1024 loc) · 36 KB
/
viosocket.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
Copyright (c) 2001, 2019, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
Without limiting anything contained in the foregoing, this file,
which is part of C Driver for MySQL (Connector/C), is also subject to the
Universal FOSS Exception, version 1.0, a copy of which can be found at
http://oss.oracle.com/licenses/universal-foss-exception.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
/*
Note that we can't have assertion on file descriptors; The reason for
this is that during mysql shutdown, another thread can close a file
we are working on. In this case we should just return read errors from
the file descriptior.
*/
#include "my_config.h"
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <time.h>
#ifndef _WIN32
#include <netdb.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include "my_compiler.h"
#include "my_dbug.h"
#include "my_inttypes.h"
#include "my_io.h"
#include "my_macros.h"
#include "template_utils.h"
#include "vio/vio_priv.h"
#ifdef FIONREAD_IN_SYS_FILIO
#include <sys/filio.h>
#endif
#ifndef _WIN32
#include <netinet/tcp.h>
#endif
#ifdef HAVE_POLL_H
#include <poll.h>
#endif
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#include "mysql/psi/mysql_socket.h"
int vio_errno(Vio *vio MY_ATTRIBUTE((unused))) {
/* These transport types are not Winsock based. */
#ifdef _WIN32
if (vio->type == VIO_TYPE_NAMEDPIPE || vio->type == VIO_TYPE_SHARED_MEMORY)
return GetLastError();
#endif
/* Mapped to WSAGetLastError() on Win32. */
return socket_errno;
}
/**
Attempt to wait for an I/O event on a socket.
@param vio VIO object representing a connected socket.
@param event The type of I/O event (read or write) to wait for.
@return Return value is -1 on failure, 0 on success.
*/
int vio_socket_io_wait(Vio *vio, enum enum_vio_io_event event) {
int timeout, ret;
DBUG_ASSERT(event == VIO_IO_EVENT_READ || event == VIO_IO_EVENT_WRITE);
/* Choose an appropriate timeout. */
if (event == VIO_IO_EVENT_READ)
timeout = vio->read_timeout;
else
timeout = vio->write_timeout;
/* Wait for input data to become available. */
switch (vio_io_wait(vio, event, timeout)) {
case -1:
/* Upon failure, vio_read/write() shall return -1. */
ret = -1;
break;
case 0:
/* The wait timed out. */
ret = -1;
break;
default:
/* A positive value indicates an I/O event. */
ret = 0;
break;
}
return ret;
}
/*
Define a stub MSG_DONTWAIT if unavailable. In this case, fcntl
(or a equivalent) is used to enable non-blocking operations.
The flag must be supported in both send and recv operations.
*/
#if defined(__linux__)
#define VIO_USE_DONTWAIT 1
#define VIO_DONTWAIT MSG_DONTWAIT
#else
#define VIO_DONTWAIT 0
#endif
size_t vio_read(Vio *vio, uchar *buf, size_t size) {
ssize_t ret;
int flags = 0;
DBUG_ENTER("vio_read");
/* Ensure nobody uses vio_read_buff and vio_read simultaneously. */
DBUG_ASSERT(vio->read_end == vio->read_pos);
/* If timeout is enabled, do not block if data is unavailable. */
if (vio->read_timeout >= 0) flags = VIO_DONTWAIT;
while ((ret = mysql_socket_recv(vio->mysql_socket, (SOCKBUF_T *)buf, size,
flags)) == -1) {
int error = socket_errno;
/* Error encountered that is unrelated to blocking; percolate it up. */
#if SOCKET_EAGAIN == SOCKET_EWOULDBLOCK
if (error != SOCKET_EAGAIN)
#else
if (error != SOCKET_EAGAIN && error != SOCKET_EWOULDBLOCK)
#endif
break;
/*
Nonblocking with either EAGAIN or EWOULDBLOCK. Don't call
io_wait. 0 bytes are available.
*/
DBUG_ASSERT(error == SOCKET_EAGAIN || error == SOCKET_EWOULDBLOCK);
if (!vio_is_blocking(vio)) {
DBUG_PRINT("info", ("vio_read on nonblocking socket read no bytes"));
DBUG_RETURN(-1);
}
/* Wait for input data to become available. */
if ((ret = vio_socket_io_wait(vio, VIO_IO_EVENT_READ))) break;
}
DBUG_RETURN(ret);
}
/*
Buffered read: if average read size is small it may
reduce number of syscalls.
*/
size_t vio_read_buff(Vio *vio, uchar *buf, size_t size) {
size_t rc;
#define VIO_UNBUFFERED_READ_MIN_SIZE 2048
DBUG_ENTER("vio_read_buff");
DBUG_PRINT("enter", ("sd: %d buf: %p size: %u",
mysql_socket_getfd(vio->mysql_socket), buf, (uint)size));
if (vio->read_pos < vio->read_end) {
rc = MY_MIN((size_t)(vio->read_end - vio->read_pos), size);
memcpy(buf, vio->read_pos, rc);
vio->read_pos += rc;
/*
Do not try to read from the socket now even if rc < size:
vio_read can return -1 due to an error or non-blocking mode, and
the safest way to handle it is to move to a separate branch.
*/
} else if (size < VIO_UNBUFFERED_READ_MIN_SIZE) {
rc = vio_read(vio, (uchar *)vio->read_buffer, VIO_READ_BUFFER_SIZE);
if (rc != 0 && rc != (size_t)-1) {
if (rc > size) {
vio->read_pos = vio->read_buffer + size;
vio->read_end = vio->read_buffer + rc;
rc = size;
}
memcpy(buf, vio->read_buffer, rc);
}
} else
rc = vio_read(vio, buf, size);
DBUG_RETURN(rc);
#undef VIO_UNBUFFERED_READ_MIN_SIZE
}
bool vio_buff_has_data(Vio *vio) { return (vio->read_pos != vio->read_end); }
size_t vio_write(Vio *vio, const uchar *buf, size_t size) {
ssize_t ret;
int flags = 0;
DBUG_ENTER("vio_write");
/* If timeout is enabled, do not block. */
if (vio->write_timeout >= 0) flags = VIO_DONTWAIT;
while ((ret = mysql_socket_send(vio->mysql_socket, (SOCKBUF_T *)buf, size,
flags)) == -1) {
int error = socket_errno;
/* The operation would block? */
#if SOCKET_EAGAIN == SOCKET_EWOULDBLOCK
if (error != SOCKET_EAGAIN)
#else
if (error != SOCKET_EAGAIN && error != SOCKET_EWOULDBLOCK)
#endif
break;
if (!vio_is_blocking(vio)) {
DBUG_PRINT("info", ("vio_write on nonblocking socket written no bytes"));
DBUG_RETURN(-1);
}
/* Wait for the output buffer to become writable.*/
if ((ret = vio_socket_io_wait(vio, VIO_IO_EVENT_WRITE))) break;
}
DBUG_RETURN(ret);
}
// WL#4896: Not covered
int vio_set_blocking(Vio *vio, bool status) {
DBUG_ENTER("vio_set_blocking");
#ifdef _WIN32
{
int ret;
u_long arg = status ? 0 : 1;
ret = ioctlsocket(mysql_socket_getfd(vio->mysql_socket), FIONBIO, &arg);
DBUG_RETURN(ret);
}
#else
{
int flags;
if ((flags = fcntl(mysql_socket_getfd(vio->mysql_socket), F_GETFL, NULL)) <
0)
DBUG_RETURN(-1);
/*
Always set/clear the flag to avoid inheritance issues. This is
a issue mainly on Mac OS X Tiger (version 10.4) where although
the O_NONBLOCK flag is inherited from the parent socket, the
actual non-blocking behavior is not inherited.
*/
if (status)
flags &= ~O_NONBLOCK;
else
flags |= O_NONBLOCK;
if (fcntl(mysql_socket_getfd(vio->mysql_socket), F_SETFL, flags) == -1)
DBUG_RETURN(-1);
}
#endif
DBUG_RETURN(0);
}
int vio_set_blocking_flag(Vio *vio, bool status) {
DBUG_ENTER(__func__);
int ret = 0;
/*
Asynchronous communication in client is allowed only for below
types of connections.
*/
if (VIO_TYPE_TCPIP == vio->type || VIO_TYPE_SOCKET == vio->type ||
VIO_TYPE_SSL == vio->type) {
vio->is_blocking_flag = status;
ret = vio_set_blocking(vio, status);
}
DBUG_RETURN(ret);
}
bool vio_is_blocking(Vio *vio) {
DBUG_ENTER(__func__);
DBUG_RETURN(vio->is_blocking_flag);
}
int vio_socket_timeout(Vio *vio, uint which MY_ATTRIBUTE((unused)),
bool old_mode) {
int ret = 0;
DBUG_ENTER("vio_socket_timeout");
#if defined(_WIN32)
{
int optname;
DWORD timeout = 0;
const char *optval = (const char *)&timeout;
/*
The default socket timeout value is zero, which means an infinite
timeout. Values less than 500 milliseconds are interpreted to be of
500 milliseconds. Hence, the VIO behavior for zero timeout, which is
intended to cause the send or receive operation to fail immediately
if no data is available, is not supported on WIN32 and neither is
necessary as it's not possible to set the VIO timeout value to zero.
Assert that the VIO timeout is either positive or set to infinite.
*/
DBUG_ASSERT(which || vio->read_timeout);
DBUG_ASSERT(!which || vio->write_timeout);
if (which) {
optname = SO_SNDTIMEO;
if (vio->write_timeout > 0) timeout = vio->write_timeout;
} else {
optname = SO_RCVTIMEO;
if (vio->read_timeout > 0) timeout = vio->read_timeout;
}
ret = mysql_socket_setsockopt(vio->mysql_socket, SOL_SOCKET, optname,
optval, sizeof(timeout));
}
#else
/*
The MSG_DONTWAIT trick is not used with SSL sockets as the send and
receive I/O operations are wrapped through SSL-specific functions
(SSL_read and SSL_write) which are not equivalent to the standard
recv(2) and send(2) used in vio_read() and vio_write(). Hence, the
socket blocking mode is changed and vio_io_wait() is used to wait
for I/O or timeout.
*/
#ifdef VIO_USE_DONTWAIT
if (vio->type == VIO_TYPE_SSL)
#endif
{
/* Deduce what should be the new blocking mode of the socket. */
bool new_mode = vio->write_timeout < 0 && vio->read_timeout < 0;
/* If necessary, update the blocking mode. */
if (new_mode != old_mode) ret = vio_set_blocking(vio, new_mode);
}
#endif
DBUG_RETURN(ret);
}
int vio_fastsend(Vio *vio) {
int r = 0;
DBUG_ENTER("vio_fastsend");
#if defined(IPTOS_THROUGHPUT)
{
int tos = IPTOS_THROUGHPUT;
r = mysql_socket_setsockopt(vio->mysql_socket, IPPROTO_IP, IP_TOS,
(void *)&tos, sizeof(tos));
}
#endif /* IPTOS_THROUGHPUT */
if (!r) {
#ifdef _WIN32
BOOL nodelay = 1;
#else
int nodelay = 1;
#endif
r = mysql_socket_setsockopt(vio->mysql_socket, IPPROTO_TCP, TCP_NODELAY,
IF_WIN((const char *), (void *)) & nodelay,
sizeof(nodelay));
}
if (r) {
DBUG_PRINT("warning", ("Couldn't set socket option for fast send"));
r = -1;
}
DBUG_PRINT("exit", ("%d", r));
DBUG_RETURN(r);
}
int vio_keepalive(Vio *vio, bool set_keep_alive) {
int r = 0;
uint opt = 0;
DBUG_ENTER("vio_keepalive");
DBUG_PRINT("enter",
("sd: %d set_keep_alive: %d",
mysql_socket_getfd(vio->mysql_socket), (int)set_keep_alive));
if (vio->type != VIO_TYPE_NAMEDPIPE) {
if (set_keep_alive) opt = 1;
r = mysql_socket_setsockopt(vio->mysql_socket, SOL_SOCKET, SO_KEEPALIVE,
(char *)&opt, sizeof(opt));
}
DBUG_RETURN(r);
}
/**
Indicate whether a I/O operation must be retried later.
@param vio A VIO object
@return Whether a I/O operation should be deferred.
@retval true Temporary failure, retry operation.
@retval false Indeterminate failure.
*/
bool vio_should_retry(Vio *vio) { return (vio_errno(vio) == SOCKET_EINTR); }
/**
Indicate whether a I/O operation timed out.
@param vio A VIO object
@return Whether a I/O operation timed out.
@retval true Operation timed out.
@retval false Not a timeout failure.
*/
bool vio_was_timeout(Vio *vio) { return (vio_errno(vio) == SOCKET_ETIMEDOUT); }
#ifdef USE_PPOLL_IN_VIO
static void vio_wait_until_woken(Vio *vio) {
while (vio->poll_shutdown_flag.test_and_set()) {
// Wait until the vio is woken up from poll.
}
}
#elif defined HAVE_KQUEUE
static const int WAKEUP_EVENT_ID = 0xFACEFEED;
static void vio_wait_until_woken(Vio *vio) {
if (vio->kq_fd != -1) {
struct kevent kev;
EV_SET(&kev, WAKEUP_EVENT_ID, EVFILT_USER, 0, NOTE_TRIGGER, 0, NULL);
int nev = kevent(vio->kq_fd, &kev, 1, nullptr, 0, nullptr);
if (nev != -1) {
while (vio->kevent_wakeup_flag.test_and_set()) {
// Wait until the vio is woken up from kevent.
}
}
}
}
#endif
int vio_shutdown(Vio *vio) {
int r = 0;
DBUG_ENTER("vio_shutdown");
if (vio->inactive == false) {
DBUG_ASSERT(vio->type == VIO_TYPE_TCPIP || vio->type == VIO_TYPE_SOCKET ||
vio->type == VIO_TYPE_SSL);
DBUG_ASSERT(mysql_socket_getfd(vio->mysql_socket) >= 0);
if (mysql_socket_shutdown(vio->mysql_socket, SHUT_RDWR)) r = -1;
#ifdef USE_PPOLL_IN_VIO
if (vio->thread_id != 0 && vio->poll_shutdown_flag.test_and_set()) {
// Send signal to wake up from poll.
if (pthread_kill(vio->thread_id, SIGUSR1) == 0)
vio_wait_until_woken(vio);
else
perror("Error in pthread_kill");
}
#elif defined HAVE_KQUEUE
if (vio->kq_fd != -1 && vio->kevent_wakeup_flag.test_and_set())
vio_wait_until_woken(vio);
#endif
if (mysql_socket_close(vio->mysql_socket)) r = -1;
#ifdef HAVE_KQUEUE
if (vio->kq_fd == -1 || close(vio->kq_fd)) r = -1;
vio->kq_fd = -1;
#endif
}
if (r) {
DBUG_PRINT("vio_error", ("close() failed, error: %d", socket_errno));
/* FIXME: error handling (not critical for MySQL) */
}
vio->inactive = true;
vio->mysql_socket = MYSQL_INVALID_SOCKET;
DBUG_RETURN(r);
}
void vio_description(Vio *vio, char *buf) {
switch (vio->type) {
case VIO_TYPE_SOCKET:
snprintf(buf, VIO_DESCRIPTION_SIZE, "socket (%d)",
mysql_socket_getfd(vio->mysql_socket));
break;
#ifdef _WIN32
case VIO_TYPE_NAMEDPIPE:
my_stpcpy(buf, "named pipe");
break;
case VIO_TYPE_SHARED_MEMORY:
my_stpcpy(buf, "shared memory");
break;
#endif
default:
snprintf(buf, VIO_DESCRIPTION_SIZE, "TCP/IP (%d)",
mysql_socket_getfd(vio->mysql_socket));
break;
}
}
enum enum_vio_type vio_type(const Vio *vio) { return vio->type; }
my_socket vio_fd(Vio *vio) { return mysql_socket_getfd(vio->mysql_socket); }
/**
Convert a sock-address (AF_INET or AF_INET6) into the "normalized" form,
which is the IPv4 form for IPv4-mapped or IPv4-compatible IPv6 addresses.
@note Background: when IPv4 and IPv6 are used simultaneously, IPv4
addresses may be written in a form of IPv4-mapped or IPv4-compatible IPv6
addresses. That means, one address (a.b.c.d) can be written in three forms:
- IPv4: a.b.c.d;
- IPv4-compatible IPv6: @code ::a.b.c.d @endcode;
- IPv4-mapped IPv4: @code ::ffff:a.b.c.d @endcode;
Having three forms of one address makes it a little difficult to compare
addresses with each other (the IPv4-compatible IPv6-address of foo.bar
will be different from the IPv4-mapped IPv6-address of foo.bar).
@note This function can be made public when it's needed.
@param [in] src source IP address (AF_INET or AF_INET6).
@param [in] src_length length of the src.
@param [out] dst a buffer to store normalized IP address
(sockaddr_storage).
@param [out] dst_length actual length of the normalized IP address.
*/
static void vio_get_normalized_ip(const struct sockaddr *src, size_t src_length,
struct sockaddr *dst, size_t *dst_length) {
switch (src->sa_family) {
case AF_INET:
memcpy(dst, src, src_length);
*dst_length = src_length;
break;
case AF_INET6: {
const struct sockaddr_in6 *src_addr6 = (const struct sockaddr_in6 *)src;
const struct in6_addr *src_ip6 = &(src_addr6->sin6_addr);
const uint32 *src_ip6_int32 =
pointer_cast<const uint32 *>(src_ip6->s6_addr);
if (IN6_IS_ADDR_V4MAPPED(src_ip6) || IN6_IS_ADDR_V4COMPAT(src_ip6)) {
struct sockaddr_in *dst_ip4 = (struct sockaddr_in *)dst;
/*
This is an IPv4-mapped or IPv4-compatible IPv6 address. It should
be converted to the IPv4 form.
*/
*dst_length = sizeof(struct sockaddr_in);
memset(dst_ip4, 0, *dst_length);
dst_ip4->sin_family = AF_INET;
dst_ip4->sin_port = src_addr6->sin6_port;
/*
In an IPv4 mapped or compatible address, the last 32 bits represent
the IPv4 address. The byte orders for IPv6 and IPv4 addresses are
the same, so a simple copy is possible.
*/
dst_ip4->sin_addr.s_addr = src_ip6_int32[3];
} else {
/* This is a "native" IPv6 address. */
memcpy(dst, src, src_length);
*dst_length = src_length;
}
break;
}
}
}
/**
Return the normalized IP address string for a sock-address.
The idea is to return an IPv4-address for an IPv4-mapped and
IPv4-compatible IPv6 address.
The function writes the normalized IP address to the given buffer.
The buffer should have enough space, otherwise error flag is returned.
The system constant INET6_ADDRSTRLEN can be used to reserve buffers of
the right size.
@param [in] addr sockaddr object (AF_INET or AF_INET6).
@param [in] addr_length length of the addr.
@param [out] ip_string buffer to write normalized IP address.
@param [in] ip_string_size size of the ip_string.
@return Error status.
@retval true in case of error (the ip_string buffer is not enough).
@retval false on success.
*/
bool vio_get_normalized_ip_string(const struct sockaddr *addr,
size_t addr_length, char *ip_string,
size_t ip_string_size) {
struct sockaddr_storage norm_addr_storage;
struct sockaddr *norm_addr = (struct sockaddr *)&norm_addr_storage;
size_t norm_addr_length;
int err_code;
vio_get_normalized_ip(addr, addr_length, norm_addr, &norm_addr_length);
err_code = vio_getnameinfo(norm_addr, ip_string, ip_string_size, NULL, 0,
NI_NUMERICHOST);
if (!err_code) return false;
DBUG_PRINT("error", ("getnameinfo() failed with %d (%s).", (int)err_code,
(const char *)gai_strerror(err_code)));
return true;
}
/**
Return IP address and port of a VIO client socket.
The function returns an IPv4 address if IPv6 support is disabled.
The function returns an IPv4 address if the client socket is associated
with an IPv4-compatible or IPv4-mapped IPv6 address. Otherwise, the native
IPv6 address is returned.
*/
bool vio_peer_addr(Vio *vio, char *ip_buffer, uint16 *port,
size_t ip_buffer_size) {
DBUG_ENTER("vio_peer_addr");
DBUG_PRINT("enter", ("Client socked fd: %d",
(int)mysql_socket_getfd(vio->mysql_socket)));
if (vio->localhost) {
/*
Initialize vio->remote and vio->addLen. Set vio->remote to IPv4 loopback
address.
*/
struct in_addr *ip4 = &((struct sockaddr_in *)&(vio->remote))->sin_addr;
vio->remote.ss_family = AF_INET;
vio->addrLen = sizeof(struct sockaddr_in);
ip4->s_addr = htonl(INADDR_LOOPBACK);
/* Initialize ip_buffer and port. */
my_stpcpy(ip_buffer, "127.0.0.1");
*port = 0;
} else {
int err_code;
char port_buffer[NI_MAXSERV];
struct sockaddr_storage addr_storage;
struct sockaddr *addr = (struct sockaddr *)&addr_storage;
socket_len_t addr_length = sizeof(addr_storage);
/* Get sockaddr by socked fd. */
err_code = mysql_socket_getpeername(vio->mysql_socket, addr, &addr_length);
if (err_code) {
DBUG_PRINT("exit", ("getpeername() gave error: %d", socket_errno));
DBUG_RETURN(true);
}
/* Normalize IP address. */
vio_get_normalized_ip(addr, addr_length, (struct sockaddr *)&vio->remote,
&vio->addrLen);
/* Get IP address & port number. */
err_code = vio_getnameinfo((struct sockaddr *)&vio->remote, ip_buffer,
ip_buffer_size, port_buffer, NI_MAXSERV,
NI_NUMERICHOST | NI_NUMERICSERV);
if (err_code) {
DBUG_PRINT("exit",
("getnameinfo() gave error: %s", gai_strerror(err_code)));
DBUG_RETURN(true);
}
*port = (uint16)strtol(port_buffer, NULL, 10);
}
DBUG_PRINT("exit", ("Client IP address: %s; port: %d",
(const char *)ip_buffer, (int)*port));
DBUG_RETURN(false);
}
/**
Retrieve the amount of data that can be read from a socket.
@param vio A VIO object.
@param [out] bytes The amount of bytes available.
@retval false Success.
@retval true Failure.
*/
// WL#4896: Not covered
static bool socket_peek_read(Vio *vio, uint *bytes) {
my_socket sd = mysql_socket_getfd(vio->mysql_socket);
#if defined(_WIN32)
u_long len;
if (ioctlsocket(sd, FIONREAD, &len)) return true;
*bytes = len;
return false;
#elif defined(FIONREAD_IN_SYS_IOCTL) || defined(FIONREAD_IN_SYS_FILIO)
int len;
if (ioctl(sd, FIONREAD, &len) < 0) return true;
*bytes = len;
return false;
#else
char buf[1024];
ssize_t res = recv(sd, &buf, sizeof(buf), MSG_PEEK);
if (res < 0) return true;
*bytes = res;
return false;
#endif
}
#ifndef _WIN32
/**
Set of event flags grouped by operations.
*/
/*
Linux specific flag used to detect connection shutdown. The flag is
also used for half-closed notification, which here is interpreted as
if there is data available to be read from the socket.
*/
#ifndef POLLRDHUP
#define POLLRDHUP 0
#endif
/* Data may be read. */
#define MY_POLL_SET_IN (POLLIN | POLLPRI)
/* Data may be written. */
#define MY_POLL_SET_OUT (POLLOUT)
/* An error or hangup. */
#define MY_POLL_SET_ERR (POLLERR | POLLHUP | POLLNVAL)
#endif
/**
Wait for an I/O event on a VIO socket.
@param vio VIO object representing a connected socket.
@param event The type of I/O event to wait for.
@param timeout Interval (in milliseconds) to wait for an I/O event.
A negative timeout value means an infinite timeout.
@remark sock_errno is set to SOCKET_ETIMEDOUT on timeout.
@return A three-state value which indicates the operation status.
@retval -1 Failure, socket_errno indicates the error.
@retval 0 The wait has timed out.
@retval 1 The requested I/O event has occurred.
*/
#if !defined(_WIN32) && !defined(HAVE_KQUEUE)
int vio_io_wait(Vio *vio, enum enum_vio_io_event event, int timeout) {
int ret;
int retry_count = 0;
#ifndef DBUG_OFF
short revents = 0;
#endif
struct pollfd pfd;
my_socket sd = mysql_socket_getfd(vio->mysql_socket);
MYSQL_SOCKET_WAIT_VARIABLES(locker, state) /* no ';' */
DBUG_ENTER("vio_io_wait");
memset(&pfd, 0, sizeof(pfd));
pfd.fd = sd;
/*
Set the poll bitmask describing the type of events.
The error flags are only valid in the revents bitmask.
*/
switch (event) {
case VIO_IO_EVENT_READ:
pfd.events = MY_POLL_SET_IN;
#ifndef DBUG_OFF
revents = MY_POLL_SET_IN | MY_POLL_SET_ERR | POLLRDHUP;
#endif
break;
case VIO_IO_EVENT_WRITE:
case VIO_IO_EVENT_CONNECT:
pfd.events = MY_POLL_SET_OUT;
#ifndef DBUG_OFF
revents = MY_POLL_SET_OUT | MY_POLL_SET_ERR;
#endif
break;
}
MYSQL_START_SOCKET_WAIT(locker, &state, vio->mysql_socket, PSI_SOCKET_SELECT,
0);
#ifdef USE_PPOLL_IN_VIO
// Check if shutdown is in progress, if so return -1
if (vio->poll_shutdown_flag.test_and_set()) DBUG_RETURN(-1);
timespec ts;
timespec *ts_ptr = nullptr;
if (timeout >= 0) {
ts = {timeout / 1000, (timeout % 1000) * 1000000};
ts_ptr = &ts;
}
#endif
/*
Wait for the I/O event and return early in case of
error or timeout.
*/
do {
#ifdef USE_PPOLL_IN_VIO
/*
vio->signal_mask is only useful when thread_id != 0.
thread_id is only set for servers, so signal_mask is unused for client
libraries.
*/
ret = ppoll(&pfd, 1, ts_ptr,
vio->thread_id != 0 ? &vio->signal_mask : nullptr);
#else
ret = poll(&pfd, 1, timeout);
#endif
} while (ret < 0 && vio_should_retry(vio) &&
(retry_count++ < vio->retry_count));
#ifdef USE_PPOLL_IN_VIO
vio->poll_shutdown_flag.clear();
#endif
switch (ret) {
case -1:
/* On error, -1 is returned. */
break;
case 0:
/*
Set errno to indicate a timeout error.
(This is not compiled in on WIN32.)
*/
errno = SOCKET_ETIMEDOUT;
break;
default:
/* Ensure that the requested I/O event has completed. */
DBUG_ASSERT(pfd.revents & revents);
break;
}
MYSQL_END_SOCKET_WAIT(locker, 0);
DBUG_RETURN(ret);
}
#elif defined(_WIN32)
int vio_io_wait(Vio *vio, enum enum_vio_io_event event, int timeout) {
int ret;
int retry_count = 0;
struct timeval tm;
my_socket fd;
fd_set readfds, writefds, exceptfds;
MYSQL_SOCKET_WAIT_VARIABLES(locker, state) /* no ';' */
DBUG_ENTER("vio_io_wait");
fd = mysql_socket_getfd(vio->mysql_socket);
if (fd == INVALID_SOCKET) DBUG_RETURN(-1);
/* Convert the timeout, in milliseconds, to seconds and microseconds. */
if (timeout >= 0) {
tm.tv_sec = timeout / 1000;
tm.tv_usec = (timeout % 1000) * 1000;
}
FD_ZERO(&readfds);
FD_ZERO(&writefds);
FD_ZERO(&exceptfds);
/* Always receive notification of exceptions. */
FD_SET(fd, &exceptfds);
switch (event) {
case VIO_IO_EVENT_READ:
/* Readiness for reading. */
FD_SET(fd, &readfds);
break;
case VIO_IO_EVENT_WRITE:
case VIO_IO_EVENT_CONNECT:
/* Readiness for writing. */
FD_SET(fd, &writefds);
break;
}
MYSQL_START_SOCKET_WAIT(locker, &state, vio->mysql_socket, PSI_SOCKET_SELECT,
0);
/* The first argument is ignored on Windows. */
do {
ret = select((int)(fd + 1), &readfds, &writefds, &exceptfds,
(timeout >= 0) ? &tm : NULL);
} while (ret < 0 && vio_should_retry(vio) &&
(retry_count++ < vio->retry_count));
MYSQL_END_SOCKET_WAIT(locker, 0);
/* Set error code to indicate a timeout error. */
if (ret == 0) WSASetLastError(SOCKET_ETIMEDOUT);
/* Error or timeout? */
if (ret <= 0) DBUG_RETURN(ret);
/* The requested I/O event is ready? */
switch (event) {
case VIO_IO_EVENT_READ:
ret = MY_TEST(FD_ISSET(fd, &readfds));
break;
case VIO_IO_EVENT_WRITE:
case VIO_IO_EVENT_CONNECT:
ret = MY_TEST(FD_ISSET(fd, &writefds));
break;
}
/* Error conditions pending? */
ret |= MY_TEST(FD_ISSET(fd, &exceptfds));
/* Not a timeout, ensure that a condition was met. */
DBUG_ASSERT(ret);
DBUG_RETURN(ret);
}
#elif defined(HAVE_KQUEUE)
int vio_io_wait(Vio *vio, enum enum_vio_io_event event, int timeout) {
int nev;
static const int MAX_EVENT = 2;
struct kevent kev_set[MAX_EVENT];
struct kevent kev_event[MAX_EVENT];
my_socket fd = mysql_socket_getfd(vio->mysql_socket);
MYSQL_SOCKET_WAIT_VARIABLES(locker, state) /* no ';' */
DBUG_ENTER("vio_io_wait");
if (vio->kq_fd == -1) DBUG_RETURN(-1);
EV_SET(&kev_set[1], WAKEUP_EVENT_ID, EVFILT_USER,
EV_ADD | EV_ENABLE | EV_DISPATCH | EV_CLEAR, 0, 0, nullptr);
switch (event) {
case VIO_IO_EVENT_READ:
EV_SET(&kev_set[0], fd, EVFILT_READ,
EV_ADD | EV_ENABLE | EV_DISPATCH | EV_CLEAR, 0, 0, nullptr);
break;
case VIO_IO_EVENT_WRITE:
case VIO_IO_EVENT_CONNECT:
EV_SET(&kev_set[0], fd, EVFILT_WRITE,
EV_ADD | EV_ENABLE | EV_DISPATCH | EV_CLEAR, 0, 0, nullptr);
break;
}
MYSQL_START_SOCKET_WAIT(locker, &state, vio->mysql_socket, PSI_SOCKET_SELECT,
0);
timespec ts = {static_cast<long>(timeout / 1000),
(static_cast<long>(timeout) % 1000) * 1000000};
// Check if shutdown is in progress, if so return -1.
if (vio->kevent_wakeup_flag.test_and_set()) DBUG_RETURN(-1);
int retry_count = 0;
do {
nev = kevent(vio->kq_fd, kev_set, MAX_EVENT, kev_event, MAX_EVENT,
timeout >= 0 ? &ts : nullptr);
} while (nev < 0 && vio_should_retry(vio) &&
(retry_count++ < vio->retry_count));
vio->kevent_wakeup_flag.clear();
if (nev == -1) {
// On error, -1 is returned.
DBUG_PRINT("error", ("kevent returned error %d\n", errno));
} else if (nev == 0) {
// Timeout in kevent.
errno = SOCKET_ETIMEDOUT;
} else {
for (int i = 0; i < nev; i++) {
if (!(kev_event[i].flags & (EV_ERROR | EV_EOF))) {
// Ensure that the requested I/O event has completed.
DBUG_ASSERT(event == VIO_IO_EVENT_READ
? kev_event[i].filter & EVFILT_READ