- Fix timed TCP connects for high POSIX file descriptors

Use poll() for POSIX TcpSocket timed connects instead of select().
select() cannot safely handle descriptor values >= FD_SETSIZE, so a
process with many open sockets/resources could fail new HTTPS requests
even when only one socket was being waited on. This showed up in the
HTML compat module when loading request-heavy pages such as old Reddit.

Keep the Windows path on select(), since Winsock does not use nfds as a
POSIX descriptor limit and this code only waits on one socket.

Also initialize HttpConnection::mIsKeepAlive in the TcpSocket-taking
constructor, matching the default constructor and avoiding undefined
connection lifetime state.

Add a regression test that reserves file descriptors past FD_SETSIZE and
verifies a timed localhost TcpSocket connect still succeeds.

- Treat drawable ref "none" as clearing the layer drawable instead of
trying to load it as a drawable/image reference.

- Round the scroll view inner width up before deciding horizontal
scrollbar visibility, avoiding fractional pixel overflow from creating
a bogus horizontal scrollbar.

Author: SpartanJ

src/eepp/network/http.cpp

@@ -1059,8 +1059,7 @@ Http::Response Http::downloadRequest( const Http::Request& request, IOStream& wr
 										contentLength = 0;
 								}
 
-								if ( mConnection &&
-									 received.getField( "connection" ) == "close" ) {
+								if ( mConnection && received.getField( "connection" ) == "close" ) {
 									mConnection->setConnected( false );
 									mConnection->setTunneled( false );
 								}
@@ -1618,7 +1617,11 @@ Http::HttpConnection::HttpConnection() :
 	mIsKeepAlive( false ) {}
 
 Http::HttpConnection::HttpConnection( TcpSocket* socket ) :
-	mSocket( socket ), mIsConnected( false ), mIsTunneled( false ), mIsSSL( false ) {}
+	mSocket( socket ),
+	mIsConnected( false ),
+	mIsTunneled( false ),
+	mIsSSL( false ),
+	mIsKeepAlive( false ) {}
 
 Http::HttpConnection::~HttpConnection() {
 	eeSAFE_DELETE( mSocket );

src/eepp/network/tcpsocket.cpp

@@ -5,10 +5,15 @@
 #include <eepp/network/tcpsocket.hpp>
 #include <eepp/system/clock.hpp>
 #include <eepp/system/log.hpp>
-
+#include <limits>
+
 #if EE_PLATFORM == EE_PLATFORM_HAIKU
 #include <sys/select.h>
 #endif
+
+#if EE_PLATFORM != EE_PLATFORM_WIN
+#include <poll.h>
+#endif
 
 #ifdef _MSC_VER
 #pragma warning( disable \
@@ -127,30 +132,37 @@ Socket::Status TcpSocket::connect( const IpAddress& remoteAddress, unsigned shor
 		if ( !blocking )
 			return status;
 
-		// Otherwise, wait until something happens to our socket (success, timeout or error)
-		if ( status == Socket::NotReady ) {
-			#if EE_PLATFORM != EE_PLATFORM_WIN
-			if ( getHandle() >= FD_SETSIZE ) {
-				// The socket FD is too large for select().
-				// You cannot safely use FD_SET.
-				setBlocking( true );
-				return Error;
-			}
-			#endif
-
-			// Setup the selector
-			fd_set selector;
-			FD_ZERO( &selector );
-			FD_SET( getHandle(), &selector );
+		// Otherwise, wait until something happens to our socket (success, timeout or error)
+		if ( status == Socket::NotReady ) {
+#if EE_PLATFORM == EE_PLATFORM_WIN
+			// Setup the selector
+			fd_set selector;
+			FD_ZERO( &selector );
+			FD_SET( getHandle(), &selector );
 
 			// Setup the timeout
 			timeval time;
 			time.tv_sec = static_cast<long>( timeout.asMicroseconds() / 1000000 );
 			time.tv_usec = static_cast<long>( timeout.asMicroseconds() % 1000000 );
 
-			// Wait for something to write on our socket (which means that the connection request
-			// has returned)
-			if ( select( static_cast<int>( getHandle() + 1 ), NULL, &selector, NULL, &time ) > 0 ) {
+			// Wait for something to write on our socket (which means that the connection request
+			// has returned)
+			if ( select( static_cast<int>( getHandle() + 1 ), NULL, &selector, NULL, &time ) > 0 ) {
+#else
+			pollfd descriptor;
+			descriptor.fd = getHandle();
+			descriptor.events = POLLOUT;
+			descriptor.revents = 0;
+
+			Int64 timeoutMilliseconds = ( timeout.asMicroseconds() + 999 ) / 1000;
+			int pollTimeout = timeoutMilliseconds > std::numeric_limits<int>::max()
+								  ? std::numeric_limits<int>::max()
+								  : static_cast<int>( timeoutMilliseconds );
+
+			// Wait for something to write on our socket (which means that the connection request
+			// has returned). poll() is not limited by FD_SETSIZE, unlike select().
+			if ( poll( &descriptor, 1, pollTimeout ) > 0 ) {
+#endif
 				// At this point the connection may have been either accepted or refused.
 				// To know whether it's a success or a failure, we must check the address of the
 				// connected peer

src/eepp/ui/uinodedrawable.cpp

@@ -654,6 +654,11 @@ void UINodeDrawable::LayerDrawable::setDrawable( Drawable* drawable, const bool&
 }
 
 void UINodeDrawable::LayerDrawable::setDrawable( const std::string& drawableRef ) {
+	if ( drawableRef == "none" ) {
+		setDrawable( nullptr, false );
+		return;
+	}
+
 	if ( loadRemoteDrawable( drawableRef ) ) {
 		mDrawableRef = drawableRef;
 		return;

src/eepp/ui/uiscrollview.cpp

@@ -219,9 +219,10 @@ void UIScrollView::containerUpdate() {
 		mHScroll->setVisible( false );
 		mHScroll->setEnabled( false );
 	} else {
-		bool visible = mScrollView->getPixelsSize().getWidth() > getPixelsSize().getWidth() -
-																	 getPixelsPadding().Left -
-																	 getPixelsPadding().Right;
+		auto scrollViewWidth = mScrollView->getPixelsSize().getWidth();
+		auto meInnerWidth = std::ceil( getPixelsSize().getWidth() - getPixelsPadding().Left -
+									   getPixelsPadding().Right );
+		auto visible = scrollViewWidth > meInnerWidth;
 
 		mHScroll->setVisible( visible );
 		mHScroll->setEnabled( visible );

src/tests/unit_tests/http.cpp

@@ -2,14 +2,36 @@
 
 #include <atomic>
 #include <thread>
+#include <vector>
 
 #include <eepp/network/http.hpp>
 #include <eepp/network/tcplistener.hpp>
 #include <eepp/network/tcpsocket.hpp>
 
+#if EE_PLATFORM != EE_PLATFORM_WIN
+#include <fcntl.h>
+#include <sys/select.h>
+#include <unistd.h>
+#endif
+
 using namespace EE;
 using namespace EE::Network;
 
+#if EE_PLATFORM != EE_PLATFORM_WIN
+namespace {
+
+struct FileDescriptorGuard {
+	~FileDescriptorGuard() {
+		for ( int fd : fds )
+			::close( fd );
+	}
+
+	std::vector<int> fds;
+};
+
+} // namespace
+#endif
+
 UTEST( Http, responseHeaderLineLargerThanReceiveBuffer ) {
 	TcpListener listener;
 	ASSERT_EQ( listener.listen( Socket::AnyPort, IpAddress::LocalHost ), Socket::Done );
@@ -55,3 +77,36 @@ UTEST( Http, responseHeaderLineLargerThanReceiveBuffer ) {
 	EXPECT_EQ( response.getStatus(), Http::Response::Ok );
 	EXPECT_TRUE( response.getBody() == "hello" );
 }
+
+#if EE_PLATFORM != EE_PLATFORM_WIN
+UTEST( Http, tcpConnectTimeoutHandlesFdAboveFdSetSize ) {
+	TcpListener listener;
+	ASSERT_EQ( listener.listen( Socket::AnyPort, IpAddress::LocalHost ), Socket::Done );
+
+	FileDescriptorGuard openFiles;
+	openFiles.fds.reserve( FD_SETSIZE + 16 );
+	while ( openFiles.fds.empty() || openFiles.fds.back() < FD_SETSIZE ) {
+		int fd = ::open( "/dev/null", O_RDONLY );
+		if ( fd < 0 )
+			break;
+		openFiles.fds.push_back( fd );
+	}
+
+	if ( openFiles.fds.empty() || openFiles.fds.back() < FD_SETSIZE )
+		UTEST_SKIP( "could not reserve enough file descriptors" );
+
+	TcpSocket client;
+	Socket::Status status =
+		client.connect( IpAddress::LocalHost, listener.getLocalPort(), Seconds( 5 ) );
+	EXPECT_EQ( status, Socket::Done );
+
+	if ( status == Socket::Done ) {
+		TcpSocket accepted;
+		EXPECT_EQ( listener.accept( accepted ), Socket::Done );
+		accepted.disconnect();
+	}
+
+	client.disconnect();
+	listener.close();
+}
+#endif