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