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