#import "common.h"

#define EXPOSE_NSPort_IVARS 1

#define EXPOSE_NSMessagePort_IVARS 1

#import "GNUstepBase/GSLock.h"

#import "Foundation/NSArray.h"

#import "Foundation/NSAutoreleasePool.h"

#import "Foundation/NSNotification.h"

#import "Foundation/NSException.h"

#import "Foundation/NSRunLoop.h"

#import "Foundation/NSByteOrder.h"

#import "Foundation/NSData.h"

#import "Foundation/NSDate.h"

#import "Foundation/NSMapTable.h"

#import "Foundation/NSPortMessage.h"

#import "Foundation/NSPortNameServer.h"

#import "Foundation/NSLock.h"

#import "Foundation/NSConnection.h"

#import "Foundation/NSPathUtilities.h"

#import "Foundation/NSValue.h"

#import "Foundation/NSFileManager.h"

#import "Foundation/NSProcessInfo.h"

#import "GSPrivate.h"

#import "GSNetwork.h"

#import "GSPortPrivate.h"

#include <stdio.h>

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

#include <sys/types.h>

#include <sys/un.h>

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

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

#if defined(HAVE_SYS_FCNTL_H)

# include <sys/fcntl.h>

#elif defined(HAVE_FCNTL_H)

# include <fcntl.h>

#endif

#include <sys/time.h>

#include <sys/resource.h>

#include <netdb.h>

#include <sys/socket.h>

#if defined(HAVE_SYS_FILE_H)

# include <sys/file.h>

#endif

#include <sys/stat.h>

#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)

# include <sys/stropts.h>

# endif

#endif

@interface NSProcessInfo (private)

+ (BOOL) _exists: (int)pid;

static uint32_t maxDataLength = 32 * 1024 * 1024;

#if 0

#define M_LOCK(X) {NSDebugMLLog(@"NSMessagePort",@"lock %@",X); [X lock];}

#define M_UNLOCK(X) {NSDebugMLLog(@"NSMessagePort",@"unlock %@",X); [X unlock];}

#else

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

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

#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 {

unsigned char version;

unsigned char addr[0]; /* name of the port on the local host */

} GSPortInfo;

static NSMessagePort*

decodePort(NSData *data)

{

GSPortItemHeader *pih;

GSPortInfo *pi;

pih = (GSPortItemHeader*)[data bytes];

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

NSInternalInconsistencyException);

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

if (pi->version != 0)

{

NSLog(@"Remote version of GNUstep is more recent than this one (%i)",

pi->version);

return nil;

}

NSDebugFLLog(@"NSMessagePort", @"Decoded port as '%s'", pi->addr);

return [NSMessagePort _portWithName: pi->addr

listener: NO];

}

static NSData*

newDataWithEncodedPort(NSMessagePort *port)

{

GSPortItemHeader *pih;

GSPortInfo *pi;

NSMutableData *data;

unsigned plen;

const unsigned char *name = [port _name];

plen = 2 + strlen((char*)name);

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

pih = (GSPortItemHeader*)[data mutableBytes];

pih->type = GSSwapHostI32ToBig(GSP_PORT);

pih->length = GSSwapHostI32ToBig(plen);

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

strncpy((char*)pi->addr, (char*)name, strlen((char*)name) + 1);

NSDebugFLLog(@"NSMessagePort", @"Encoded port as '%s'", pi->addr);

return data;

}

#ifndef AF_LOCAL

#define AF_LOCAL AF_UNIX

#define PF_LOCAL PF_UNIX

#endif

#ifndef SUN_LEN

#define SUN_LEN(su) \

(sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))

#endif

#define GS_CONNECTION_MSG 0

#define NETBLOCK 8192



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 GSMessageHandle : NSObject <RunLoopEvents>

{

int 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. */

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

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

BOOL valid;

NSMessagePort *recvPort;

NSMessagePort *sendPort;

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

}

+ (GSMessageHandle*) handleWithDescriptor: (int)d;

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

- (int) descriptor;

- (void) invalidate;

- (BOOL) isValid;

- (void) receivedEvent: (void*)data

type: (RunLoopEventType)type

extra: (void*)extra

forMode: (NSString*)mode;

- (NSMessagePort*) recvPort;

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

- (NSMessagePort*) sendPort;

- (void) setState: (GSHandleState)s;

- (GSHandleState) state;



@implementation GSMessageHandle

static Class mutableArrayClass;

static Class mutableDataClass;

static Class portMessageClass;

static Class runLoopClass;

+ (id) allocWithZone: (NSZone*)zone

{

[NSException raise: NSGenericException

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

return nil;

}

+ (GSMessageHandle*) handleWithDescriptor: (int)d

{

GSMessageHandle *handle;

int e;

if (d < 0)

{

NSLog(@"illegal descriptor (%d) for message handle", d);

return nil;

}

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;

}

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

handle->desc = d;

handle->wMsgs = [NSMutableArray new];

handle->myLock = [NSRecursiveLock new];

handle->valid = YES;

return AUTORELEASE(handle);

}

+ (void) initialize

{

if (self == [GSMessageHandle class])

{

mutableArrayClass = [NSMutableArray class];

mutableDataClass = [NSMutableData class];

portMessageClass = [NSPortMessage class];

runLoopClass = [NSRunLoop class];

}

}

- (void) _add: (NSRunLoop*)l

{

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

type: ET_WDESC

watcher: self

forMode: NSConnectionReplyMode];

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

type: ET_WDESC

watcher: self

forMode: NSDefaultRunLoopMode];

}

- (void) _rem: (NSRunLoop*)l

{

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

type: ET_WDESC

forMode: NSConnectionReplyMode

all: NO];

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

type: ET_WDESC

forMode: NSDefaultRunLoopMode

all: NO];

}

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

{

NSRunLoop *l;

const unsigned char *name;

M_LOCK(myLock);

NSDebugMLLog(@"NSMessagePort",

@"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. */

}

name = [aPort _name];

memset(&sockAddr, '\0', sizeof(sockAddr));

sockAddr.sun_family = AF_LOCAL;

strncpy(sockAddr.sun_path, (char*)name, sizeof(sockAddr.sun_path) - 1);

if (connect(desc, (struct sockaddr*)&sockAddr, SUN_LEN(&sockAddr)) < 0)

{

if (!GSWOULDBLOCK)

{

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

sockAddr.sun_path, [NSError _last]);

M_UNLOCK(myLock);

return NO;

}

}

state = GS_H_TRYCON;

l = [NSRunLoop currentRunLoop];

[self _add: l];

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

&& [when timeIntervalSinceNow] > 0)

{

[l runMode: NSConnectionReplyMode beforeDate: when];

}

[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)

{

addrNum = 0;

state = GS_H_UNCON;

M_UNLOCK(myLock);

return NO;

}

else

{

int status = 1;

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

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(rData);

DESTROY(rItems);

DESTROY(wMsgs);

DESTROY(myLock);

[super dealloc];

}

- (NSString*) description

{

return [NSString stringWithFormat: @"<GSMessageHandle %p (%d) to %s>",

self, desc, sockAddr.sun_path];

}

- (int) descriptor

{

return desc;

}

- (void) finalize

{

[self invalidate];

(void)close(desc);

desc = -1;

}

- (void) invalidate

{

if (valid == YES)

{

M_LOCK(myLock);

if (valid == YES)

{

NSRunLoop *l;

valid = NO;

l = [runLoopClass currentRunLoop];

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

type: ET_RDESC

forMode: nil

all: YES];

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

type: ET_WDESC

forMode: nil

all: YES];

NSDebugMLLog(@"NSMessagePort",

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

[[self recvPort] removeHandle: self];

[[self sendPort] removeHandle: self];

}

M_UNLOCK(myLock);

}

}

- (BOOL) isValid

{

return valid;

}

- (NSMessagePort*) recvPort

{

if (recvPort == nil)

return nil;

else

return recvPort;

}

- (void) receivedEvent: (void*)data

type: (RunLoopEventType)type

extra: (void*)extra

forMode: (NSString*)mode

{

NSDebugMLLog(@"NSMessagePort_details",

@"received %s event on 0x%"PRIxPTR,

type != ET_WDESC ? "read" : "write", (NSUInteger)self);

/*

if (desc < 0)

{

NSRunLoop *l = [runLoopClass currentRunLoop];

[l removeEvent: data

type: ET_WDESC

forMode: mode

all: YES];

return;

}

M_LOCK(myLock);

if (type != ET_WDESC)

{

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 = read(desc, bytes + rLength, want - rLength);

if (res <= 0)

{

if (res == 0)

{

NSDebugMLLog(@"NSMessagePort",

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

M_UNLOCK(myLock);

[self invalidate];

return;

}

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

{

NSDebugMLLog(@"NSMessagePort",

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

M_UNLOCK(myLock);

[self invalidate];

return;

}

res = 0; /* Interrupted - continue */

}

NSDebugMLLog(@"NSMessagePort_details",

@"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 > 512)

{

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

self, l);

M_UNLOCK(myLock);

[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);

M_UNLOCK(myLock);

[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);

M_UNLOCK(myLock);

[self invalidate];

return;

}

/*

rLength -= rWant;

if (rLength > 0)

{

memmove(bytes, bytes + rWant, rLength);

}

rWant = l;

}

else

{

NSLog(@"%@ - bad data received on port handle, rType=%i",

self, rType);

M_UNLOCK(myLock);

[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;

case GSP_DATA:

{

NSData *d;

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

d = [mutableDataClass allocWithZone: NSDefaultMallocZone()];

d = [d initWithBytes: bytes length: rWant];

[rItems addObject: d];

RELEASE(d);

rLength -= rWant;

if (rLength > 0)

{

memmove(bytes, bytes + rWant, rLength);

}

rWant = sizeof(GSPortItemHeader);

if (nItems == [rItems count])

{

shouldDispatch = YES;

}

}

break;

case GSP_PORT:

{

NSMessagePort *p;

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

p = decodePort(rData);

if (p == nil)

{

NSLog(@"%@ - unable to decode remote port", self);

M_UNLOCK(myLock);

[self invalidate];

return;

}

/*

rLength -= rWant;

if (rLength > 0)

{

memmove(bytes, bytes + rWant, rLength);

}

rWant = sizeof(GSPortItemHeader);

if (state == GS_H_ACCEPT)

{

/*

state = GS_H_CONNECTED;

[p addHandle: self forSend: YES];

}

else

{

/*

[rItems addObject: p];

if (nItems == [rItems count])

{

shouldDispatch = YES;

}

}

}

break;

}

if (shouldDispatch == YES)

{

NSPortMessage *pm;

NSMessagePort *rp = [self recvPort];

pm = [portMessageClass allocWithZone: NSDefaultMallocZone()];

pm = [pm initWithSendPort: [self sendPort]

receivePort: rp

components: rItems];

[pm setMsgid: rId];

rId = 0;

DESTROY(rItems);

NSDebugMLLog(@"NSMessagePort_details",

@"got message %@ on 0x%"PRIxPTR, pm, (NSUInteger)self);

IF_NO_GC([rp retain];)

M_UNLOCK(myLock);

NS_DURING

{

[rp handlePortMessage: pm];

}

NS_HANDLER

{

M_LOCK(myLock);

RELEASE(pm);

RELEASE(rp);

[localException raise];

}

NS_ENDHANDLER

M_LOCK(myLock);

RELEASE(pm);

RELEASE(rp);

bytes = [rData mutableBytes];

}

}

}

else

{

if (state == GS_H_TRYCON) /* Connection attempt. */

{

int res = 0;

unsigned len = sizeof(res);

#if !defined(__gnu_hurd__)

if (getsockopt(desc, SOL_SOCKET, SO_ERROR, (char*)&res, &len) != 0)

{

state = GS_H_UNCON;

NSLog(@"connect attempt failed - %@", [NSError _last]);

}

else if (res != 0)

{

state = GS_H_UNCON;

NSLog(@"connect attempt failed - %@",

[NSError _systemError: res]);

}

else

#endif

{

NSData *d = newDataWithEncodedPort([self recvPort]);

len = write(desc, [d bytes], [d length]);

if (len == (int)[d length])

{

NSDebugMLLog(@"NSMessagePort_details",

@"wrote %d bytes on 0x%"PRIxPTR, len, (NSUInteger)self);

state = GS_H_CONNECTED;

}

else

{

state = GS_H_UNCON;

NSLog(@"connect write attempt failed - %@",

[NSError _last]);

}

RELEASE(d);

}

}

else

{

int res;

unsigned l;

const void *b;

if (wData == nil)

{

if ([wMsgs count] > 0)

{

NSArray *components = [wMsgs objectAtIndex: 0];

wData = [components objectAtIndex: wItem++];

wLength = 0;

}

else

{

M_UNLOCK(myLock);

return;

}

}

b = [wData bytes];

l = [wData length];

res = write(desc, b + wLength, l - wLength);

if (res < 0)

{

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

{

NSLog(@"write attempt failed - %@", [NSError _last]);

M_UNLOCK(myLock);

[self invalidate];

return;

}

}

else

{

NSDebugMLLog(@"NSMessagePort_details",

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

wLength += res;

if (wLength == l)

{

NSArray *components;

/*

components = [wMsgs objectAtIndex: 0];

wLength = 0;

if ([components count] > wItem)

{

/*

wData = [components objectAtIndex: wItem++];