int socketCreatePair(int* fd1, int* fd2) { #ifndef _WIN32 int fds[2]; int ret = ::socketpair(AF_UNIX, SOCK_STREAM, 0, fds); if (!ret) { socketSetNonBlocking(fds[0]); socketSetNonBlocking(fds[1]); *fd1 = fds[0]; *fd2 = fds[1]; } else { DPLOG(ERROR) << "Could not create socket pair\n"; } return ret; #else /* _WIN32 */ /* on Windows, select() only works with network sockets, which * means we absolutely cannot use Win32 PIPEs to implement * socket pairs with the current event loop implementation. * We're going to do like Cygwin: create a random pair * of localhost TCP sockets and connect them together */ /* first, create the 'server' socket. * a port number of 0 means 'any port between 1024 and 5000. * see Winsock bind() documentation for details */ ScopedSocket s0(socketTcpLoopbackServer(0)); if (s0.get() < 0) { return -1; } // IMPORTANT: Keep the s0 socket in blocking mode, or the accept() // below may fail with WSAEWOULDBLOCK randomly. /* now connect a client socket to it, we first need to * extract the server socket's port number */ int port = socketGetPort(s0.get()); ScopedSocket s2(socketTcpLoopbackClient(port)); if (!s2.valid()) { return -1; } /* we need to accept the connection on the server socket * this will create the second socket for the pair */ ScopedSocket s1(socketAccept(s0.get())); if (!s1.valid()) { DPLOG(ERROR) << "Could not accept connection from server socket\n"; return -1; } socketSetNonBlocking(s1.get()); *fd1 = s1.release(); *fd2 = s2.release(); return 0; #endif /* _WIN32 */ }
bool ObjectWatcher::StartWatching(HANDLE object, Delegate* delegate) { CHECK(delegate); if (wait_object_) { NOTREACHED() << "Already watching an object"; return false; } // Since our job is to just notice when an object is signaled and report the // result back to this thread, we can just run on a Windows wait thread. DWORD wait_flags = WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE; // DoneWaiting can be synchronously called from RegisterWaitForSingleObject, // so set up all state now. callback_ = base::Bind(&ObjectWatcher::Signal, weak_factory_.GetWeakPtr(), delegate); object_ = object; origin_loop_ = MessageLoop::current(); if (!RegisterWaitForSingleObject(&wait_object_, object, DoneWaiting, this, INFINITE, wait_flags)) { DPLOG(FATAL) << "RegisterWaitForSingleObject failed"; object_ = NULL; wait_object_ = NULL; return false; } // We need to know if the current message loop is going away so we can // prevent the wait thread from trying to access a dead message loop. MessageLoop::current()->AddDestructionObserver(this); return true; }
void PLogTest() { PLOG(ERROR) << "Couldn't do foo"; DPLOG(ERROR) << "Couldn't do foo"; PLOG_IF(ERROR, 1) << "Couldn't do foo"; DPLOG_IF(ERROR, 0) << "Couldn't do foo"; PCHECK(1) << "Couldn't do foo"; DPCHECK(1) << "Couldn't do foo"; }
int socketGetPort(int socket) { SockAddressStorage addr; socklen_t addrLen = sizeof(addr); if (getsockname(socket, &addr.generic, &addrLen) < 0) { DPLOG(ERROR) << "Could not get socket name!\n"; return -1; } return addr.getPort(); }
int socketTcpLoopbackClient(int port) { ScopedSocket s(socketCreateTcp()); if (s.get() < 0) { DPLOG(ERROR) << "Could not create TCP socket\n"; return -1; } SockAddressStorage addr; addr.initLoopback(port); if (::connect(s.get(), &addr.generic, sizeof(addr.inet)) < 0) { DPLOG(ERROR) << "Could not connect to TCP loopback port " << port << "\n"; return -1; } return s.release(); }
int socketTcpLoopbackServer(int port) { ScopedSocket s(socketCreateTcp()); if (s.get() < 0) { DPLOG(ERROR) << "Could not create TCP socket\n"; return -1; } socketSetXReuseAddr(s.get()); SockAddressStorage addr; addr.initLoopback(port); if (socketTcpBindAndListen(s.get(), &addr) < 0) { DPLOG(ERROR) << "Could not bind to TCP loopback port " << port << "\n"; return -1; } return s.release(); }
Win32ErrorLogMessage::~Win32ErrorLogMessage() { const int error_message_buffer_size = 256; char msgbuf[error_message_buffer_size]; DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS; HMODULE hmod; if(module_) { hmod = GetModuleHandleA(module_); if(hmod) { flags |= FORMAT_MESSAGE_FROM_HMODULE; } else { // 导致Win32ErrorLogMessage嵌套, 由于module_是NULL不会再次进入这里, // 所以不会死循环. DPLOG(WARNING) << "Couldn't open module " << module_ << " for error message query"; } } else { hmod = NULL; } DWORD len = FormatMessageA(flags, hmod, err_, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), msgbuf, sizeof(msgbuf)/sizeof(msgbuf[0]), NULL); if(len) { while((len>0) && isspace(static_cast<unsigned char>(msgbuf[len-1]))) { msgbuf[--len] = 0; } stream() << ": " << msgbuf; } else { stream() << ": Error " << GetLastError() << " while retrieving error " << err_; } }
bool ObjectWatcher::StopWatching() { if (!wait_object_) return false; // Make sure ObjectWatcher is used in a single-threaded fashion. DCHECK_EQ(origin_loop_, MessageLoop::current()); // Blocking call to cancel the wait. Any callbacks already in progress will // finish before we return from this call. if (!UnregisterWaitEx(wait_object_, INVALID_HANDLE_VALUE)) { DPLOG(FATAL) << "UnregisterWaitEx failed"; return false; } weak_factory_.InvalidateWeakPtrs(); object_ = NULL; wait_object_ = NULL; MessageLoop::current()->RemoveDestructionObserver(this); return true; }