1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <arpa/inet.h>
18 #include <errno.h>
19 #include <netdb.h>
20 #include <netinet/in.h>
21 #include <netinet/tcp.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/socket.h>
26 #include <sys/types.h>
27 #include <unistd.h>
28
29 #include "base/logging.h"
30 #include "base/stringprintf.h"
31 #include "jdwp/jdwp_priv.h"
32
33 #define kBasePort 8000
34 #define kMaxPort 8040
35
36 namespace art {
37
38 namespace JDWP {
39
40 /*
41 * JDWP network state.
42 *
43 * We only talk to one debugger at a time.
44 */
45 struct JdwpSocketState : public JdwpNetStateBase {
46 uint16_t listenPort;
47 int listenSock; /* listen for connection from debugger */
48
JdwpSocketStateart::JDWP::JdwpSocketState49 explicit JdwpSocketState(JdwpState* state) : JdwpNetStateBase(state) {
50 listenPort = 0;
51 listenSock = -1;
52 }
53
54 virtual bool Accept();
55 virtual bool Establish(const JdwpOptions*);
56 virtual void Shutdown();
57 virtual bool ProcessIncoming();
58
59 private:
60 in_addr remote_addr_;
61 uint16_t remote_port_;
62 };
63
64 static JdwpSocketState* SocketStartup(JdwpState* state, uint16_t port, bool probe);
65
66 /*
67 * Set up some stuff for transport=dt_socket.
68 */
InitSocketTransport(JdwpState * state,const JdwpOptions * options)69 bool InitSocketTransport(JdwpState* state, const JdwpOptions* options) {
70 uint16_t port = options->port;
71
72 if (options->server) {
73 if (options->port != 0) {
74 /* try only the specified port */
75 state->netState = SocketStartup(state, port, false);
76 } else {
77 /* scan through a range of ports, binding to the first available */
78 for (port = kBasePort; port <= kMaxPort; port++) {
79 state->netState = SocketStartup(state, port, true);
80 if (state->netState != nullptr) {
81 break;
82 }
83 }
84 }
85 if (state->netState == nullptr) {
86 LOG(ERROR) << "JDWP net startup failed (req port=" << options->port << ")";
87 return false;
88 }
89 } else {
90 state->netState = SocketStartup(state, 0, false);
91 }
92
93 if (options->suspend) {
94 LOG(INFO) << "JDWP will wait for debugger on port " << port;
95 } else {
96 LOG(INFO) << "JDWP will " << (options->server ? "listen" : "connect") << " on port " << port;
97 }
98
99 return true;
100 }
101
102 /*
103 * Initialize JDWP stuff.
104 *
105 * Allocates a new state structure. If "port" is non-zero, this also
106 * tries to bind to a listen port. If "port" is zero, we assume
107 * we're preparing for an outbound connection, and return without binding
108 * to anything.
109 *
110 * This may be called several times if we're probing for a port.
111 *
112 * Returns 0 on success.
113 */
SocketStartup(JdwpState * state,uint16_t port,bool probe)114 static JdwpSocketState* SocketStartup(JdwpState* state, uint16_t port, bool probe) {
115 JdwpSocketState* netState = new JdwpSocketState(state);
116 if (port == 0) {
117 return netState;
118 }
119
120 netState->listenSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
121 if (netState->listenSock < 0) {
122 PLOG(probe ? ERROR : FATAL) << "Socket create failed";
123 goto fail;
124 }
125
126 /* allow immediate re-use */
127 {
128 int one = 1;
129 if (setsockopt(netState->listenSock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) {
130 PLOG(probe ? ERROR : FATAL) << "setsockopt(SO_REUSEADDR) failed";
131 goto fail;
132 }
133 }
134
135 union {
136 sockaddr_in addrInet;
137 sockaddr addrPlain;
138 } addr;
139 addr.addrInet.sin_family = AF_INET;
140 addr.addrInet.sin_port = htons(port);
141 inet_aton("127.0.0.1", &addr.addrInet.sin_addr);
142
143 if (bind(netState->listenSock, &addr.addrPlain, sizeof(addr)) != 0) {
144 PLOG(probe ? ERROR : FATAL) << "Attempt to bind to port " << port << " failed";
145 goto fail;
146 }
147
148 netState->listenPort = port;
149
150 if (listen(netState->listenSock, 5) != 0) {
151 PLOG(probe ? ERROR : FATAL) << "Listen failed";
152 goto fail;
153 }
154
155 return netState;
156
157 fail:
158 netState->Shutdown();
159 delete netState;
160 return nullptr;
161 }
162
163 /*
164 * Shut down JDWP listener. Don't free state.
165 *
166 * This may be called from a non-JDWP thread as part of shutting the
167 * JDWP thread down.
168 *
169 * (This is currently called several times during startup as we probe
170 * for an open port.)
171 */
Shutdown()172 void JdwpSocketState::Shutdown() {
173 int local_listenSock = this->listenSock;
174 int local_clientSock = this->clientSock;
175
176 /* clear these out so it doesn't wake up and try to reuse them */
177 this->listenSock = this->clientSock = -1;
178
179 /* "shutdown" dislodges blocking read() and accept() calls */
180 if (local_listenSock != -1) {
181 shutdown(local_listenSock, SHUT_RDWR);
182 close(local_listenSock);
183 }
184 if (local_clientSock != -1) {
185 shutdown(local_clientSock, SHUT_RDWR);
186 close(local_clientSock);
187 }
188
189 WakePipe();
190 }
191
192 /*
193 * Disable the TCP Nagle algorithm, which delays transmission of outbound
194 * packets until the previous transmissions have been acked. JDWP does a
195 * lot of back-and-forth with small packets, so this may help.
196 */
SetNoDelay(int fd)197 static int SetNoDelay(int fd) {
198 int on = 1;
199 int cc = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
200 CHECK_EQ(cc, 0);
201 return cc;
202 }
203
204 /*
205 * Accept a connection. This will block waiting for somebody to show up.
206 * If that's not desirable, use checkConnection() to make sure something
207 * is pending.
208 */
Accept()209 bool JdwpSocketState::Accept() {
210 union {
211 sockaddr_in addrInet;
212 sockaddr addrPlain;
213 } addr;
214 socklen_t addrlen;
215 int sock;
216
217 if (listenSock < 0) {
218 return false; /* you're not listening! */
219 }
220
221 CHECK_EQ(clientSock, -1); /* must not already be talking */
222
223 addrlen = sizeof(addr);
224 do {
225 sock = accept(listenSock, &addr.addrPlain, &addrlen);
226 if (sock < 0 && errno != EINTR) {
227 // When we call shutdown() on the socket, accept() returns with
228 // EINVAL. Don't gripe about it.
229 if (errno == EINVAL) {
230 if (VLOG_IS_ON(jdwp)) {
231 PLOG(ERROR) << "accept failed";
232 }
233 } else {
234 PLOG(ERROR) << "accept failed";
235 return false;
236 }
237 }
238 } while (sock < 0);
239
240 remote_addr_ = addr.addrInet.sin_addr;
241 remote_port_ = ntohs(addr.addrInet.sin_port);
242 VLOG(jdwp) << "+++ accepted connection from " << inet_ntoa(remote_addr_) << ":" << remote_port_;
243
244 clientSock = sock;
245 SetAwaitingHandshake(true);
246 input_count_ = 0;
247
248 VLOG(jdwp) << "Setting TCP_NODELAY on accepted socket";
249 SetNoDelay(clientSock);
250
251 if (!MakePipe()) {
252 return false;
253 }
254
255 return true;
256 }
257
258 /*
259 * Create a connection to a waiting debugger.
260 */
Establish(const JdwpOptions * options)261 bool JdwpSocketState::Establish(const JdwpOptions* options) {
262 union {
263 sockaddr_in addrInet;
264 sockaddr addrPlain;
265 } addr;
266 hostent* pEntry;
267
268 CHECK(!options->server);
269 CHECK(!options->host.empty());
270 CHECK_NE(options->port, 0);
271
272 /*
273 * Start by resolving the host name.
274 */
275 #if defined(__linux__)
276 hostent he;
277 char auxBuf[128];
278 int error;
279 int cc = gethostbyname_r(options->host.c_str(), &he, auxBuf, sizeof(auxBuf), &pEntry, &error);
280 if (cc != 0) {
281 LOG(WARNING) << "gethostbyname_r('" << options->host << "') failed: " << hstrerror(error);
282 return false;
283 }
284 #else
285 h_errno = 0;
286 pEntry = gethostbyname(options->host.c_str());
287 if (pEntry == nullptr) {
288 PLOG(WARNING) << "gethostbyname('" << options->host << "') failed";
289 return false;
290 }
291 #endif
292
293 /* copy it out ASAP to minimize risk of multithreaded annoyances */
294 memcpy(&addr.addrInet.sin_addr, pEntry->h_addr, pEntry->h_length);
295 addr.addrInet.sin_family = pEntry->h_addrtype;
296
297 addr.addrInet.sin_port = htons(options->port);
298
299 LOG(INFO) << "Connecting out to " << inet_ntoa(addr.addrInet.sin_addr) << ":" << ntohs(addr.addrInet.sin_port);
300
301 /*
302 * Create a socket.
303 */
304 clientSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
305 if (clientSock < 0) {
306 PLOG(ERROR) << "Unable to create socket";
307 return false;
308 }
309
310 /*
311 * Try to connect.
312 */
313 if (connect(clientSock, &addr.addrPlain, sizeof(addr)) != 0) {
314 PLOG(ERROR) << "Unable to connect to " << inet_ntoa(addr.addrInet.sin_addr) << ":" << ntohs(addr.addrInet.sin_port);
315 close(clientSock);
316 clientSock = -1;
317 return false;
318 }
319
320 LOG(INFO) << "Connection established to " << options->host << " (" << inet_ntoa(addr.addrInet.sin_addr) << ":" << ntohs(addr.addrInet.sin_port) << ")";
321 SetAwaitingHandshake(true);
322 input_count_ = 0;
323
324 SetNoDelay(clientSock);
325
326 if (!MakePipe()) {
327 return false;
328 }
329
330 return true;
331 }
332
333 /*
334 * Process incoming data. If no data is available, this will block until
335 * some arrives.
336 *
337 * If we get a full packet, handle it.
338 *
339 * To take some of the mystery out of life, we want to reject incoming
340 * connections if we already have a debugger attached. If we don't, the
341 * debugger will just mysteriously hang until it times out. We could just
342 * close the listen socket, but there's a good chance we won't be able to
343 * bind to the same port again, which would confuse utilities.
344 *
345 * Returns "false" on error (indicating that the connection has been severed),
346 * "true" if things are still okay.
347 */
ProcessIncoming()348 bool JdwpSocketState::ProcessIncoming() {
349 int readCount;
350
351 CHECK_NE(clientSock, -1);
352
353 if (!HaveFullPacket()) {
354 /* read some more, looping until we have data */
355 errno = 0;
356 while (1) {
357 int selCount;
358 fd_set readfds;
359 int maxfd = -1;
360 int fd;
361
362 FD_ZERO(&readfds);
363
364 /* configure fds; note these may get zapped by another thread */
365 fd = listenSock;
366 if (fd >= 0) {
367 FD_SET(fd, &readfds);
368 if (maxfd < fd) {
369 maxfd = fd;
370 }
371 }
372 fd = clientSock;
373 if (fd >= 0) {
374 FD_SET(fd, &readfds);
375 if (maxfd < fd) {
376 maxfd = fd;
377 }
378 }
379 fd = wake_pipe_[0];
380 if (fd >= 0) {
381 FD_SET(fd, &readfds);
382 if (maxfd < fd) {
383 maxfd = fd;
384 }
385 } else {
386 LOG(INFO) << "NOTE: entering select w/o wakepipe";
387 }
388
389 if (maxfd < 0) {
390 VLOG(jdwp) << "+++ all fds are closed";
391 return false;
392 }
393
394 /*
395 * Select blocks until it sees activity on the file descriptors.
396 * Closing the local file descriptor does not count as activity,
397 * so we can't rely on that to wake us up (it works for read()
398 * and accept(), but not select()).
399 *
400 * We can do one of three things: (1) send a signal and catch
401 * EINTR, (2) open an additional fd ("wake pipe") and write to
402 * it when it's time to exit, or (3) time out periodically and
403 * re-issue the select. We're currently using #2, as it's more
404 * reliable than #1 and generally better than #3. Wastes two fds.
405 */
406 selCount = select(maxfd + 1, &readfds, nullptr, nullptr, nullptr);
407 if (selCount < 0) {
408 if (errno == EINTR) {
409 continue;
410 }
411 PLOG(ERROR) << "select failed";
412 goto fail;
413 }
414
415 if (wake_pipe_[0] >= 0 && FD_ISSET(wake_pipe_[0], &readfds)) {
416 if (listenSock >= 0) {
417 LOG(ERROR) << "Exit wake set, but not exiting?";
418 } else {
419 VLOG(jdwp) << "Got wake-up signal, bailing out of select";
420 }
421 goto fail;
422 }
423 if (listenSock >= 0 && FD_ISSET(listenSock, &readfds)) {
424 LOG(INFO) << "Ignoring second debugger -- accepting and dropping";
425 union {
426 sockaddr_in addrInet;
427 sockaddr addrPlain;
428 } addr;
429 socklen_t addrlen;
430 int tmpSock;
431 tmpSock = accept(listenSock, &addr.addrPlain, &addrlen);
432 if (tmpSock < 0) {
433 LOG(INFO) << "Weird -- accept failed";
434 } else {
435 close(tmpSock);
436 }
437 }
438 if (clientSock >= 0 && FD_ISSET(clientSock, &readfds)) {
439 readCount = read(clientSock, input_buffer_ + input_count_, sizeof(input_buffer_) - input_count_);
440 if (readCount < 0) {
441 /* read failed */
442 if (errno != EINTR) {
443 goto fail;
444 }
445 VLOG(jdwp) << "+++ EINTR hit";
446 return true;
447 } else if (readCount == 0) {
448 /* EOF hit -- far end went away */
449 VLOG(jdwp) << "+++ peer disconnected";
450 goto fail;
451 } else {
452 break;
453 }
454 }
455 }
456
457 input_count_ += readCount;
458 if (!HaveFullPacket()) {
459 return true; /* still not there yet */
460 }
461 }
462
463 /*
464 * Special-case the initial handshake. For some bizarre reason we're
465 * expected to emulate bad tty settings by echoing the request back
466 * exactly as it was sent. Note the handshake is always initiated by
467 * the debugger, no matter who connects to whom.
468 *
469 * Other than this one case, the protocol [claims to be] stateless.
470 */
471 if (IsAwaitingHandshake()) {
472 if (memcmp(input_buffer_, kMagicHandshake, kMagicHandshakeLen) != 0) {
473 LOG(ERROR) << StringPrintf("ERROR: bad handshake '%.14s'", input_buffer_);
474 goto fail;
475 }
476
477 errno = 0;
478 int cc = TEMP_FAILURE_RETRY(write(clientSock, input_buffer_, kMagicHandshakeLen));
479 if (cc != kMagicHandshakeLen) {
480 PLOG(ERROR) << "Failed writing handshake bytes (" << cc << " of " << kMagicHandshakeLen << ")";
481 goto fail;
482 }
483
484 ConsumeBytes(kMagicHandshakeLen);
485 SetAwaitingHandshake(false);
486 VLOG(jdwp) << "+++ handshake complete";
487 return true;
488 }
489
490 /*
491 * Handle this packet.
492 */
493 return state_->HandlePacket();
494
495 fail:
496 Close();
497 return false;
498 }
499
500 } // namespace JDWP
501
502 } // namespace art
503