#import "common.h"

#define EXPOSE_NSPort_IVARS 1

#define EXPOSE_NSSocketPort_IVARS 1

#import "GNUstepBase/GSLock.h"

#import "Foundation/NSArray.h"

#import "Foundation/NSNotification.h"

#import "Foundation/NSNotificationQueue.h"

#import "Foundation/NSException.h"

#import "Foundation/NSRunLoop.h"

#import "Foundation/NSByteOrder.h"

#import "Foundation/NSData.h"

#import "Foundation/NSDate.h"

#import "Foundation/NSHost.h"

#import "Foundation/NSMapTable.h"

#import "Foundation/NSPortMessage.h"

#import "Foundation/NSPortNameServer.h"

#import "Foundation/NSLock.h"

#import "Foundation/NSHost.h"

#import "Foundation/NSThread.h"

#import "Foundation/NSConnection.h"

#import "GSPortPrivate.h"

#import "GSPrivate.h"

#import "GSNetwork.h"

#include <stdio.h>

#ifdef _WIN32

#define close closesocket

#define OPTLEN int

#else

#define OPTLEN socklen_t

#include <sys/param.h> /* for MAXHOSTNAMELEN */

#include <sys/types.h>

#include <netinet/in.h>

#include <arpa/inet.h> /* for inet_ntoa() */

#endif /* !_WIN32 */

#include <ctype.h> /* for strchr() */

#if defined(HAVE_SYS_FCNTL_H)

# include <sys/fcntl.h>

#elif defined(HAVE_FCNTL_H)

# include <fcntl.h>

#endif

#ifdef HAVE_SYS_TIME_H

# include <sys/time.h>

#endif

#ifdef _WIN32

#include <winsock2.h>

#include <wininet.h>

#include <process.h>

#else

#include <sys/resource.h>

#include <netdb.h>

#include <sys/socket.h>

#if defined(HAVE_SYS_FILE_H)

# include <sys/file.h>

#endif

#if defined(__POSIX_SOURCE)\

|| defined(__EXT_POSIX1_198808)\

|| defined(O_NONBLOCK)

#define NBLK_OPT O_NONBLOCK

#else

#define NBLK_OPT FNDELAY

#endif

#include <netinet/in.h>

#include <net/if.h>

#if !defined(SIOCGIFCONF) || defined(__CYGWIN__)

#include <sys/ioctl.h>

#ifndef SIOCGIFCONF

#include <sys/sockio.h>

#endif

#endif

#if defined(__svr4__)

# if defined(HAVE_SYS_STROPTS_H)

# include <sys/stropts.h>

# endif

#endif

#define SOCKET int

#define SOCKET_ERROR -1

#define INVALID_SOCKET -1

#endif /* !_WIN32 */

static uint32_t maxDataLength = 32 * 1024 * 1024;

#if 0

#define M_LOCK(X) {NSDebugMLLog(@"GSTcpHandleLock",@"lock %@ in %@",X,[NSThread currentThread]); [X lock];}

#define M_UNLOCK(X) {NSDebugMLLog(@"GSTcpHandleLock",@"unlock %@ in %@",X,[NSThread currentThread]); [X unlock];}

#else

#define M_LOCK(X) {[X lock];}

#define M_UNLOCK(X) {[X unlock];}

#endif

#define GS_CONNECTION_MSG 0

#define NETBLOCK 8192

#ifndef INADDR_NONE

#define INADDR_NONE -1

#endif



typedef enum {

GSP_NONE,

GSP_PORT, /* Simple port item. */

GSP_DATA, /* Simple data item. */

GSP_HEAD /* Port message header + initial data. */

} GSPortItemType;

typedef struct {

uint32_t type; /* A GSPortItemType as a 4-byte number. */

uint32_t length; /* The length of the item (excluding header). */

} GSPortItemHeader;

typedef struct {

uint32_t mId; /* The ID for the message starting with this. */

uint32_t nItems; /* Number of items (including this one). */

} GSPortMsgHeader;

typedef struct {

uint16_t num; /* TCP port num */

char addr[0]; /* host address */

} GSPortInfo;

typedef enum {

GS_H_UNCON = 0, // Currently idle and unconnected.

GS_H_TRYCON, // Trying connection (outgoing).

GS_H_ACCEPT, // Making initial connection (incoming).

GS_H_CONNECTED // Currently connected.

} GSHandleState;

@interface GSTcpHandle : NSObject <RunLoopEvents>

{

SOCKET desc; /* File descriptor for I/O. */

unsigned wItem; /* Index of item being written. */

NSMutableData *wData; /* Data object being written. */

unsigned wLength; /* Ammount written so far. */

NSMutableArray *wMsgs; /* Message in progress. */

NSMutableData *rData; /* Buffer for incoming data */

uint32_t rLength; /* Amount read so far. */

uint32_t rWant; /* Amount desired. */

NSMutableArray *rItems; /* Message in progress. */

GSPortItemType rType; /* Type of data being read. */

uint32_t rId; /* Id of incoming message. */

unsigned nItems; /* Number of items to be read. */

GSHandleState state; /* State of the handle. */

unsigned int addrNum; /* Address number within host. */

#ifdef _WIN32

WSAEVENT event; /* Win32 event associated to socket */

WSAEVENT eventTemp; /* Win32 event for asynchronous */

BOOL inReplyMode; /* Indicate when have addEvent self */

BOOL readyToSend; /* Indicate when send */

#endif

NSRecursiveLock *myLock; /* Lock for this handle. */

BOOL caller; /* Did we connect to other end? */

BOOL valid;

NSSocketPort *recvPort;

NSSocketPort *sendPort;

struct sockaddr sockAddr; /* Far end of connection. */

NSString *defaultAddress;

}

+ (GSTcpHandle*) handleWithDescriptor: (SOCKET)d;

- (BOOL) connectToPort: (NSSocketPort*)aPort beforeDate: (NSDate*)when;

- (int) descriptor;

#if defined(_WIN32)

- (int) eventHandle;

#endif

- (void) invalidate;

- (BOOL) isValid;

- (void) receivedEvent: (void*)data

type: (RunLoopEventType)type

extra: (void*)extra

forMode: (NSString*)mode;

- (void) receivedEventRead;

- (void) receivedEventWrite;

- (NSSocketPort*) recvPort;

- (BOOL) sendMessage: (NSArray*)components beforeDate: (NSDate*)when;

- (NSSocketPort*) sendPort;

- (void) setState: (GSHandleState)s;

- (GSHandleState) state;

static NSSocketPort*

decodePort(NSData *data, NSString *defaultAddress)

{

GSPortItemHeader *pih;

GSPortInfo *pi;

NSString *addr;

uint16_t pnum;

NSHost *host;

unichar c;

pih = (GSPortItemHeader*)[data bytes];

NSCAssert(GSSwapBigI32ToHost(pih->type) == GSP_PORT,

NSInternalInconsistencyException);

pi = (GSPortInfo*)&pih[1];

pnum = GSSwapBigI16ToHost(pi->num);

if (strncmp(pi->addr, "VER", 3) == 0)

{

NSLog(@"Remote version of GNUstep at %s:%d is more recent than this one",

pi->addr, pnum);

return nil;

}

addr = [NSString stringWithUTF8String: pi->addr];

NSDebugFLLog(@"NSPort", @"Decoded port as '%@:%d'", addr, pnum);

/*

if ([addr length] == 0)

{

addr = defaultAddress;

}

c = [addr characterAtIndex: 0];

if (c >= '0' && c <= '9')

{

host = [NSHost hostWithAddress: addr];

}

else

{

host = [NSHost hostWithName: addr];

}

return [NSSocketPort portWithNumber: pnum

onHost: host

forceAddress: nil

listener: NO];

}

static NSData*

newDataWithEncodedPort(NSSocketPort *port)

{

GSPortItemHeader *pih;

GSPortInfo *pi;

NSMutableData *data;

unsigned plen;

NSString *addr;

uint16_t pnum;

pnum = [port portNumber];

addr = [port address];

if (addr == nil)

{

static NSHost *local = nil;

/*

if (local == nil)

{

local = RETAIN([NSHost localHost]);

}

if ([[port host] isEqual: local] == YES)

{

addr = @"";

}

else if ((addr = [[port host] name]) == nil)

{

addr = [[port host] address];

if (addr == nil)

{

addr = @"127.0.0.1"; /* resign ourselves to this */

}

}

}

plen = [addr cStringLength] + 3;

data = [[NSMutableData alloc] initWithLength: sizeof(GSPortItemHeader)+plen];

pih = (GSPortItemHeader*)[data mutableBytes];

pih->type = GSSwapHostI32ToBig(GSP_PORT);

pih->length = GSSwapHostI32ToBig(plen);

pi = (GSPortInfo*)&pih[1];

pi->num = GSSwapHostI16ToBig(pnum);

[addr getCString: pi->addr];

NSDebugFLLog(@"NSPort", @"Encoded port as '%@:%d'", addr, pnum);

return data;

}



@implementation GSTcpHandle

static Class mutableArrayClass;

static Class mutableDataClass;

static Class portMessageClass;

static Class runLoopClass;

+ (id) allocWithZone: (NSZone*)zone

{

[NSException raise: NSGenericException

format: @"attempt to alloc a GSTcpHandle!"];

return nil;

}

+ (GSTcpHandle*) handleWithDescriptor: (SOCKET)d

{

GSTcpHandle *handle;

#ifdef _WIN32

unsigned long dummy;

#else

int e;

#endif /* _WIN32 */

#ifdef _WIN32

WSAEVENT ev;

int rc;

#endif

if (d == INVALID_SOCKET)

{

NSLog(@"illegal descriptor (%d) for Tcp Handle", d);

return nil;

}

#ifdef _WIN32

dummy = 1;

if (ioctlsocket(d, FIONBIO, &dummy) == SOCKET_ERROR)

{

NSLog(@"unable to set non-blocking mode on %d - %@",

d, [NSError _last]);

return nil;

}

#else /* !_WIN32 */

if ((e = fcntl(d, F_GETFL, 0)) >= 0)

{

e |= NBLK_OPT;

if (fcntl(d, F_SETFL, e) < 0)

{

NSLog(@"unable to set non-blocking mode on %d - %@",

d, [NSError _last]);

return nil;

}

}

else

{

NSLog(@"unable to get non-blocking mode on %d - %@",

d, [NSError _last]);

return nil;

}

#endif

handle = (GSTcpHandle*)NSAllocateObject(self, 0, NSDefaultMallocZone());

handle->desc = d;

handle->wMsgs = [NSMutableArray new];

handle->myLock = [NSRecursiveLock new];

#if defined(_WIN32)

ev = (WSAEVENT)CreateEvent(NULL,NO,NO,NULL);

if (ev == WSA_INVALID_EVENT)

{

NSLog(@"Invalid Event - '%d'", WSAGetLastError());

return nil;

}

rc = WSAEventSelect(handle->desc, ev, FD_ALL_EVENTS);

NSAssert(rc == 0, @"WSAEventSelect failed!");

handle->event = ev;

handle->inReplyMode = NO;

handle->readyToSend = YES;

#endif

handle->valid = YES;

return AUTORELEASE(handle);

}

+ (void) initialize

{

if (self == [GSTcpHandle class])

{

#ifdef _WIN32

WORD wVersionRequested;

WSADATA wsaData;

wVersionRequested = MAKEWORD(2, 0);

WSAStartup(wVersionRequested, &wsaData);

#endif

mutableArrayClass = [NSMutableArray class];

mutableDataClass = [NSMutableData class];

portMessageClass = [NSPortMessage class];

runLoopClass = [NSRunLoop class];

}

}

- (void) _add: (NSRunLoop*)l

{

#if defined(_WIN32)

[l addEvent: (void*)(uintptr_t)event

type: ET_HANDLE

watcher: self

forMode: NSConnectionReplyMode];

[l addEvent: (void*)(uintptr_t)event

type: ET_HANDLE

watcher: self

forMode: NSDefaultRunLoopMode];

inReplyMode = YES;

#else

[l addEvent: (void*)(uintptr_t)desc

type: ET_WDESC

watcher: self

forMode: NSConnectionReplyMode];

[l addEvent: (void*)(uintptr_t)desc

type: ET_EDESC

watcher: self

forMode: NSConnectionReplyMode];

[l addEvent: (void*)(uintptr_t)desc

type: ET_WDESC

watcher: self

forMode: NSDefaultRunLoopMode];

[l addEvent: (void*)(uintptr_t)desc

type: ET_EDESC

watcher: self

forMode: NSDefaultRunLoopMode];

#endif

}

- (void) _rem: (NSRunLoop*)l

{

#if defined(_WIN32)

[l removeEvent: (void*)(uintptr_t)event

type: ET_HANDLE

forMode: NSConnectionReplyMode

all: NO];

[l removeEvent: (void*)(uintptr_t)event

type: ET_HANDLE

forMode: NSDefaultRunLoopMode

all: NO];

inReplyMode = NO;

#else

[l removeEvent: (void*)(uintptr_t)desc

type: ET_WDESC

forMode: NSConnectionReplyMode

all: NO];

[l removeEvent: (void*)(uintptr_t)desc

type: ET_EDESC

forMode: NSConnectionReplyMode

all: NO];

[l removeEvent: (void*)(uintptr_t)desc

type: ET_WDESC

forMode: NSDefaultRunLoopMode

all: NO];

[l removeEvent: (void*)(uintptr_t)desc

type: ET_EDESC

forMode: NSDefaultRunLoopMode

all: NO];

#endif

}

- (BOOL) connectToPort: (NSSocketPort*)aPort beforeDate: (NSDate*)when

{

NSArray *addrs;

BOOL gotAddr = NO;

NSRunLoop *l;

M_LOCK(myLock);

NSDebugMLLog(@"GSTcpHandle",

@"Connecting on 0x%"PRIxPTR" before %@", (NSUInteger)self, when);

if (state != GS_H_UNCON)

{

BOOL result;

if (state == GS_H_CONNECTED) /* Already connected. */

{

NSLog(@"attempting connect on connected handle");

result = YES;

}

else if (state == GS_H_ACCEPT) /* Impossible. */

{

NSLog(@"attempting connect with accepting handle");

result = NO;

}

else /* Already connecting. */

{

NSLog(@"attempting connect while connecting");

result = NO;

}

M_UNLOCK(myLock);

return result;

}

if (recvPort == nil || aPort == nil)

{

NSLog(@"attempting connect with port(s) unset");

M_UNLOCK(myLock);

return NO; /* impossible. */

}

/*

if ([aPort address] != nil)

{

addrs = [NSArray arrayWithObject: [aPort address]];

}

else

{

addrs = [[aPort host] addresses];

}

while (gotAddr == NO)

{

NSString *addr;

if (addrNum >= [addrs count])

{

NSLog(@"run out of addresses to try (tried %d) for port %@",

addrNum, aPort);

M_UNLOCK(myLock);

return NO;

}

addr = [addrs objectAtIndex: addrNum++];

if (NO == GSPrivateSockaddrSetup(addr,

[aPort portNumber], nil, nil, &sockAddr))

{

NSLog(@"bad address - '%@'", addr);

}

else

{

gotAddr = YES;

NSDebugMLLog(@"GSTcpHandle", @"Connecting to %@:%d using desc %d",

addr, [aPort portNumber], desc);

}

}

if (connect(desc, (struct sockaddr*)&sockAddr,

GSPrivateSockaddrLength(&sockAddr)) == SOCKET_ERROR)

{

if (!GSWOULDBLOCK)

{

NSLog(@"unable to make connection to %@ - %@",

GSPrivateSockaddrName(&sockAddr), [NSError _last]);

if (addrNum < [addrs count])

{

BOOL result;

result = [self connectToPort: aPort beforeDate: when];

M_UNLOCK(myLock);

return result;

}

else

{

M_UNLOCK(myLock);

return NO; /* Tried all addresses */

}

}

}

state = GS_H_TRYCON;

l = [NSRunLoop currentRunLoop];

[self _add: l];

while (valid == YES && state == GS_H_TRYCON

&& [when timeIntervalSinceNow] > 0)

{

M_UNLOCK(myLock);

NS_DURING

[l runMode: NSConnectionReplyMode beforeDate: when];

NS_HANDLER

M_LOCK(myLock);

[self _rem: l];

M_UNLOCK(myLock);

[localException raise];

NS_ENDHANDLER

M_LOCK(myLock);

}

[self _rem: l];

if (state == GS_H_TRYCON)

{

state = GS_H_UNCON;

addrNum = 0;

M_UNLOCK(myLock);

return NO; /* Timed out */

}

else if (state == GS_H_UNCON)

{

if (addrNum < [addrs count] && [when timeIntervalSinceNow] > 0)

{

BOOL result;

/*

result = [self connectToPort: aPort beforeDate: when];

M_UNLOCK(myLock);

return result;

}

addrNum = 0;

state = GS_H_UNCON;

M_UNLOCK(myLock);

return NO; /* connection failed */

}

else

{

int status = 1;

if (setsockopt(desc, SOL_SOCKET, SO_KEEPALIVE, (char*)&status,

(OPTLEN)sizeof(status)) < 0)

{

NSLog(@"failed to turn on keepalive for connected socket %d", desc);

}

addrNum = 0;

caller = YES;

[aPort addHandle: self forSend: YES];

M_UNLOCK(myLock);

return YES;

}

}

- (void) dealloc

{

[self finalize];

DESTROY(defaultAddress);

DESTROY(rData);

DESTROY(rItems);

DESTROY(wMsgs);

DESTROY(myLock);

[super dealloc];

}

- (NSString*) description

{

return [NSString stringWithFormat: @"Handle (%d) to %@",

desc, GSPrivateSockaddrName(&sockAddr)];

}

- (int) descriptor

{

return desc;

}

#if defined(_WIN32)

- (int) eventHandle

{

return (int) (size_t) event;

}

#endif

- (void) finalize

{

[self invalidate];

#if defined(_WIN32)

if (event != WSA_INVALID_EVENT)

{

WSACloseEvent(event);

event = WSA_INVALID_EVENT;

}

#endif

if (desc >= 0)

{

(void)close(desc);

desc = -1;

}

}

- (void) invalidate

{

if (valid == YES)

{

M_LOCK(myLock);

if (valid == YES)

{

valid = NO;

NSDebugMLLog(@"GSTcpHandle",

@"invalidated 0x%"PRIxPTR, (NSUInteger)self);

[[self recvPort] removeHandle: self];

[[self sendPort] removeHandle: self];

}

M_UNLOCK(myLock);

}

}

- (BOOL) isValid

{

return valid;

}

- (NSSocketPort*) recvPort

{

if (recvPort == nil)

return nil;

else

return recvPort;

}

- (void) receivedEventRead

{

unsigned want;

void *bytes;

int res;

/*

if (rData == nil)

{

rData = [[mutableDataClass alloc] initWithLength: NETBLOCK];

rWant = sizeof(GSPortItemHeader);

rLength = 0;

want = NETBLOCK;

}

else

{

want = [rData length];

if (want < rWant)

{

want = rWant;

[rData setLength: want];

}

if (want < NETBLOCK)

{

want = NETBLOCK;

[rData setLength: want];

}

}

/*

bytes = [rData mutableBytes];

res = recv(desc, bytes + rLength, want - rLength, 0);

if (res <= 0)

{

if (res == 0)

{

NSDebugMLLog(@"GSTcpHandle",

@"read eof on 0x%"PRIxPTR, (NSUInteger)self);

[self invalidate];

return;

}

#ifdef _WIN32

else if (WSAGetLastError()!= WSAEINTR

&& WSAGetLastError()!= WSAEWOULDBLOCK)

#else

else if (errno != EINTR && errno != EAGAIN)

#endif /* !_WIN32 */

{

NSDebugMLLog(@"GSTcpHandle",

@"read failed - %@ on 0x%p", [NSError _last], self);

[self invalidate];

return;

}

res = 0; /* Interrupted - continue */

}

NSDebugMLLog(@"GSTcpHandle",

@"read %d bytes on 0x%"PRIxPTR, res, (NSUInteger)self);

rLength += res;

while (valid == YES && rLength >= rWant)

{

BOOL shouldDispatch = NO;

switch (rType)

{

case GSP_NONE:

{

GSPortItemHeader *h;

unsigned l;

/*

h = (GSPortItemHeader*)bytes;

rType = GSSwapBigI32ToHost(h->type);

l = GSSwapBigI32ToHost(h->length);

if (rType == GSP_PORT)

{

if (l > 128)

{

NSLog(@"%@ - unreasonable length (%u) for port",

self, l);

[self invalidate];

return;

}

/*

rWant += l;

}

else if (rType == GSP_DATA)

{

if (l == 0)

{

NSData *d;

/*

rType = GSP_NONE; /* ready for a new item */

rLength -= rWant;

if (rLength > 0)

{

memmove(bytes, bytes + rWant, rLength);

}

rWant = sizeof(GSPortItemHeader);

d = [mutableDataClass new];

[rItems addObject: d];

RELEASE(d);

if (nItems == [rItems count])

{

shouldDispatch = YES;

}

}

else

{

if (l > maxDataLength)

{

NSLog(@"%@ - unreasonable length (%u) for data",

self, l);

[self invalidate];

return;

}

/*

rLength -= rWant;

if (rLength > 0)

{

memmove(bytes, bytes + rWant, rLength);

}

rWant = l;

}

}

else if (rType == GSP_HEAD)

{

if (l > maxDataLength)

{

NSLog(@"%@ - unreasonable length (%u) for data",

self, l);

[self invalidate];

return;

}

/*

rLength -= rWant;

if (rLength > 0)

{

memmove(bytes, bytes + rWant, rLength);

}

rWant = l;

}

else

{

NSLog(@"%@ - bad data received on port handle", self);

[self invalidate];

return;

}

}

break;

case GSP_HEAD:

{

GSPortMsgHeader *h;

rType = GSP_NONE; /* ready for a new item */

/*

h = (GSPortMsgHeader*)bytes;

rId = GSSwapBigI32ToHost(h->mId);

nItems = GSSwapBigI32ToHost(h->nItems);

NSAssert(nItems >0, NSInternalInconsistencyException);

rItems = [mutableArrayClass allocWithZone: NSDefaultMallocZone()];

rItems = [rItems initWithCapacity: nItems];

if (rWant > sizeof(GSPortMsgHeader))

{

NSData *d;

/*

rWant -= sizeof(GSPortMsgHeader);

d = [mutableDataClass alloc];

d = [d initWithBytes: bytes + sizeof(GSPortMsgHeader)

length: rWant];

[rItems addObject: d];

RELEASE(d);

rWant += sizeof(GSPortMsgHeader);

rLength -= rWant;

if (rLength > 0)

{

memmove(bytes, bytes + rWant, rLength);

}

rWant = sizeof(GSPortItemHeader);

if (nItems == 1)

{

shouldDispatch = YES;

}

}

else

{

/*

rLength -= rWant;

if (rLength > 0)

{

memmove(bytes, bytes + rWant, rLength);

}

rWant = sizeof(GSPortItemHeader);

}

}

break;