1 //===-- RNBSocket.cpp -------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  Created by Greg Clayton on 12/12/07.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "RNBSocket.h"
15 #include <arpa/inet.h>
16 #include <errno.h>
17 #include <fcntl.h>
18 #include <netdb.h>
19 #include <netinet/in.h>
20 #include <netinet/tcp.h>
21 #include <termios.h>
22 #include "DNBLog.h"
23 #include "DNBError.h"
24 
25 #ifdef WITH_LOCKDOWN
26 #include "lockdown.h"
27 #endif
28 
29 /* Once we have a RNBSocket object with a port # specified,
30    this function is called to wait for an incoming connection.
31    This function blocks while waiting for that connection.  */
32 
33 rnb_err_t
34 RNBSocket::Listen (in_port_t port, PortBoundCallback callback, const void *callback_baton)
35 {
36     //DNBLogThreadedIf(LOG_RNB_COMM, "%8u RNBSocket::%s called", (uint32_t)m_timer.ElapsedMicroSeconds(true), __FUNCTION__);
37     // Disconnect without saving errno
38     Disconnect (false);
39 
40     DNBError err;
41     int listen_fd = ::socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
42     if (listen_fd == -1)
43         err.SetError(errno, DNBError::POSIX);
44 
45     if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
46         err.LogThreaded("::socket ( domain = AF_INET, type = SOCK_STREAM, protocol = IPPROTO_TCP ) => socket = %i", listen_fd);
47 
48     if (err.Fail())
49         return rnb_err;
50 
51     // enable local address reuse
52     SetSocketOption (listen_fd, SOL_SOCKET, SO_REUSEADDR, 1);
53 
54     struct sockaddr_in sa;
55     ::memset (&sa, 0, sizeof sa);
56     sa.sin_len = sizeof sa;
57     sa.sin_family = AF_INET;
58     sa.sin_port = htons (port);
59     sa.sin_addr.s_addr = htonl (INADDR_ANY);
60 
61     int error = ::bind (listen_fd, (struct sockaddr *) &sa, sizeof(sa));
62     if (error == -1)
63         err.SetError(errno, DNBError::POSIX);
64 
65     if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
66         err.LogThreaded("::bind ( socket = %i, (struct sockaddr *) &sa, sizeof(sa)) )", listen_fd);
67 
68     if (err.Fail())
69     {
70         ClosePort (listen_fd, false);
71         return rnb_err;
72     }
73 
74     if (callback && port == 0)
75     {
76         // We were asked to listen on port zero which means we
77         // must now read the actual port that was given to us
78         // as port zero is a special code for "find an open port
79         // for me".
80         socklen_t sa_len = sizeof (sa);
81         if (getsockname(listen_fd, (struct sockaddr *)&sa, &sa_len) == 0)
82         {
83             port = ntohs (sa.sin_port);
84             callback (callback_baton, port);
85         }
86     }
87 
88     error = ::listen (listen_fd, 1);
89     if (error == -1)
90         err.SetError(errno, DNBError::POSIX);
91 
92     if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
93         err.LogThreaded("::listen ( socket = %i, backlog = 1 )", listen_fd);
94 
95     if (err.Fail())
96     {
97         ClosePort (listen_fd, false);
98         return rnb_err;
99     }
100 
101     m_fd = ::accept (listen_fd, NULL, 0);
102     if (m_fd == -1)
103         err.SetError(errno, DNBError::POSIX);
104 
105     if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
106         err.LogThreaded("::accept ( socket = %i, address = NULL, address_len = 0 )", listen_fd);
107 
108     ClosePort (listen_fd, false);
109 
110     if (err.Fail())
111     {
112         return rnb_err;
113     }
114     else
115     {
116         // Keep our TCP packets coming without any delays.
117         SetSocketOption (m_fd, IPPROTO_TCP, TCP_NODELAY, 1);
118     }
119 
120     return rnb_success;
121 }
122 
123 rnb_err_t
124 RNBSocket::Connect (const char *host, uint16_t port)
125 {
126     Disconnect (false);
127 
128     // Create the socket
129     m_fd = ::socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
130     if (m_fd == -1)
131         return rnb_err;
132 
133     // Enable local address reuse
134     SetSocketOption (m_fd, SOL_SOCKET, SO_REUSEADDR, 1);
135 
136     struct sockaddr_in sa;
137     ::memset (&sa, 0, sizeof (sa));
138     sa.sin_family = AF_INET;
139     sa.sin_port = htons (port);
140 
141     if (host == NULL)
142         host = "localhost";
143 
144     int inet_pton_result = ::inet_pton (AF_INET, host, &sa.sin_addr);
145 
146     if (inet_pton_result <= 0)
147     {
148         struct hostent *host_entry = gethostbyname (host);
149         if (host_entry)
150         {
151             std::string host_str (::inet_ntoa (*(struct in_addr *)*host_entry->h_addr_list));
152             inet_pton_result = ::inet_pton (AF_INET, host_str.c_str(), &sa.sin_addr);
153             if (inet_pton_result <= 0)
154             {
155                 Disconnect (false);
156                 return rnb_err;
157             }
158         }
159     }
160 
161     if (-1 == ::connect (m_fd, (const struct sockaddr *)&sa, sizeof(sa)))
162     {
163         Disconnect (false);
164         return rnb_err;
165     }
166 
167     // Keep our TCP packets coming without any delays.
168     SetSocketOption (m_fd, IPPROTO_TCP, TCP_NODELAY, 1);
169     return rnb_success;
170 }
171 
172 rnb_err_t
173 RNBSocket::useFD(int fd)
174 {
175        if (fd < 0) {
176                DNBLogThreadedIf(LOG_RNB_COMM, "Bad file descriptor passed in.");
177                return rnb_err;
178        }
179 
180        m_fd = fd;
181        return rnb_success;
182 }
183 
184 #ifdef WITH_LOCKDOWN
185 rnb_err_t
186 RNBSocket::ConnectToService()
187 {
188     DNBLog("Connecting to com.apple.%s service...", DEBUGSERVER_PROGRAM_NAME);
189     // Disconnect from any previous connections
190     Disconnect(false);
191 
192     SSLContextRef ssl_ctx;
193     bzero(&ssl_ctx, sizeof(ssl_ctx));
194     if (::lockdown_secure_checkin (&m_fd, &ssl_ctx, NULL, NULL) != kLDESuccess)
195     {
196         DNBLogThreadedIf(LOG_RNB_COMM, "::lockdown_secure_checkin(&m_fd, NULL, NULL, NULL) failed");
197         m_fd = -1;
198         return rnb_not_connected;
199     }
200     m_fd_from_lockdown = true;
201     return rnb_success;
202 }
203 #endif
204 
205 rnb_err_t
206 RNBSocket::OpenFile (const char *path)
207 {
208     DNBError err;
209     m_fd = open (path, O_RDWR);
210     if (m_fd == -1)
211     {
212         err.SetError(errno, DNBError::POSIX);
213         err.LogThreaded ("can't open file '%s'", path);
214         return rnb_not_connected;
215     }
216     else
217     {
218         struct termios stdin_termios;
219 
220         if (::tcgetattr (m_fd, &stdin_termios) == 0)
221         {
222             stdin_termios.c_lflag &= ~ECHO;     // Turn off echoing
223             stdin_termios.c_lflag &= ~ICANON;   // Get one char at a time
224             ::tcsetattr (m_fd, TCSANOW, &stdin_termios);
225         }
226     }
227     return rnb_success;
228 }
229 
230 int
231 RNBSocket::SetSocketOption(int fd, int level, int option_name, int option_value)
232 {
233     return ::setsockopt(fd, level, option_name, &option_value, sizeof(option_value));
234 }
235 
236 rnb_err_t
237 RNBSocket::Disconnect (bool save_errno)
238 {
239 #ifdef WITH_LOCKDOWN
240     if (m_fd_from_lockdown)
241         m_fd_from_lockdown = false;
242 #endif
243     return ClosePort (m_fd, save_errno);
244 }
245 
246 
247 rnb_err_t
248 RNBSocket::Read (std::string &p)
249 {
250     char buf[1024];
251     p.clear();
252 
253     // Note that BUF is on the stack so we must be careful to keep any
254     // writes to BUF from overflowing or we'll have security issues.
255 
256     if (m_fd == -1)
257         return rnb_err;
258 
259     //DNBLogThreadedIf(LOG_RNB_COMM, "%8u RNBSocket::%s calling read()", (uint32_t)m_timer.ElapsedMicroSeconds(true), __FUNCTION__);
260     DNBError err;
261     int bytesread = read (m_fd, buf, sizeof (buf));
262     if (bytesread <= 0)
263         err.SetError(errno, DNBError::POSIX);
264     else
265         p.append(buf, bytesread);
266 
267     if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
268         err.LogThreaded("::read ( %i, %p, %llu ) => %i", m_fd, buf, sizeof (buf), (uint64_t)bytesread);
269 
270     // Our port went away - we have to mark this so IsConnected will return the truth.
271     if (bytesread == 0)
272     {
273         m_fd = -1;
274         return rnb_not_connected;
275     }
276     else if (bytesread == -1)
277     {
278         m_fd = -1;
279         return rnb_err;
280     }
281     // Strip spaces from the end of the buffer
282     while (!p.empty() && isspace (p[p.size() - 1]))
283         p.erase (p.size () - 1);
284 
285     // Most data in the debugserver packets valid printable characters...
286     DNBLogThreadedIf(LOG_RNB_COMM, "read: %s", p.c_str());
287     return rnb_success;
288 }
289 
290 rnb_err_t
291 RNBSocket::Write (const void *buffer, size_t length)
292 {
293     if (m_fd == -1)
294         return rnb_err;
295 
296     DNBError err;
297     int bytessent = write (m_fd, buffer, length);
298     if (bytessent < 0)
299         err.SetError(errno, DNBError::POSIX);
300 
301     if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
302         err.LogThreaded("::write ( socket = %i, buffer = %p, length = %llu) => %i", m_fd, buffer, length, (uint64_t)bytessent);
303 
304     if (bytessent < 0)
305         return rnb_err;
306 
307     if (bytessent != length)
308         return rnb_err;
309 
310     DNBLogThreadedIf(LOG_RNB_PACKETS, "putpkt: %*s", (int)length, (char *)buffer);   // All data is string based in debugserver, so this is safe
311     DNBLogThreadedIf(LOG_RNB_COMM, "sent: %*s", (int)length, (char *)buffer);
312 
313     return rnb_success;
314 }
315 
316 
317 rnb_err_t
318 RNBSocket::ClosePort (int& fd, bool save_errno)
319 {
320     int close_err = 0;
321     if (fd > 0)
322     {
323         errno = 0;
324         close_err = close (fd);
325         fd = -1;
326     }
327     return close_err != 0 ? rnb_err : rnb_success;
328 }
329 
330 
331