#import "common.h"

#if !defined (__GNU_LIBOBJC__)

# include <objc/encoding.h>

#endif

#define GS_NSConnection_IVARS \

BOOL _isValid; \

BOOL _independentQueueing; \

BOOL _authenticateIn; \

BOOL _authenticateOut; \

BOOL _multipleThreads; \

BOOL _shuttingDown; \

BOOL _useKeepalive; \

BOOL _keepaliveWait; \

NSPort *_receivePort; \

NSPort *_sendPort; \

unsigned _requestDepth; \

unsigned _messageCount; \

unsigned _reqOutCount; \

unsigned _reqInCount; \

unsigned _repOutCount; \

unsigned _repInCount; \

GSIMapTable _localObjects; \

GSIMapTable _localTargets; \

GSIMapTable _remoteProxies; \

GSIMapTable _replyMap; \

NSTimeInterval _replyTimeout; \

NSTimeInterval _requestTimeout; \

NSMutableArray *_requestModes; \

NSMutableArray *_runLoops; \

NSMutableArray *_requestQueue; \

id _delegate; \

NSRecursiveLock *_refGate; \

NSMutableArray *_cachedDecoders; \

NSMutableArray *_cachedEncoders; \

NSString *_remoteName; \

NSString *_registeredName; \

NSPortNameServer *_nameServer; \

int _lastKeepalive

#define EXPOSE_NSDistantObject_IVARS 1

#ifdef HAVE_MALLOC_H

#if !defined(__OpenBSD__)

#include <malloc.h>

#endif

#endif

#ifdef HAVE_ALLOCA_H

#include <alloca.h>

#endif

#import "Foundation/NSEnumerator.h"

#import "GNUstepBase/GSLock.h"

static inline const char *

skip_argspec(const char *ptr)

{

if (ptr != NULL)

{

ptr = NSGetSizeAndAlignment(ptr, NULL, NULL);

if (*ptr == '+') ptr++;

while (isdigit(*ptr)) ptr++;

}

return ptr;

}

#define GSI_MAP_KTYPES GSUNION_PTR | GSUNION_OBJ | GSUNION_NSINT

#define GSI_MAP_VTYPES GSUNION_PTR | GSUNION_OBJ

#define GSI_MAP_RETAIN_KEY(M, X)

#define GSI_MAP_RELEASE_KEY(M, X)

#define GSI_MAP_RETAIN_VAL(M, X)

#define GSI_MAP_RELEASE_VAL(M, X)

#define GSI_MAP_HASH(M, X) ((X).nsu ^ ((X).nsu >> 3))

#define GSI_MAP_EQUAL(M, X,Y) ((X).ptr == (Y).ptr)

#define GSI_MAP_NOCLEAN 1

#include "GNUstepBase/GSIMap.h"

#define _IN_CONNECTION_M

#import "Foundation/NSConnection.h"

#undef _IN_CONNECTION_M

#import "Foundation/NSPortCoder.h"

#import "GNUstepBase/DistributedObjects.h"

#import "Foundation/NSHashTable.h"

#import "Foundation/NSMapTable.h"

#import "Foundation/NSData.h"

#import "Foundation/NSRunLoop.h"

#import "Foundation/NSArray.h"

#import "Foundation/NSDictionary.h"

#import "Foundation/NSValue.h"

#import "Foundation/NSDate.h"

#import "Foundation/NSException.h"

#import "Foundation/NSLock.h"

#import "Foundation/NSThread.h"

#import "Foundation/NSPort.h"

#import "Foundation/NSPortMessage.h"

#import "Foundation/NSPortNameServer.h"

#import "Foundation/NSNotification.h"

#import "GSInvocation.h"

#import "GSPortPrivate.h"

#import "GSPrivate.h"

static inline NSRunLoop *

GSRunLoopForThread(NSThread *aThread)

{

GSRunLoopThreadInfo *info = GSRunLoopInfoForThread(aThread);

if (info == nil || info->loop == nil)

{

if (aThread == nil || aThread == GSCurrentThread())

{

return [NSRunLoop currentRunLoop];

}

return nil;

}

return info->loop;

}

@interface NSPortCoder (Private)

- (NSMutableArray*) _components;

@interface NSPortMessage (Private)

- (NSMutableArray*) _components;

@interface NSConnection (GNUstepExtensions)

- (void) finalize;

- (void) forwardInvocation: (NSInvocation *)inv

forProxy: (NSDistantObject*)object;

- (const char *) typeForSelector: (SEL)sel remoteTarget: (unsigned)target;

#define GS_F_LOCK(X) \

{NSDebugFLLog(@"GSConnection",@"Lock %@",X);[X lock];}

#define GS_F_UNLOCK(X) \

{NSDebugFLLog(@"GSConnection",@"Unlock %@",X);[X unlock];}

#define GS_M_LOCK(X) \

{NSDebugMLLog(@"GSConnection",@"Lock %@",X);[X lock];}

#define GSM_UNLOCK(X) \

{NSDebugMLLog(@"GSConnection",@"Unlock %@",X);[X unlock];}

static id dummyObject;

static Class connectionClass;

static Class dateClass;

static Class distantObjectClass;

static Class sendCoderClass;

static Class recvCoderClass;

static Class runLoopClass;

static NSString*

stringFromMsgType(int type)

{

switch (type)

{

case METHOD_REQUEST:

return @"method request";

case METHOD_REPLY:

return @"method reply";

case ROOTPROXY_REQUEST:

return @"root proxy request";

case ROOTPROXY_REPLY:

return @"root proxy reply";

case CONNECTION_SHUTDOWN:

return @"connection shutdown";

case METHODTYPE_REQUEST:

return @"methodtype request";

case METHODTYPE_REPLY:

return @"methodtype reply";

case PROXY_RELEASE:

return @"proxy release";

case PROXY_RETAIN:

return @"proxy retain";

case RETAIN_REPLY:

return @"retain replay";

default:

return @"unknown operation type!";

}

}



@interface CachedLocalObject : NSObject

{

NSDistantObject *obj;

int time;

}

- (BOOL) countdown;

- (NSDistantObject*) obj;

+ (id) newWithObject: (NSDistantObject*)o time: (int)t;

@implementation CachedLocalObject

+ (id) newWithObject: (NSDistantObject*)o time: (int)t

{

CachedLocalObject *item;

item = (CachedLocalObject*)NSAllocateObject(self, 0, NSDefaultMallocZone());

item->obj = RETAIN(o);

item->time = t;

return item;

}

- (void) dealloc

{

RELEASE(obj);

[super dealloc];

}

- (BOOL) countdown

{

if (time-- > 0)

return YES;

return NO;

}

- (NSDistantObject*) obj

{

return obj;

}



#define GSInternal NSConnectionInternal

#include "GSInternal.h"

GS_PRIVATE_INTERNAL(NSConnection)

#define IisValid (internal->_isValid)

#define IindependentQueueing (internal->_independentQueueing)

#define IauthenticateIn (internal->_authenticateIn)

#define IauthenticateOut (internal->_authenticateOut)

#define ImultipleThreads (internal->_multipleThreads)

#define IshuttingDown (internal->_shuttingDown)

#define IuseKeepalive (internal->_useKeepalive)

#define IkeepaliveWait (internal->_keepaliveWait)

#define IreceivePort (internal->_receivePort)

#define IsendPort (internal->_sendPort)

#define IrequestDepth (internal->_requestDepth)

#define ImessageCount (internal->_messageCount)

#define IreqOutCount (internal->_reqOutCount)

#define IreqInCount (internal->_reqInCount)

#define IrepOutCount (internal->_repOutCount)

#define IrepInCount (internal->_repInCount)

#define IlocalObjects (internal->_localObjects)

#define IlocalTargets (internal->_localTargets)

#define IremoteProxies (internal->_remoteProxies)

#define IreplyMap (internal->_replyMap)

#define IreplyTimeout (internal->_replyTimeout)

#define IrequestTimeout (internal->_requestTimeout)

#define IrequestModes (internal->_requestModes)

#define IrunLoops (internal->_runLoops)

#define IrequestQueue (internal->_requestQueue)

#define Idelegate (internal->_delegate)

#define IrefGate (internal->_refGate)

#define IcachedDecoders (internal->_cachedDecoders)

#define IcachedEncoders (internal->_cachedEncoders)

#define IremoteName (internal->_remoteName)

#define IregisteredName (internal->_registeredName)

#define InameServer (internal->_nameServer)

#define IlastKeepalive (internal->_lastKeepalive)

@interface NSConnection(Private)

- (void) handlePortMessage: (NSPortMessage*)msg;

- (void) _runInNewThread;

+ (int) setDebug: (int)val;

- (void) _enableKeepalive;

- (void) addLocalObject: (NSDistantObject*)anObj;

- (void) removeLocalObject: (NSDistantObject*)anObj;

- (void) _doneInReply: (NSPortCoder*)c;

- (void) _doneInRmc: (NSPortCoder*) NS_CONSUMED c;

- (void) _failInRmc: (NSPortCoder*)c;

- (void) _failOutRmc: (NSPortCoder*)c;

- (NSPortCoder*) _getReplyRmc: (int)sn for: (const char*)request;

- (NSPortCoder*) _newInRmc: (NSMutableArray*)components;

- (NSPortCoder*) _newOutRmc: (int)sequence generate: (int*)sno reply: (BOOL)f;

- (void) _portIsInvalid: (NSNotification*)notification;

- (void) _sendOutRmc: (NSPortCoder*) NS_CONSUMED c

type: (int)msgid

sequence: (int)sno;

- (void) _service_forwardForProxy: (NSPortCoder*)rmc;

- (void) _service_release: (NSPortCoder*)rmc;

- (void) _service_retain: (NSPortCoder*)rmc;

- (void) _service_rootObject: (NSPortCoder*)rmc;

- (void) _service_shutdown: (NSPortCoder*)rmc;

- (void) _service_typeForSelector: (NSPortCoder*)rmc;

- (void) _shutdown;

+ (void) _threadWillExit: (NSNotification*)notification;

static NSTimer *timer = nil;

static BOOL cacheCoders = NO;

static int debug_connection = 0;

static NSHashTable *connection_table;

static NSRecursiveLock *connection_table_gate = nil;

static NSConnection*

existingConnection(NSPort *receivePort, NSPort *sendPort)

{

NSHashEnumerator enumerator;

NSConnection *c;

GS_F_LOCK(connection_table_gate);

enumerator = NSEnumerateHashTable(connection_table);

while ((c = (NSConnection*)NSNextHashEnumeratorItem(&enumerator)) != nil)

{

if ((sendPort == nil || [sendPort isEqual: [c sendPort]])

&& (receivePort == nil || [receivePort isEqual: [c receivePort]]))

{

/*

IF_NO_GC([[c retain] autorelease];)

break;

}

}

NSEndHashTableEnumeration(&enumerator);

GS_F_UNLOCK(connection_table_gate);

return c;

}

static NSMapTable *root_object_map;

static NSLock *root_object_map_gate = nil;

static id

rootObjectForInPort(NSPort *aPort)

{

id rootObject;

GS_F_LOCK(root_object_map_gate);

rootObject = (id)NSMapGet(root_object_map, (void*)(uintptr_t)aPort);

GS_F_UNLOCK(root_object_map_gate);

return rootObject;

}

static void

setRootObjectForInPort(id anObj, NSPort *aPort)

{

id oldRootObject;

GS_F_LOCK(root_object_map_gate);

oldRootObject = (id)NSMapGet(root_object_map, (void*)(uintptr_t)aPort);

if (oldRootObject != anObj)

{

if (anObj != nil)

{

NSMapInsert(root_object_map, (void*)(uintptr_t)aPort,

(void*)(uintptr_t)anObj);

}

else /* anObj == nil && oldRootObject != nil */

{

NSMapRemove(root_object_map, (void*)(uintptr_t)aPort);

}

}

GS_F_UNLOCK(root_object_map_gate);

}

static NSMapTable *targetToCached = NULL;

static NSLock *cached_proxies_gate = nil;



@implementation NSConnection

+ (NSArray*) allConnections

{

NSArray *a;

GS_M_LOCK(connection_table_gate);

a = NSAllHashTableObjects(connection_table);

GSM_UNLOCK(connection_table_gate);

return a;

}

+ (NSConnection*) connectionWithReceivePort: (NSPort*)r

sendPort: (NSPort*)s

{

NSConnection *c = existingConnection(r, s);

if (c == nil)

{

c = [self allocWithZone: NSDefaultMallocZone()];

c = [c initWithReceivePort: r sendPort: s];

IF_NO_GC([c autorelease];)

}

return c;

}

+ (NSConnection*) connectionWithRegisteredName: (NSString*)n

host: (NSString*)h

{

NSPortNameServer *s;

s = [NSPortNameServer systemDefaultPortNameServer];

return [self connectionWithRegisteredName: n

host: h

usingNameServer: s];

}

+ (NSConnection*) connectionWithRegisteredName: (NSString*)n

host: (NSString*)h

usingNameServer: (NSPortNameServer*)s

{

NSConnection *con = nil;

if (s != nil)

{

NSPort *sendPort = [s portForName: n onHost: h];

if (sendPort != nil)

{

NSPort *recvPort;

recvPort = [[self defaultConnection] receivePort];

if (recvPort == sendPort)

{

/*

recvPort = [NSPort port];

}

else if (![recvPort isMemberOfClass: [sendPort class]])

{

/*

recvPort = [[sendPort class] port];

}

con = existingConnection(recvPort, sendPort);

if (con == nil)

{

con = [self connectionWithReceivePort: recvPort

sendPort: sendPort];

}

ASSIGNCOPY(GSIVar(con, _remoteName), n);

}

}

return con;

}

+ (id) currentConversation

{

return nil;

}

+ (NSConnection*) defaultConnection

{

static NSString *tkey = @"NSConnectionThreadKey";

NSConnection *c;

NSMutableDictionary *d;

d = GSCurrentThreadDictionary();

c = (NSConnection*)[d objectForKey: tkey];

if (c != nil && [c isValid] == NO)

{

/*

[d removeObjectForKey: tkey];

c = nil;

}

if (c == nil)

{

NSPort *port;

c = [self alloc];

port = [NSPort port];

c = [c initWithReceivePort: port sendPort: nil];

if (c != nil)

{

[d setObject: c forKey: tkey];

RELEASE(c);

}

}

return c;

}

+ (void) initialize

{

if (connectionClass == nil)

{

NSNotificationCenter *nc;

GSMakeWeakPointer(self, "delegate");

connectionClass = self;

dateClass = [NSDate class];

distantObjectClass = [NSDistantObject class];

sendCoderClass = [NSPortCoder class];

recvCoderClass = [NSPortCoder class];

runLoopClass = [NSRunLoop class];

dummyObject = [NSObject new];

[[NSObject leakAt: &dummyObject] release];

connection_table =

NSCreateHashTable(NSNonRetainedObjectHashCallBacks, 0);

[[NSObject leakAt: &connection_table] release];

targetToCached =

NSCreateMapTable(NSIntegerMapKeyCallBacks,

NSObjectMapValueCallBacks, 0);

[[NSObject leakAt: &targetToCached] release];

root_object_map =

NSCreateMapTable(NSNonOwnedPointerMapKeyCallBacks,

NSObjectMapValueCallBacks, 0);

[[NSObject leakAt: &root_object_map] release];

if (connection_table_gate == nil)

{

connection_table_gate = [NSRecursiveLock new];

[[NSObject leakAt: &connection_table_gate] release];

}

if (cached_proxies_gate == nil)

{

cached_proxies_gate = [NSLock new];

[[NSObject leakAt: &cached_proxies_gate] release];

}

if (root_object_map_gate == nil)

{

root_object_map_gate = [NSLock new];

[[NSObject leakAt: &root_object_map_gate] release];

}

/*

nc = [NSNotificationCenter defaultCenter];

[nc addObserver: self

selector: @selector(_threadWillExit:)

name: NSThreadWillExitNotification

object: nil];

}

}

+ (id) new

{

return RETAIN([self defaultConnection]);

}

+ (NSDistantObject*) rootProxyForConnectionWithRegisteredName: (NSString*)n

host: (NSString*)h

{

NSAutoreleasePool *arp = [NSAutoreleasePool new];

NSConnection *connection;

NSDistantObject *proxy = nil;

connection = [self connectionWithRegisteredName: n host: h];

if (connection != nil)

{

proxy = [[connection rootProxy] retain];

}

[arp drain];

return [proxy autorelease];

}

+ (NSDistantObject*) rootProxyForConnectionWithRegisteredName: (NSString*)n

host: (NSString*)h usingNameServer: (NSPortNameServer*)s

{

NSAutoreleasePool *arp = [NSAutoreleasePool new];

NSConnection *connection;

NSDistantObject *proxy = nil;

connection = [self connectionWithRegisteredName: n

host: h

usingNameServer: s];

if (connection != nil)

{

proxy = RETAIN([connection rootProxy]);

}

[arp drain];

return AUTORELEASE(proxy);

}

+ (id) serviceConnectionWithName: (NSString *)name

rootObject: (id)root

{

return [self serviceConnectionWithName: name

rootObject: root

usingNameServer: [NSPortNameServer systemDefaultPortNameServer]];

}

+ (id) serviceConnectionWithName: (NSString *)name

rootObject: (id)root

usingNameServer: (NSPortNameServer *)server

{

NSConnection *c;

NSPort *p;

if ([server isKindOfClass: [NSMessagePortNameServer class]] == YES)

{

p = [NSMessagePort port];

}

else if ([server isKindOfClass: [NSSocketPortNameServer class]] == YES)

{

p = [NSSocketPort port];

}

else

{

p = nil;

}

c = [[NSConnection alloc] initWithReceivePort: p sendPort: nil];

[c setRootObject: root];

if ([c registerName: name withNameServer: server] == NO)

{

DESTROY(c);

}

return AUTORELEASE(c);

}

+ (void) _timeout: (NSTimer*)t

{

NSArray *cached_locals;

int i;

GS_M_LOCK(cached_proxies_gate);

cached_locals = NSAllMapTableValues(targetToCached);

for (i = [cached_locals count]; i > 0; i--)

{

CachedLocalObject *item = [cached_locals objectAtIndex: i-1];

if ([item countdown] == NO)

{

NSDistantObject *obj = [item obj];

NSMapRemove(targetToCached,

(void*)(uintptr_t)obj->_handle);

}

}

if ([cached_locals count] == 0)

{

[t invalidate];

timer = nil;

}

GSM_UNLOCK(cached_proxies_gate);

}

- (void) addRequestMode: (NSString*)mode

{

GS_M_LOCK(IrefGate);

if ([self isValid] == YES)

{

if ([IrequestModes containsObject: mode] == NO)

{

NSUInteger c = [IrunLoops count];

while (c-- > 0)

{

NSRunLoop *loop = [IrunLoops objectAtIndex: c];

[IreceivePort addConnection: self toRunLoop: loop forMode: mode];

}

[IrequestModes addObject: mode];

}

}

GSM_UNLOCK(IrefGate);

}

- (void) addRunLoop: (NSRunLoop*)loop

{

GS_M_LOCK(IrefGate);

if ([self isValid] == YES)

{

if ([IrunLoops indexOfObjectIdenticalTo: loop] == NSNotFound)

{

NSUInteger c = [IrequestModes count];

while (c-- > 0)

{

NSString *mode = [IrequestModes objectAtIndex: c];

[IreceivePort addConnection: self toRunLoop: loop forMode: mode];

}

[IrunLoops addObject: loop];

}

}

GSM_UNLOCK(IrefGate);

}

- (void) dealloc

{

if (debug_connection)

NSLog(@"deallocating %@", self);

[self finalize];

if (internal != nil)

{

GS_DESTROY_INTERNAL(NSConnection);

}

[super dealloc];

}

- (id) delegate

{

return Idelegate;

}

- (NSString*) description

{

return [NSString stringWithFormat: @"%@ local: '%@',%@ remote '%@',%@",

[super description],

IregisteredName ? (id)IregisteredName : (id)@"", [self receivePort],

IremoteName ? (id)IremoteName : (id)@"", [self sendPort]];

}

- (void) enableMultipleThreads

{

ImultipleThreads = YES;

}

- (BOOL) independentConversationQueueing

{

return IindependentQueueing;

}

- (id) init

{

NSPort *port = [NSPort port];

self = [self initWithReceivePort: port sendPort: nil];

return self;

}

- (id) initWithReceivePort: (NSPort*)r

sendPort: (NSPort*)s

{

NSNotificationCenter *nCenter;

NSConnection *parent;

NSConnection *conn;

NSRunLoop *loop;

id del;

NSZone *z;

z = NSDefaultMallocZone();

/*

if (r == nil)

{

if (debug_connection > 2)

{

NSLog(@"Asked to create connection with nil receive port");

}

DESTROY(self);

return self;

}

/*

if (s == nil)

{

s = r;

}

conn = existingConnection(r, s);

/*