RNBSocket.cpp revision 7d96ecc2fe57d7d7289bed7fc633154a310979c7
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 33rnb_err_t 34RNBSocket::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 123rnb_err_t 124RNBSocket::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 172rnb_err_t 173RNBSocket::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 185rnb_err_t 186RNBSocket::ConnectToService() 187{ 188 DNBLog("Connecting to com.apple.%s service...", DEBUGSERVER_PROGRAM_NAME); 189 // Disconnect from any previous connections 190 Disconnect(false); 191 if (::secure_lockdown_checkin (&m_ld_conn, NULL, NULL) != kLDESuccess) 192 { 193 DNBLogThreadedIf(LOG_RNB_COMM, "::secure_lockdown_checkin(&m_fd, NULL, NULL) failed"); 194 m_fd = -1; 195 return rnb_not_connected; 196 } 197 m_fd = ::lockdown_get_socket (m_ld_conn); 198 if (m_fd == -1) 199 { 200 DNBLogThreadedIf(LOG_RNB_COMM, "::lockdown_get_socket() failed"); 201 return rnb_not_connected; 202 } 203 m_fd_from_lockdown = true; 204 return rnb_success; 205} 206#endif 207 208rnb_err_t 209RNBSocket::OpenFile (const char *path) 210{ 211 DNBError err; 212 m_fd = open (path, O_RDWR); 213 if (m_fd == -1) 214 { 215 err.SetError(errno, DNBError::POSIX); 216 err.LogThreaded ("can't open file '%s'", path); 217 return rnb_not_connected; 218 } 219 else 220 { 221 struct termios stdin_termios; 222 223 if (::tcgetattr (m_fd, &stdin_termios) == 0) 224 { 225 stdin_termios.c_lflag &= ~ECHO; // Turn off echoing 226 stdin_termios.c_lflag &= ~ICANON; // Get one char at a time 227 ::tcsetattr (m_fd, TCSANOW, &stdin_termios); 228 } 229 } 230 return rnb_success; 231} 232 233int 234RNBSocket::SetSocketOption(int fd, int level, int option_name, int option_value) 235{ 236 return ::setsockopt(fd, level, option_name, &option_value, sizeof(option_value)); 237} 238 239rnb_err_t 240RNBSocket::Disconnect (bool save_errno) 241{ 242#ifdef WITH_LOCKDOWN 243 if (m_fd_from_lockdown) 244 { 245 m_fd_from_lockdown = false; 246 m_fd = -1; 247 if (lockdown_deactivate (m_ld_conn) == 0) 248 return rnb_success; 249 else 250 return rnb_err; 251 } 252#endif 253 return ClosePort (m_fd, save_errno); 254} 255 256 257rnb_err_t 258RNBSocket::Read (std::string &p) 259{ 260 char buf[1024]; 261 p.clear(); 262 263 // Note that BUF is on the stack so we must be careful to keep any 264 // writes to BUF from overflowing or we'll have security issues. 265 266 if (m_fd == -1) 267 return rnb_err; 268 269 //DNBLogThreadedIf(LOG_RNB_COMM, "%8u RNBSocket::%s calling read()", (uint32_t)m_timer.ElapsedMicroSeconds(true), __FUNCTION__); 270 DNBError err; 271 int bytesread = read (m_fd, buf, sizeof (buf)); 272 if (bytesread <= 0) 273 err.SetError(errno, DNBError::POSIX); 274 else 275 p.append(buf, bytesread); 276 277 if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM)) 278 err.LogThreaded("::read ( %i, %p, %llu ) => %i", m_fd, buf, sizeof (buf), (uint64_t)bytesread); 279 280 // Our port went away - we have to mark this so IsConnected will return the truth. 281 if (bytesread == 0) 282 { 283 m_fd = -1; 284 return rnb_not_connected; 285 } 286 else if (bytesread == -1) 287 { 288 m_fd = -1; 289 return rnb_err; 290 } 291 // Strip spaces from the end of the buffer 292 while (!p.empty() && isspace (p[p.size() - 1])) 293 p.erase (p.size () - 1); 294 295 // Most data in the debugserver packets valid printable characters... 296 DNBLogThreadedIf(LOG_RNB_COMM, "read: %s", p.c_str()); 297 return rnb_success; 298} 299 300rnb_err_t 301RNBSocket::Write (const void *buffer, size_t length) 302{ 303 if (m_fd == -1) 304 return rnb_err; 305 306 DNBError err; 307 int bytessent = write (m_fd, buffer, length); 308 if (bytessent < 0) 309 err.SetError(errno, DNBError::POSIX); 310 311 if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM)) 312 err.LogThreaded("::write ( socket = %i, buffer = %p, length = %llu) => %i", m_fd, buffer, length, (uint64_t)bytessent); 313 314 if (bytessent < 0) 315 return rnb_err; 316 317 if (bytessent != length) 318 return rnb_err; 319 320 DNBLogThreadedIf(LOG_RNB_PACKETS, "putpkt: %*s", (int)length, (char *)buffer); // All data is string based in debugserver, so this is safe 321 DNBLogThreadedIf(LOG_RNB_COMM, "sent: %*s", (int)length, (char *)buffer); 322 323 return rnb_success; 324} 325 326 327rnb_err_t 328RNBSocket::ClosePort (int& fd, bool save_errno) 329{ 330 int close_err = 0; 331 if (fd > 0) 332 { 333 errno = 0; 334 close_err = close (fd); 335 fd = -1; 336 } 337 return close_err != 0 ? rnb_err : rnb_success; 338} 339 340 341