OLD | NEW |
1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "platform/globals.h" | 5 #include "platform/globals.h" |
6 #if defined(TARGET_OS_LINUX) | 6 #if defined(TARGET_OS_LINUX) |
7 | 7 |
8 #include <errno.h> // NOLINT | 8 #include <errno.h> // NOLINT |
9 #include <stdio.h> // NOLINT | 9 #include <stdio.h> // NOLINT |
10 #include <stdlib.h> // NOLINT | 10 #include <stdlib.h> // NOLINT |
11 #include <string.h> // NOLINT | 11 #include <string.h> // NOLINT |
12 #include <sys/stat.h> // NOLINT | 12 #include <sys/stat.h> // NOLINT |
13 #include <unistd.h> // NOLINT | 13 #include <unistd.h> // NOLINT |
14 #include <netinet/tcp.h> // NOLINT | 14 #include <netinet/tcp.h> // NOLINT |
15 | 15 |
16 #include "bin/fdutils.h" | 16 #include "bin/fdutils.h" |
17 #include "bin/file.h" | 17 #include "bin/file.h" |
18 #include "bin/log.h" | 18 #include "bin/log.h" |
19 #include "bin/socket.h" | 19 #include "bin/socket.h" |
20 | 20 |
21 | 21 |
| 22 SocketAddress::SocketAddress(struct addrinfo* addrinfo) { |
| 23 ASSERT(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); |
| 24 sockaddr_in *sockaddr = SocketAddress::GetAsSockAddrIn(addrinfo->ai_addr); |
| 25 const char* result = inet_ntop(addrinfo->ai_family, |
| 26 &sockaddr->sin_addr, |
| 27 as_string_, |
| 28 INET6_ADDRSTRLEN); |
| 29 if (result == NULL) as_string_[0] = 0; |
| 30 memmove(reinterpret_cast<void *>(&addr_), |
| 31 addrinfo->ai_addr, |
| 32 addrinfo->ai_addrlen); |
| 33 } |
| 34 |
| 35 |
22 bool Socket::Initialize() { | 36 bool Socket::Initialize() { |
23 // Nothing to do on Linux. | 37 // Nothing to do on Linux. |
24 return true; | 38 return true; |
25 } | 39 } |
26 | 40 |
27 | 41 |
28 intptr_t Socket::CreateConnect(const char* host, const intptr_t port) { | 42 intptr_t Socket::CreateConnect(sockaddr_storage addr, const intptr_t port) { |
29 intptr_t fd; | 43 intptr_t fd; |
30 struct hostent server; | |
31 struct sockaddr_in server_address; | |
32 | 44 |
33 fd = TEMP_FAILURE_RETRY(socket(AF_INET, SOCK_STREAM, 0)); | 45 fd = TEMP_FAILURE_RETRY(socket(addr.ss_family, SOCK_STREAM, 0)); |
34 if (fd < 0) { | 46 if (fd < 0) { |
35 Log::PrintErr("Error CreateConnect: %s\n", strerror(errno)); | 47 Log::PrintErr("Error CreateConnect: %s\n", strerror(errno)); |
36 return -1; | 48 return -1; |
37 } | 49 } |
38 | 50 |
39 FDUtils::SetCloseOnExec(fd); | 51 FDUtils::SetCloseOnExec(fd); |
40 Socket::SetNonBlocking(fd); | 52 Socket::SetNonBlocking(fd); |
41 | 53 |
42 static const size_t kTempBufSize = 1024; | 54 SocketAddress::SetAddrPort(&addr, port); |
43 char temp_buf[kTempBufSize]; | |
44 struct hostent *unused; | |
45 int err; | |
46 if (gethostbyname_r( | |
47 host, &server, temp_buf, kTempBufSize, &unused, &err) != 0) { | |
48 TEMP_FAILURE_RETRY(close(fd)); | |
49 Log::PrintErr("Error CreateConnect: %s\n", strerror(errno)); | |
50 return -1; | |
51 } | |
52 | |
53 server_address.sin_family = AF_INET; | |
54 server_address.sin_port = htons(port); | |
55 bcopy(server.h_addr, &server_address.sin_addr.s_addr, server.h_length); | |
56 memset(&server_address.sin_zero, 0, sizeof(server_address.sin_zero)); | |
57 intptr_t result = TEMP_FAILURE_RETRY( | 55 intptr_t result = TEMP_FAILURE_RETRY( |
58 connect(fd, | 56 connect(fd, |
59 reinterpret_cast<struct sockaddr *>(&server_address), | 57 SocketAddress::GetAsSockAddr(&addr), |
60 sizeof(server_address))); | 58 SocketAddress::GetAddrLength(addr))); |
61 if (result == 0 || errno == EINPROGRESS) { | 59 if (result == 0 || errno == EINPROGRESS) { |
62 return fd; | 60 return fd; |
63 } | 61 } |
| 62 TEMP_FAILURE_RETRY(close(fd)); |
64 return -1; | 63 return -1; |
65 } | 64 } |
66 | 65 |
67 | 66 |
68 intptr_t Socket::Available(intptr_t fd) { | 67 intptr_t Socket::Available(intptr_t fd) { |
69 return FDUtils::AvailableBytes(fd); | 68 return FDUtils::AvailableBytes(fd); |
70 } | 69 } |
71 | 70 |
72 | 71 |
73 int Socket::Read(intptr_t fd, void* buffer, intptr_t num_bytes) { | 72 int Socket::Read(intptr_t fd, void* buffer, intptr_t num_bytes) { |
(...skipping 17 matching lines...) Expand all Loading... |
91 // If the would block we need to retry and therefore return 0 as | 90 // If the would block we need to retry and therefore return 0 as |
92 // the number of bytes written. | 91 // the number of bytes written. |
93 written_bytes = 0; | 92 written_bytes = 0; |
94 } | 93 } |
95 return written_bytes; | 94 return written_bytes; |
96 } | 95 } |
97 | 96 |
98 | 97 |
99 intptr_t Socket::GetPort(intptr_t fd) { | 98 intptr_t Socket::GetPort(intptr_t fd) { |
100 ASSERT(fd >= 0); | 99 ASSERT(fd >= 0); |
101 struct sockaddr_in socket_address; | 100 struct sockaddr_storage socket_address; |
102 socklen_t size = sizeof(socket_address); | 101 socklen_t size = sizeof(socket_address); |
103 if (TEMP_FAILURE_RETRY( | 102 if (TEMP_FAILURE_RETRY( |
104 getsockname(fd, | 103 getsockname(fd, |
105 reinterpret_cast<struct sockaddr *>(&socket_address), | 104 SocketAddress::GetAsSockAddr(&socket_address), |
106 &size))) { | 105 &size))) { |
107 Log::PrintErr("Error getsockname: %s\n", strerror(errno)); | 106 Log::PrintErr("Error getsockname: %s\n", strerror(errno)); |
108 return 0; | 107 return 0; |
109 } | 108 } |
110 return ntohs(socket_address.sin_port); | 109 return SocketAddress::GetAddrPort(&socket_address); |
111 } | 110 } |
112 | 111 |
113 | 112 |
114 bool Socket::GetRemotePeer(intptr_t fd, char *host, intptr_t *port) { | 113 bool Socket::GetRemotePeer(intptr_t fd, char *host, intptr_t *port) { |
115 ASSERT(fd >= 0); | 114 ASSERT(fd >= 0); |
116 struct sockaddr_in socket_address; | 115 struct sockaddr_storage socket_address; |
117 socklen_t size = sizeof(socket_address); | 116 socklen_t size = sizeof(socket_address); |
118 if (TEMP_FAILURE_RETRY( | 117 if (TEMP_FAILURE_RETRY( |
119 getpeername(fd, | 118 getpeername(fd, |
120 reinterpret_cast<struct sockaddr *>(&socket_address), | 119 SocketAddress::GetAsSockAddr(&socket_address), |
121 &size))) { | 120 &size))) { |
122 Log::PrintErr("Error getpeername: %s\n", strerror(errno)); | 121 Log::PrintErr("Error getpeername: %s\n", strerror(errno)); |
123 return false; | 122 return false; |
124 } | 123 } |
125 if (inet_ntop(socket_address.sin_family, | 124 struct sockaddr* as_addr = SocketAddress::GetAsSockAddr(&socket_address); |
126 reinterpret_cast<const void *>(&socket_address.sin_addr), | 125 const void* src; |
| 126 if (socket_address.ss_family == AF_INET6) { |
| 127 src = reinterpret_cast<const void*>( |
| 128 &SocketAddress::GetAsSockAddrIn6(as_addr)->sin6_addr); |
| 129 } else { |
| 130 src = reinterpret_cast<const void*>( |
| 131 &SocketAddress::GetAsSockAddrIn(as_addr)->sin_addr); |
| 132 } |
| 133 if (inet_ntop(socket_address.ss_family, |
| 134 src, |
127 host, | 135 host, |
128 INET_ADDRSTRLEN) == NULL) { | 136 INET_ADDRSTRLEN) == NULL) { |
129 Log::PrintErr("Error inet_ntop: %s\n", strerror(errno)); | 137 Log::PrintErr("Error inet_ntop: %s\n", strerror(errno)); |
130 return false; | 138 return false; |
131 } | 139 } |
132 *port = ntohs(socket_address.sin_port); | 140 *port = SocketAddress::GetAddrPort(&socket_address); |
133 return true; | 141 return true; |
134 } | 142 } |
135 | 143 |
136 | 144 |
137 void Socket::GetError(intptr_t fd, OSError* os_error) { | 145 void Socket::GetError(intptr_t fd, OSError* os_error) { |
138 int len = sizeof(errno); | 146 int len = sizeof(errno); |
139 getsockopt(fd, | 147 getsockopt(fd, |
140 SOL_SOCKET, | 148 SOL_SOCKET, |
141 SO_ERROR, | 149 SO_ERROR, |
142 &errno, | 150 &errno, |
(...skipping 11 matching lines...) Expand all Loading... |
154 if (S_ISREG(buf.st_mode)) return File::kFile; | 162 if (S_ISREG(buf.st_mode)) return File::kFile; |
155 return File::kOther; | 163 return File::kOther; |
156 } | 164 } |
157 | 165 |
158 | 166 |
159 intptr_t Socket::GetStdioHandle(int num) { | 167 intptr_t Socket::GetStdioHandle(int num) { |
160 return static_cast<intptr_t>(num); | 168 return static_cast<intptr_t>(num); |
161 } | 169 } |
162 | 170 |
163 | 171 |
164 const char* Socket::LookupIPv4Address(char* host, OSError** os_error) { | 172 SocketAddresses* Socket::LookupAddress(const char* host, |
165 // Perform a name lookup for an IPv4 address. | 173 int type, |
| 174 OSError** os_error) { |
| 175 // Perform a name lookup for a host name. |
166 struct addrinfo hints; | 176 struct addrinfo hints; |
167 memset(&hints, 0, sizeof(hints)); | 177 memset(&hints, 0, sizeof(hints)); |
168 hints.ai_family = AF_INET; | 178 hints.ai_family = SocketAddress::FromType(type); |
169 hints.ai_socktype = SOCK_STREAM; | 179 hints.ai_socktype = SOCK_STREAM; |
| 180 hints.ai_flags = 0; |
170 hints.ai_protocol = IPPROTO_TCP; | 181 hints.ai_protocol = IPPROTO_TCP; |
171 struct addrinfo* info = NULL; | 182 struct addrinfo* info = NULL; |
172 int status = getaddrinfo(host, 0, &hints, &info); | 183 int status = getaddrinfo(host, 0, &hints, &info); |
173 if (status != 0) { | 184 if (status != 0) { |
174 ASSERT(*os_error == NULL); | 185 ASSERT(*os_error == NULL); |
175 *os_error = new OSError(status, | 186 *os_error = new OSError(status, |
176 gai_strerror(status), | 187 gai_strerror(status), |
177 OSError::kGetAddressInfo); | 188 OSError::kGetAddressInfo); |
178 return NULL; | 189 return NULL; |
179 } | 190 } |
180 // Convert the address into IPv4 dotted decimal notation. | 191 intptr_t count = 0; |
181 char* buffer = reinterpret_cast<char*>(malloc(INET_ADDRSTRLEN)); | 192 for (struct addrinfo* c = info; c != NULL; c = c->ai_next) { |
182 sockaddr_in *sockaddr = reinterpret_cast<sockaddr_in *>(info->ai_addr); | 193 if (c->ai_family == AF_INET || c->ai_family == AF_INET6) count++; |
183 const char* result = inet_ntop(AF_INET, | |
184 reinterpret_cast<void *>(&sockaddr->sin_addr), | |
185 buffer, | |
186 INET_ADDRSTRLEN); | |
187 if (result == NULL) { | |
188 free(buffer); | |
189 return NULL; | |
190 } | 194 } |
191 ASSERT(result == buffer); | 195 SocketAddresses* addresses = new SocketAddresses(count); |
192 return buffer; | 196 intptr_t i = 0; |
| 197 for (struct addrinfo* c = info; c != NULL; c = c->ai_next) { |
| 198 if (c->ai_family == AF_INET || c->ai_family == AF_INET6) { |
| 199 addresses->SetAt(i, new SocketAddress(c)); |
| 200 i++; |
| 201 } |
| 202 } |
| 203 freeaddrinfo(info); |
| 204 return addresses; |
193 } | 205 } |
194 | 206 |
195 | 207 |
196 intptr_t ServerSocket::CreateBindListen(const char* host, | 208 intptr_t ServerSocket::CreateBindListen(sockaddr_storage addr, |
197 intptr_t port, | 209 intptr_t port, |
198 intptr_t backlog) { | 210 intptr_t backlog) { |
199 intptr_t fd; | 211 intptr_t fd; |
200 struct sockaddr_in server_address; | |
201 | 212 |
202 in_addr_t s_addr = inet_addr(host); | 213 fd = TEMP_FAILURE_RETRY(socket(addr.ss_family, SOCK_STREAM, 0)); |
203 if (s_addr == INADDR_NONE) { | |
204 return -5; | |
205 } | |
206 | |
207 fd = TEMP_FAILURE_RETRY(socket(AF_INET, SOCK_STREAM, 0)); | |
208 if (fd < 0) return -1; | 214 if (fd < 0) return -1; |
209 | 215 |
210 FDUtils::SetCloseOnExec(fd); | 216 FDUtils::SetCloseOnExec(fd); |
211 | 217 |
212 int optval = 1; | 218 int optval = 1; |
213 TEMP_FAILURE_RETRY( | 219 TEMP_FAILURE_RETRY( |
214 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval))); | 220 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval))); |
215 | 221 |
216 server_address.sin_family = AF_INET; | 222 if (addr.ss_family == AF_INET6) { |
217 server_address.sin_port = htons(port); | 223 optval = 0; |
218 server_address.sin_addr.s_addr = s_addr; | 224 TEMP_FAILURE_RETRY( |
219 memset(&server_address.sin_zero, 0, sizeof(server_address.sin_zero)); | 225 setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof(optval))); |
| 226 } |
220 | 227 |
| 228 SocketAddress::SetAddrPort(&addr, port); |
221 if (TEMP_FAILURE_RETRY( | 229 if (TEMP_FAILURE_RETRY( |
222 bind(fd, | 230 bind(fd, |
223 reinterpret_cast<struct sockaddr *>(&server_address), | 231 SocketAddress::GetAsSockAddr(&addr), |
224 sizeof(server_address))) < 0) { | 232 SocketAddress::GetAddrLength(addr))) < 0) { |
225 TEMP_FAILURE_RETRY(close(fd)); | 233 TEMP_FAILURE_RETRY(close(fd)); |
226 return -1; | 234 return -1; |
227 } | 235 } |
228 | 236 |
229 if (TEMP_FAILURE_RETRY(listen(fd, backlog > 0 ? backlog : SOMAXCONN)) != 0) { | 237 if (TEMP_FAILURE_RETRY(listen(fd, backlog > 0 ? backlog : SOMAXCONN)) != 0) { |
230 TEMP_FAILURE_RETRY(close(fd)); | 238 TEMP_FAILURE_RETRY(close(fd)); |
231 return -1; | 239 return -1; |
232 } | 240 } |
233 | 241 |
234 Socket::SetNonBlocking(fd); | 242 Socket::SetNonBlocking(fd); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
291 bool Socket::SetNoDelay(intptr_t fd, bool enabled) { | 299 bool Socket::SetNoDelay(intptr_t fd, bool enabled) { |
292 int on = enabled ? 1 : 0; | 300 int on = enabled ? 1 : 0; |
293 return TEMP_FAILURE_RETRY(setsockopt(fd, | 301 return TEMP_FAILURE_RETRY(setsockopt(fd, |
294 SOL_TCP, | 302 SOL_TCP, |
295 TCP_NODELAY, | 303 TCP_NODELAY, |
296 reinterpret_cast<char *>(&on), | 304 reinterpret_cast<char *>(&on), |
297 sizeof(on))) == 0; | 305 sizeof(on))) == 0; |
298 } | 306 } |
299 | 307 |
300 #endif // defined(TARGET_OS_LINUX) | 308 #endif // defined(TARGET_OS_LINUX) |
OLD | NEW |