@@ -11,22 +11,27 @@
  * Public License, either version 2 or 3, which can be found in the file
  * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
  * file.
  */
 
-#define __NO_EXT_QNX
-
 #include "config.h"
 
+#ifndef _XOPEN_SOURCE_EXTENDED
+# define _XOPEN_SOURCE_EXTENDED
+#endif
+#define __NO_EXT_QNX
+#define _HPUX_ALT_XOPEN_SOCKET_API
+
 #include <assert.h>
 #include <errno.h>
 #include <string.h>
 
 #import "OFStreamSocket.h"
 #import "OFStreamSocket+Private.h"
 #import "OFRunLoop.h"
 #import "OFRunLoop+Private.h"
+#import "OFSocket+Private.h"
 
 #import "OFAcceptFailedException.h"
 #import "OFInitializationFailedException.h"
 #import "OFInvalidArgumentException.h"
 #import "OFListenFailedException.h"
@@ -35,22 +40,20 @@
 #import "OFOutOfRangeException.h"
 #import "OFReadFailedException.h"
 #import "OFSetOptionFailedException.h"
 #import "OFWriteFailedException.h"
 
-#import "socket_helpers.h"
-
 @implementation OFStreamSocket
 @dynamic delegate;
 @synthesize listening = _listening;
 
 + (void)initialize
 {
 	if (self != [OFStreamSocket class])
 		return;
 
-	if (!of_socket_init())
+	if (!OFSocketInit())
 		@throw [OFInitializationFailedException
 		    exceptionWithClass: self];
 }
 
 + (instancetype)socket
@@ -66,11 +69,11 @@
 		if (self.class == [OFStreamSocket class]) {
 			[self doesNotRecognizeSelector: _cmd];
 			abort();
 		}
 
-		_socket = INVALID_SOCKET;
+		_socket = OFInvalidSocketHandle;
 	} @catch (id e) {
 		[self release];
 		@throw e;
 	}
 
@@ -77,59 +80,57 @@
 	return self;
 }
 
 - (void)dealloc
 {
-	if (_socket != INVALID_SOCKET)
+	if (_socket != OFInvalidSocketHandle)
 		[self close];
 
 	[super dealloc];
 }
 
 - (bool)lowlevelIsAtEndOfStream
 {
-	if (_socket == INVALID_SOCKET)
+	if (_socket == OFInvalidSocketHandle)
 		@throw [OFNotOpenException exceptionWithObject: self];
 
 	return _atEndOfStream;
 }
 
-- (size_t)lowlevelReadIntoBuffer: (void *)buffer
-			  length: (size_t)length
+- (size_t)lowlevelReadIntoBuffer: (void *)buffer length: (size_t)length
 {
 	ssize_t ret;
 
-	if (_socket == INVALID_SOCKET)
+	if (_socket == OFInvalidSocketHandle)
 		@throw [OFNotOpenException exceptionWithObject: self];
 
 #ifndef OF_WINDOWS
 	if ((ret = recv(_socket, buffer, length, 0)) < 0)
 		@throw [OFReadFailedException
 		    exceptionWithObject: self
 			requestedLength: length
-				  errNo: of_socket_errno()];
+				  errNo: OFSocketErrNo()];
 #else
 	if (length > INT_MAX)
 		@throw [OFOutOfRangeException exception];
 
 	if ((ret = recv(_socket, buffer, (int)length, 0)) < 0)
 		@throw [OFReadFailedException
 		    exceptionWithObject: self
 			requestedLength: length
-				  errNo: of_socket_errno()];
+				  errNo: OFSocketErrNo()];
 #endif
 
 	if (ret == 0)
 		_atEndOfStream = true;
 
 	return ret;
 }
 
-- (size_t)lowlevelWriteBuffer: (const void *)buffer
-		       length: (size_t)length
+- (size_t)lowlevelWriteBuffer: (const void *)buffer length: (size_t)length
 {
-	if (_socket == INVALID_SOCKET)
+	if (_socket == OFInvalidSocketHandle)
 		@throw [OFNotOpenException exceptionWithObject: self];
 
 #ifndef OF_WINDOWS
 	ssize_t bytesWritten;
 
@@ -139,11 +140,11 @@
 	if ((bytesWritten = send(_socket, (void *)buffer, length, 0)) < 0)
 		@throw [OFWriteFailedException
 		    exceptionWithObject: self
 			requestedLength: length
 			   bytesWritten: 0
-				  errNo: of_socket_errno()];
+				  errNo: OFSocketErrNo()];
 #else
 	int bytesWritten;
 
 	if (length > INT_MAX)
 		@throw [OFOutOfRangeException exception];
@@ -151,29 +152,29 @@
 	if ((bytesWritten = send(_socket, buffer, (int)length, 0)) < 0)
 		@throw [OFWriteFailedException
 		    exceptionWithObject: self
 			requestedLength: length
 			   bytesWritten: 0
-				  errNo: of_socket_errno()];
+				  errNo: OFSocketErrNo()];
 #endif
 
 	return (size_t)bytesWritten;
 }
 
 #if defined(OF_WINDOWS) || defined(OF_AMIGAOS)
 - (void)setCanBlock: (bool)canBlock
 {
 # ifdef OF_WINDOWS
-	u_long v = canBlock;
+	u_long v = !canBlock;
 # else
-	char v = canBlock;
+	char v = !canBlock;
 # endif
 
 	if (ioctlsocket(_socket, FIONBIO, &v) == SOCKET_ERROR)
 		@throw [OFSetOptionFailedException
 		    exceptionWithObject: self
-				  errNo: of_socket_errno()];
+				  errNo: OFSocketErrNo()];
 
 	_canBlock = canBlock;
 }
 #endif
 
@@ -180,11 +181,11 @@
 - (int)fileDescriptorForReading
 {
 #ifndef OF_WINDOWS
 	return _socket;
 #else
-	if (_socket == INVALID_SOCKET)
+	if (_socket == OFInvalidSocketHandle)
 		return -1;
 
 	if (_socket > INT_MAX)
 		@throw [OFOutOfRangeException exception];
 
@@ -195,11 +196,11 @@
 - (int)fileDescriptorForWriting
 {
 #ifndef OF_WINDOWS
 	return _socket;
 #else
-	if (_socket == INVALID_SOCKET)
+	if (_socket == OFInvalidSocketHandle)
 		return -1;
 
 	if (_socket > INT_MAX)
 		@throw [OFOutOfRangeException exception];
 
@@ -213,11 +214,11 @@
 	int errNo;
 	socklen_t len = sizeof(errNo);
 
 	if (getsockopt(_socket, SOL_SOCKET, SO_ERROR, (char *)&errNo,
 	    &len) != 0)
-		return of_socket_errno();
+		return OFSocketErrNo();
 
 	return errNo;
 }
 #endif
 
@@ -226,18 +227,18 @@
 	[self listenWithBacklog: SOMAXCONN];
 }
 
 - (void)listenWithBacklog: (int)backlog
 {
-	if (_socket == INVALID_SOCKET)
+	if (_socket == OFInvalidSocketHandle)
 		@throw [OFNotOpenException exceptionWithObject: self];
 
 	if (listen(_socket, backlog) == -1)
 		@throw [OFListenFailedException
 		    exceptionWithSocket: self
 				backlog: backlog
-				  errNo: of_socket_errno()];
+				  errNo: OFSocketErrNo()];
 
 	_listening = true;
 }
 
 - (instancetype)accept
@@ -254,28 +255,29 @@
 
 #if defined(HAVE_PACCEPT) && defined(SOCK_CLOEXEC)
 	if ((client->_socket = paccept(_socket,
 	    &client->_remoteAddress.sockaddr.sockaddr,
 	    &client->_remoteAddress.length, NULL, SOCK_CLOEXEC)) ==
-	    INVALID_SOCKET)
+	    OFInvalidSocketHandle)
 		@throw [OFAcceptFailedException
 		    exceptionWithSocket: self
-				  errNo: of_socket_errno()];
+				  errNo: OFSocketErrNo()];
 #elif defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
 	if ((client->_socket = accept4(_socket,
 	    &client->_remoteAddress.sockaddr.sockaddr,
-	    &client->_remoteAddress.length, SOCK_CLOEXEC)) == INVALID_SOCKET)
+	    &client->_remoteAddress.length, SOCK_CLOEXEC)) ==
+	    OFInvalidSocketHandle)
 		@throw [OFAcceptFailedException
 		    exceptionWithSocket: self
-				  errNo: of_socket_errno()];
+				  errNo: OFSocketErrNo()];
 #else
 	if ((client->_socket = accept(_socket,
 	    &client->_remoteAddress.sockaddr.sockaddr,
-	    &client->_remoteAddress.length)) == INVALID_SOCKET)
+	    &client->_remoteAddress.length)) == OFInvalidSocketHandle)
 		@throw [OFAcceptFailedException
 		    exceptionWithSocket: self
-				  errNo: of_socket_errno()];
+				  errNo: OFSocketErrNo()];
 
 # if defined(HAVE_FCNTL) && defined(FD_CLOEXEC)
 	if ((flags = fcntl(client->_socket, F_GETFD, 0)) != -1)
 		fcntl(client->_socket, F_SETFD, flags | FD_CLOEXEC);
 # endif
@@ -284,64 +286,62 @@
 	assert(client->_remoteAddress.length <=
 	    (socklen_t)sizeof(client->_remoteAddress.sockaddr));
 
 	switch (client->_remoteAddress.sockaddr.sockaddr.sa_family) {
 	case AF_INET:
-		client->_remoteAddress.family = OF_SOCKET_ADDRESS_FAMILY_IPV4;
+		client->_remoteAddress.family = OFSocketAddressFamilyIPv4;
 		break;
 #ifdef OF_HAVE_IPV6
 	case AF_INET6:
-		client->_remoteAddress.family = OF_SOCKET_ADDRESS_FAMILY_IPV6;
+		client->_remoteAddress.family = OFSocketAddressFamilyIPv6;
 		break;
 #endif
 #ifdef OF_HAVE_IPX
 	case AF_IPX:
-		client->_remoteAddress.family = OF_SOCKET_ADDRESS_FAMILY_IPX;
+		client->_remoteAddress.family = OFSocketAddressFamilyIPX;
 		break;
 #endif
 	default:
-		client->_remoteAddress.family =
-		    OF_SOCKET_ADDRESS_FAMILY_UNKNOWN;
+		client->_remoteAddress.family = OFSocketAddressFamilyUnknown;
 		break;
 	}
 
 	return client;
 }
 
 - (void)asyncAccept
 {
-	[self asyncAcceptWithRunLoopMode: of_run_loop_mode_default];
+	[self asyncAcceptWithRunLoopMode: OFDefaultRunLoopMode];
 }
 
-- (void)asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
+- (void)asyncAcceptWithRunLoopMode: (OFRunLoopMode)runLoopMode
 {
 	[OFRunLoop of_addAsyncAcceptForSocket: self
 					 mode: runLoopMode
 					block: NULL
 				     delegate: _delegate];
 }
 
 #ifdef OF_HAVE_BLOCKS
-- (void)asyncAcceptWithBlock: (of_stream_socket_async_accept_block_t)block
+- (void)asyncAcceptWithBlock: (OFStreamSocketAsyncAcceptBlock)block
 {
-	[self asyncAcceptWithRunLoopMode: of_run_loop_mode_default
-				   block: block];
+	[self asyncAcceptWithRunLoopMode: OFDefaultRunLoopMode block: block];
 }
 
-- (void)asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
-			     block: (of_stream_socket_async_accept_block_t)block
+- (void)asyncAcceptWithRunLoopMode: (OFRunLoopMode)runLoopMode
+			     block: (OFStreamSocketAsyncAcceptBlock)block
 {
 	[OFRunLoop of_addAsyncAcceptForSocket: self
 					 mode: runLoopMode
 					block: block
 				     delegate: nil];
 }
 #endif
 
-- (const of_socket_address_t *)remoteAddress
+- (const OFSocketAddress *)remoteAddress
 {
-	if (_socket == INVALID_SOCKET)
+	if (_socket == OFInvalidSocketHandle)
 		@throw [OFNotOpenException exceptionWithObject: self];
 
 	if (_remoteAddress.length == 0)
 		@throw [OFInvalidArgumentException exception];
 
@@ -351,19 +351,19 @@
 	return &_remoteAddress;
 }
 
 - (void)close
 {
-	if (_socket == INVALID_SOCKET)
+	if (_socket == OFInvalidSocketHandle)
 		@throw [OFNotOpenException exceptionWithObject: self];
 
 	_listening = false;
 	memset(&_remoteAddress, 0, sizeof(_remoteAddress));
 
 	closesocket(_socket);
-	_socket = INVALID_SOCKET;
+	_socket = OFInvalidSocketHandle;
 
 	_atEndOfStream = false;
 
 	[super close];
 }
 @end