Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 1 | /* |
| 2 | * |
Craig Tiller | 6169d5f | 2016-03-31 07:46:18 -0700 | [diff] [blame] | 3 | * Copyright 2015, Google Inc. |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
murgatroid99 | 5407089 | 2016-08-08 17:01:18 -0700 | [diff] [blame^] | 34 | #include "src/core/lib/iomgr/port.h" |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 35 | |
| 36 | #ifdef GPR_WINSOCK_SOCKET |
| 37 | |
Nicolas "Pixel" Noble | c4b18a5 | 2016-04-15 04:53:54 +0200 | [diff] [blame] | 38 | #include <limits.h> |
| 39 | |
Makarand Dharmapurikar | 0579cfc | 2016-06-20 15:45:24 -0700 | [diff] [blame] | 40 | #include "src/core/lib/iomgr/network_status_tracker.h" |
Yuchen Zeng | 12dfdc3 | 2016-04-26 22:05:41 -0700 | [diff] [blame] | 41 | #include "src/core/lib/iomgr/sockaddr_windows.h" |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 42 | |
| 43 | #include <grpc/support/alloc.h> |
| 44 | #include <grpc/support/log.h> |
Yuchen Zeng | 12dfdc3 | 2016-04-26 22:05:41 -0700 | [diff] [blame] | 45 | #include <grpc/support/log_windows.h> |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 46 | #include <grpc/support/slice_buffer.h> |
Masood Malekghassemi | 701af60 | 2015-06-03 15:01:17 -0700 | [diff] [blame] | 47 | #include <grpc/support/string_util.h> |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 48 | #include <grpc/support/useful.h> |
| 49 | |
Craig Tiller | 9533d04 | 2016-03-25 17:11:06 -0700 | [diff] [blame] | 50 | #include "src/core/lib/iomgr/iocp_windows.h" |
| 51 | #include "src/core/lib/iomgr/sockaddr.h" |
| 52 | #include "src/core/lib/iomgr/sockaddr_utils.h" |
| 53 | #include "src/core/lib/iomgr/socket_windows.h" |
| 54 | #include "src/core/lib/iomgr/tcp_client.h" |
| 55 | #include "src/core/lib/iomgr/timer.h" |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 56 | |
Nicolas "Pixel" Noble | c4b18a5 | 2016-04-15 04:53:54 +0200 | [diff] [blame] | 57 | #if defined(__MSYS__) && defined(GPR_ARCH_64) |
| 58 | /* Nasty workaround for nasty bug when using the 64 bits msys compiler |
| 59 | in conjunction with Microsoft Windows headers. */ |
| 60 | #define GRPC_FIONBIO _IOW('f', 126, uint32_t) |
| 61 | #else |
| 62 | #define GRPC_FIONBIO FIONBIO |
| 63 | #endif |
| 64 | |
Craig Tiller | 3e149f3 | 2016-05-17 16:11:04 -0700 | [diff] [blame] | 65 | static grpc_error *set_non_block(SOCKET sock) { |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 66 | int status; |
Nicolas "Pixel" Noble | c4b18a5 | 2016-04-15 04:53:54 +0200 | [diff] [blame] | 67 | uint32_t param = 1; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 68 | DWORD ret; |
Nicolas "Pixel" Noble | 344f55b | 2016-04-15 07:52:25 +0200 | [diff] [blame] | 69 | status = WSAIoctl(sock, GRPC_FIONBIO, ¶m, sizeof(param), NULL, 0, &ret, |
| 70 | NULL, NULL); |
Craig Tiller | 3e149f3 | 2016-05-17 16:11:04 -0700 | [diff] [blame] | 71 | return status == 0 |
| 72 | ? GRPC_ERROR_NONE |
| 73 | : GRPC_WSA_ERROR(WSAGetLastError(), "WSAIoctl(GRPC_FIONBIO)"); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 74 | } |
| 75 | |
Craig Tiller | 3e149f3 | 2016-05-17 16:11:04 -0700 | [diff] [blame] | 76 | static grpc_error *set_dualstack(SOCKET sock) { |
Nicolas "Pixel" Noble | ee0c96c | 2015-02-04 23:35:41 +0100 | [diff] [blame] | 77 | int status; |
| 78 | unsigned long param = 0; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 79 | status = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)¶m, |
| 80 | sizeof(param)); |
Craig Tiller | 3e149f3 | 2016-05-17 16:11:04 -0700 | [diff] [blame] | 81 | return status == 0 |
| 82 | ? GRPC_ERROR_NONE |
| 83 | : GRPC_WSA_ERROR(WSAGetLastError(), "setsockopt(IPV6_V6ONLY)"); |
Nicolas "Pixel" Noble | ee0c96c | 2015-02-04 23:35:41 +0100 | [diff] [blame] | 84 | } |
| 85 | |
Craig Tiller | 3e149f3 | 2016-05-17 16:11:04 -0700 | [diff] [blame] | 86 | grpc_error *grpc_tcp_prepare_socket(SOCKET sock) { |
| 87 | grpc_error *err; |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 88 | err = set_non_block(sock); |
| 89 | if (err != GRPC_ERROR_NONE) return err; |
| 90 | err = set_dualstack(sock); |
| 91 | if (err != GRPC_ERROR_NONE) return err; |
| 92 | return GRPC_ERROR_NONE; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 93 | } |
| 94 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 95 | typedef struct grpc_tcp { |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 96 | /* This is our C++ class derivation emulation. */ |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 97 | grpc_endpoint base; |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 98 | /* The one socket this endpoint is using. */ |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 99 | grpc_winsocket *socket; |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 100 | /* Refcounting how many operations are in progress. */ |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 101 | gpr_refcount refcount; |
| 102 | |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 103 | grpc_closure on_read; |
| 104 | grpc_closure on_write; |
| 105 | |
Craig Tiller | 3382511 | 2015-09-18 07:44:19 -0700 | [diff] [blame] | 106 | grpc_closure *read_cb; |
| 107 | grpc_closure *write_cb; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 108 | gpr_slice read_slice; |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 109 | gpr_slice_buffer *write_slices; |
| 110 | gpr_slice_buffer *read_slices; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 111 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 112 | /* The IO Completion Port runs from another thread. We need some mechanism |
| 113 | to protect ourselves when requesting a shutdown. */ |
| 114 | gpr_mu mu; |
| 115 | int shutting_down; |
Craig Tiller | 81bcc4c | 2015-07-20 14:04:18 -0700 | [diff] [blame] | 116 | |
| 117 | char *peer_string; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 118 | } grpc_tcp; |
| 119 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 120 | static void tcp_free(grpc_tcp *tcp) { |
| 121 | grpc_winsocket_destroy(tcp->socket); |
| 122 | gpr_mu_destroy(&tcp->mu); |
| 123 | gpr_free(tcp->peer_string); |
| 124 | gpr_free(tcp); |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 125 | } |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 126 | |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 127 | /*#define GRPC_TCP_REFCOUNT_DEBUG*/ |
| 128 | #ifdef GRPC_TCP_REFCOUNT_DEBUG |
| 129 | #define TCP_UNREF(tcp, reason) tcp_unref((tcp), (reason), __FILE__, __LINE__) |
| 130 | #define TCP_REF(tcp, reason) tcp_ref((tcp), (reason), __FILE__, __LINE__) |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 131 | static void tcp_unref(grpc_tcp *tcp, const char *reason, const char *file, |
| 132 | int line) { |
| 133 | gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "TCP unref %p : %s %d -> %d", tcp, |
| 134 | reason, tcp->refcount.count, tcp->refcount.count - 1); |
| 135 | if (gpr_unref(&tcp->refcount)) { |
| 136 | tcp_free(tcp); |
| 137 | } |
Craig Tiller | 0882a35 | 2015-08-26 13:21:14 -0700 | [diff] [blame] | 138 | } |
| 139 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 140 | static void tcp_ref(grpc_tcp *tcp, const char *reason, const char *file, |
| 141 | int line) { |
| 142 | gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "TCP ref %p : %s %d -> %d", tcp, |
| 143 | reason, tcp->refcount.count, tcp->refcount.count + 1); |
| 144 | gpr_ref(&tcp->refcount); |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 145 | } |
| 146 | #else |
| 147 | #define TCP_UNREF(tcp, reason) tcp_unref((tcp)) |
| 148 | #define TCP_REF(tcp, reason) tcp_ref((tcp)) |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 149 | static void tcp_unref(grpc_tcp *tcp) { |
| 150 | if (gpr_unref(&tcp->refcount)) { |
| 151 | tcp_free(tcp); |
| 152 | } |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 153 | } |
| 154 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 155 | static void tcp_ref(grpc_tcp *tcp) { gpr_ref(&tcp->refcount); } |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 156 | #endif |
| 157 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 158 | /* Asynchronous callback from the IOCP, or the background thread. */ |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 159 | static void on_read(grpc_exec_ctx *exec_ctx, void *tcpp, grpc_error *error) { |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 160 | grpc_tcp *tcp = tcpp; |
| 161 | grpc_closure *cb = tcp->read_cb; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 162 | grpc_winsocket *socket = tcp->socket; |
| 163 | gpr_slice sub; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 164 | grpc_winsocket_callback_info *info = &socket->read_info; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 165 | |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 166 | GRPC_ERROR_REF(error); |
| 167 | |
| 168 | if (error == GRPC_ERROR_NONE) { |
Jan Tattermusch | 6412479 | 2016-03-25 09:16:22 -0700 | [diff] [blame] | 169 | if (info->wsa_error != 0 && !tcp->shutting_down) { |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 170 | char *utf8_message = gpr_format_message(info->wsa_error); |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 171 | error = GRPC_ERROR_CREATE(utf8_message); |
| 172 | gpr_free(utf8_message); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 173 | gpr_slice_unref(tcp->read_slice); |
| 174 | } else { |
Nicolas "Pixel" Noble | 3a26c5b | 2015-09-22 00:07:14 +0200 | [diff] [blame] | 175 | if (info->bytes_transfered != 0 && !tcp->shutting_down) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 176 | sub = gpr_slice_sub_no_ref(tcp->read_slice, 0, info->bytes_transfered); |
| 177 | gpr_slice_buffer_add(tcp->read_slices, sub); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 178 | } else { |
| 179 | gpr_slice_unref(tcp->read_slice); |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 180 | error = GRPC_ERROR_CREATE("End of TCP stream"); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 181 | } |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 182 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 183 | } |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 184 | |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 185 | tcp->read_cb = NULL; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 186 | TCP_UNREF(tcp, "read"); |
Craig Tiller | 332f1b3 | 2016-05-24 13:21:21 -0700 | [diff] [blame] | 187 | grpc_exec_ctx_sched(exec_ctx, cb, error, NULL); |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 188 | } |
| 189 | |
Craig Tiller | 565b18b | 2015-09-23 10:09:42 -0700 | [diff] [blame] | 190 | static void win_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, |
| 191 | gpr_slice_buffer *read_slices, grpc_closure *cb) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 192 | grpc_tcp *tcp = (grpc_tcp *)ep; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 193 | grpc_winsocket *handle = tcp->socket; |
| 194 | grpc_winsocket_callback_info *info = &handle->read_info; |
| 195 | int status; |
| 196 | DWORD bytes_read = 0; |
| 197 | DWORD flags = 0; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 198 | WSABUF buffer; |
| 199 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 200 | if (tcp->shutting_down) { |
Craig Tiller | 332f1b3 | 2016-05-24 13:21:21 -0700 | [diff] [blame] | 201 | grpc_exec_ctx_sched(exec_ctx, cb, |
Craig Tiller | 77c983d | 2016-05-24 13:23:14 -0700 | [diff] [blame] | 202 | GRPC_ERROR_CREATE("TCP socket is shutting down"), NULL); |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 203 | return; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 204 | } |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 205 | |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 206 | tcp->read_cb = cb; |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 207 | tcp->read_slices = read_slices; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 208 | gpr_slice_buffer_reset_and_unref(read_slices); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 209 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 210 | tcp->read_slice = gpr_slice_malloc(8192); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 211 | |
Craig Tiller | 620e965 | 2015-12-14 12:02:50 -0800 | [diff] [blame] | 212 | buffer.len = (ULONG)GPR_SLICE_LENGTH( |
| 213 | tcp->read_slice); // we know slice size fits in 32bit. |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 214 | buffer.buf = (char *)GPR_SLICE_START_PTR(tcp->read_slice); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 215 | |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 216 | TCP_REF(tcp, "read"); |
| 217 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 218 | /* First let's try a synchronous, non-blocking read. */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 219 | status = |
| 220 | WSARecv(tcp->socket->socket, &buffer, 1, &bytes_read, &flags, NULL, NULL); |
| 221 | info->wsa_error = status == 0 ? 0 : WSAGetLastError(); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 222 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 223 | /* Did we get data immediately ? Yay. */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 224 | if (info->wsa_error != WSAEWOULDBLOCK) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 225 | info->bytes_transfered = bytes_read; |
Craig Tiller | 332f1b3 | 2016-05-24 13:21:21 -0700 | [diff] [blame] | 226 | grpc_exec_ctx_sched(exec_ctx, &tcp->on_read, GRPC_ERROR_NONE, NULL); |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 227 | return; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 228 | } |
Nicolas "Pixel" Noble | 7f2e98c | 2015-05-08 01:41:21 +0200 | [diff] [blame] | 229 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 230 | /* Otherwise, let's retry, by queuing a read. */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 231 | memset(&tcp->socket->read_info.overlapped, 0, sizeof(OVERLAPPED)); |
| 232 | status = WSARecv(tcp->socket->socket, &buffer, 1, &bytes_read, &flags, |
| 233 | &info->overlapped, NULL); |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 234 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 235 | if (status != 0) { |
| 236 | int wsa_error = WSAGetLastError(); |
| 237 | if (wsa_error != WSA_IO_PENDING) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 238 | info->wsa_error = wsa_error; |
Craig Tiller | 332f1b3 | 2016-05-24 13:21:21 -0700 | [diff] [blame] | 239 | grpc_exec_ctx_sched(exec_ctx, &tcp->on_read, |
Craig Tiller | 77c983d | 2016-05-24 13:23:14 -0700 | [diff] [blame] | 240 | GRPC_WSA_ERROR(info->wsa_error, "WSARecv"), NULL); |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 241 | return; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 242 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 243 | } |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 244 | |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 245 | grpc_socket_notify_on_read(exec_ctx, tcp->socket, &tcp->on_read); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 246 | } |
| 247 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 248 | /* Asynchronous callback from the IOCP, or the background thread. */ |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 249 | static void on_write(grpc_exec_ctx *exec_ctx, void *tcpp, grpc_error *error) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 250 | grpc_tcp *tcp = (grpc_tcp *)tcpp; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 251 | grpc_winsocket *handle = tcp->socket; |
| 252 | grpc_winsocket_callback_info *info = &handle->write_info; |
Craig Tiller | 3382511 | 2015-09-18 07:44:19 -0700 | [diff] [blame] | 253 | grpc_closure *cb; |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 254 | |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 255 | GRPC_ERROR_REF(error); |
| 256 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 257 | gpr_mu_lock(&tcp->mu); |
Nicolas Noble | e144536 | 2015-05-11 17:40:26 -0700 | [diff] [blame] | 258 | cb = tcp->write_cb; |
| 259 | tcp->write_cb = NULL; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 260 | gpr_mu_unlock(&tcp->mu); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 261 | |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 262 | if (error == GRPC_ERROR_NONE) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 263 | if (info->wsa_error != 0) { |
Craig Tiller | a41ac57 | 2016-05-17 16:08:17 -0700 | [diff] [blame] | 264 | error = GRPC_WSA_ERROR(info->wsa_error, "WSASend"); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 265 | } else { |
| 266 | GPR_ASSERT(info->bytes_transfered == tcp->write_slices->length); |
Nicolas Noble | e144536 | 2015-05-11 17:40:26 -0700 | [diff] [blame] | 267 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 268 | } |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 269 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 270 | TCP_UNREF(tcp, "write"); |
Craig Tiller | 332f1b3 | 2016-05-24 13:21:21 -0700 | [diff] [blame] | 271 | grpc_exec_ctx_sched(exec_ctx, cb, error, NULL); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 272 | } |
| 273 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 274 | /* Initiates a write. */ |
Craig Tiller | 565b18b | 2015-09-23 10:09:42 -0700 | [diff] [blame] | 275 | static void win_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, |
| 276 | gpr_slice_buffer *slices, grpc_closure *cb) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 277 | grpc_tcp *tcp = (grpc_tcp *)ep; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 278 | grpc_winsocket *socket = tcp->socket; |
| 279 | grpc_winsocket_callback_info *info = &socket->write_info; |
| 280 | unsigned i; |
| 281 | DWORD bytes_sent; |
| 282 | int status; |
| 283 | WSABUF local_buffers[16]; |
| 284 | WSABUF *allocated = NULL; |
| 285 | WSABUF *buffers = local_buffers; |
Jan Tattermusch | f67f071 | 2015-12-07 18:09:49 -0800 | [diff] [blame] | 286 | size_t len; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 287 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 288 | if (tcp->shutting_down) { |
Craig Tiller | 332f1b3 | 2016-05-24 13:21:21 -0700 | [diff] [blame] | 289 | grpc_exec_ctx_sched(exec_ctx, cb, |
Craig Tiller | 77c983d | 2016-05-24 13:23:14 -0700 | [diff] [blame] | 290 | GRPC_ERROR_CREATE("TCP socket is shutting down"), NULL); |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 291 | return; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 292 | } |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 293 | |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 294 | tcp->write_cb = cb; |
Craig Tiller | b029859 | 2015-08-27 07:38:01 -0700 | [diff] [blame] | 295 | tcp->write_slices = slices; |
Jan Tattermusch | f67f071 | 2015-12-07 18:09:49 -0800 | [diff] [blame] | 296 | GPR_ASSERT(tcp->write_slices->count <= UINT_MAX); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 297 | if (tcp->write_slices->count > GPR_ARRAY_SIZE(local_buffers)) { |
| 298 | buffers = (WSABUF *)gpr_malloc(sizeof(WSABUF) * tcp->write_slices->count); |
| 299 | allocated = buffers; |
| 300 | } |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 301 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 302 | for (i = 0; i < tcp->write_slices->count; i++) { |
Jan Tattermusch | f67f071 | 2015-12-07 18:09:49 -0800 | [diff] [blame] | 303 | len = GPR_SLICE_LENGTH(tcp->write_slices->slices[i]); |
| 304 | GPR_ASSERT(len <= ULONG_MAX); |
Craig Tiller | 620e965 | 2015-12-14 12:02:50 -0800 | [diff] [blame] | 305 | buffers[i].len = (ULONG)len; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 306 | buffers[i].buf = (char *)GPR_SLICE_START_PTR(tcp->write_slices->slices[i]); |
| 307 | } |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 308 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 309 | /* First, let's try a synchronous, non-blocking write. */ |
Jan Tattermusch | 4b3ecdf | 2015-12-04 09:33:05 -0800 | [diff] [blame] | 310 | status = WSASend(socket->socket, buffers, (DWORD)tcp->write_slices->count, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 311 | &bytes_sent, 0, NULL, NULL); |
| 312 | info->wsa_error = status == 0 ? 0 : WSAGetLastError(); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 313 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 314 | /* We would kind of expect to get a WSAEWOULDBLOCK here, especially on a busy |
| 315 | connection that has its send queue filled up. But if we don't, then we can |
| 316 | avoid doing an async write operation at all. */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 317 | if (info->wsa_error != WSAEWOULDBLOCK) { |
Craig Tiller | 3e149f3 | 2016-05-17 16:11:04 -0700 | [diff] [blame] | 318 | grpc_error *error = status == 0 |
| 319 | ? GRPC_ERROR_NONE |
| 320 | : GRPC_WSA_ERROR(info->wsa_error, "WSASend"); |
Craig Tiller | 332f1b3 | 2016-05-24 13:21:21 -0700 | [diff] [blame] | 321 | grpc_exec_ctx_sched(exec_ctx, cb, error, NULL); |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 322 | return; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 323 | } |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 324 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 325 | TCP_REF(tcp, "write"); |
Craig Tiller | 9f80fcf | 2015-08-28 08:22:48 -0700 | [diff] [blame] | 326 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 327 | /* If we got a WSAEWOULDBLOCK earlier, then we need to re-do the same |
| 328 | operation, this time asynchronously. */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 329 | memset(&socket->write_info.overlapped, 0, sizeof(OVERLAPPED)); |
Jan Tattermusch | 4b3ecdf | 2015-12-04 09:33:05 -0800 | [diff] [blame] | 330 | status = WSASend(socket->socket, buffers, (DWORD)tcp->write_slices->count, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 331 | &bytes_sent, 0, &socket->write_info.overlapped, NULL); |
| 332 | if (allocated) gpr_free(allocated); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 333 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 334 | if (status != 0) { |
| 335 | int wsa_error = WSAGetLastError(); |
| 336 | if (wsa_error != WSA_IO_PENDING) { |
| 337 | TCP_UNREF(tcp, "write"); |
Craig Tiller | 332f1b3 | 2016-05-24 13:21:21 -0700 | [diff] [blame] | 338 | grpc_exec_ctx_sched(exec_ctx, cb, GRPC_WSA_ERROR(wsa_error, "WSASend"), |
Craig Tiller | 77c983d | 2016-05-24 13:23:14 -0700 | [diff] [blame] | 339 | NULL); |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 340 | return; |
Nicolas "Pixel" Noble | 7f2e98c | 2015-05-08 01:41:21 +0200 | [diff] [blame] | 341 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 342 | } |
Nicolas "Pixel" Noble | 7f2e98c | 2015-05-08 01:41:21 +0200 | [diff] [blame] | 343 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 344 | /* As all is now setup, we can now ask for the IOCP notification. It may |
| 345 | trigger the callback immediately however, but no matter. */ |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 346 | grpc_socket_notify_on_write(exec_ctx, socket, &tcp->on_write); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 347 | } |
| 348 | |
Craig Tiller | 565b18b | 2015-09-23 10:09:42 -0700 | [diff] [blame] | 349 | static void win_add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, |
| 350 | grpc_pollset *ps) { |
Jan Tattermusch | deab29e | 2015-08-03 12:32:44 -0700 | [diff] [blame] | 351 | grpc_tcp *tcp; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 352 | (void)ps; |
| 353 | tcp = (grpc_tcp *)ep; |
| 354 | grpc_iocp_add_socket(tcp->socket); |
Nicolas "Pixel" Noble | f29e9db | 2015-07-29 06:00:22 +0200 | [diff] [blame] | 355 | } |
| 356 | |
Craig Tiller | 565b18b | 2015-09-23 10:09:42 -0700 | [diff] [blame] | 357 | static void win_add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, |
| 358 | grpc_pollset_set *pss) { |
Jan Tattermusch | deab29e | 2015-08-03 12:32:44 -0700 | [diff] [blame] | 359 | grpc_tcp *tcp; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 360 | (void)pss; |
| 361 | tcp = (grpc_tcp *)ep; |
| 362 | grpc_iocp_add_socket(tcp->socket); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 363 | } |
| 364 | |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 365 | /* Initiates a shutdown of the TCP endpoint. This will queue abort callbacks |
| 366 | for the potential read and write operations. It is up to the caller to |
| 367 | guarantee this isn't called in parallel to a read or write request, so |
| 368 | we're not going to protect against these. However the IO Completion Port |
| 369 | callback will happen from another thread, so we need to protect against |
| 370 | concurrent access of the data structure in that regard. */ |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 371 | static void win_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 372 | grpc_tcp *tcp = (grpc_tcp *)ep; |
| 373 | gpr_mu_lock(&tcp->mu); |
Nicolas "Pixel" Noble | 0f981e9 | 2015-05-03 10:40:56 +0200 | [diff] [blame] | 374 | /* At that point, what may happen is that we're already inside the IOCP |
| 375 | callback. See the comments in on_read and on_write. */ |
| 376 | tcp->shutting_down = 1; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 377 | grpc_winsocket_shutdown(tcp->socket); |
| 378 | gpr_mu_unlock(&tcp->mu); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 379 | } |
| 380 | |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 381 | static void win_destroy(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) { |
Makarand Dharmapurikar | 6149443 | 2016-06-22 13:34:59 -0700 | [diff] [blame] | 382 | grpc_network_status_unregister_endpoint(ep); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 383 | grpc_tcp *tcp = (grpc_tcp *)ep; |
| 384 | TCP_UNREF(tcp, "destroy"); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 385 | } |
| 386 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 387 | static char *win_get_peer(grpc_endpoint *ep) { |
| 388 | grpc_tcp *tcp = (grpc_tcp *)ep; |
| 389 | return gpr_strdup(tcp->peer_string); |
Craig Tiller | 81bcc4c | 2015-07-20 14:04:18 -0700 | [diff] [blame] | 390 | } |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 391 | |
Craig Tiller | 5e4fb0e | 2016-06-30 14:53:51 -0700 | [diff] [blame] | 392 | static grpc_workqueue *win_get_workqueue(grpc_endpoint *ep) { return NULL; } |
| 393 | |
| 394 | static grpc_endpoint_vtable vtable = {win_read, |
| 395 | win_write, |
| 396 | win_get_workqueue, |
| 397 | win_add_to_pollset, |
| 398 | win_add_to_pollset_set, |
| 399 | win_shutdown, |
| 400 | win_destroy, |
| 401 | win_get_peer}; |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 402 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 403 | grpc_endpoint *grpc_tcp_create(grpc_winsocket *socket, char *peer_string) { |
| 404 | grpc_tcp *tcp = (grpc_tcp *)gpr_malloc(sizeof(grpc_tcp)); |
| 405 | memset(tcp, 0, sizeof(grpc_tcp)); |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 406 | tcp->base.vtable = &vtable; |
| 407 | tcp->socket = socket; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 408 | gpr_mu_init(&tcp->mu); |
| 409 | gpr_ref_init(&tcp->refcount, 1); |
Craig Tiller | 82f9bd8 | 2015-09-23 09:31:51 -0700 | [diff] [blame] | 410 | grpc_closure_init(&tcp->on_read, on_read, tcp); |
Craig Tiller | 258f8de | 2015-09-23 12:32:40 -0700 | [diff] [blame] | 411 | grpc_closure_init(&tcp->on_write, on_write, tcp); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 412 | tcp->peer_string = gpr_strdup(peer_string); |
Makarand Dharmapurikar | 0579cfc | 2016-06-20 15:45:24 -0700 | [diff] [blame] | 413 | /* Tell network status tracking code about the new endpoint */ |
| 414 | grpc_network_status_register_endpoint(&tcp->base); |
| 415 | |
Nicolas "Pixel" Noble | 21f627a | 2015-02-04 01:31:14 +0100 | [diff] [blame] | 416 | return &tcp->base; |
| 417 | } |
| 418 | |
Craig Tiller | d6c98df | 2015-08-18 09:33:44 -0700 | [diff] [blame] | 419 | #endif /* GPR_WINSOCK_SOCKET */ |