static void
closeConnection(SharedMemoryConnection *connection)
{
/*
* Signal all threads accessing this connection that we are
* shutting down.
*/
if (connection->shutdown) {
sysEventSignal(connection->shutdown);
}
(void)closeStream(&connection->incoming);
(void)closeStream(&connection->outgoing);
if (connection->sharedMemory) {
sysSharedMemClose(connection->sharedMemory, connection->shared);
}
if (connection->otherProcess) {
sysProcessClose(connection->otherProcess);
}
/*
* Ideally we should close the connection->shutdown event and
* free the connection structure. However as closing the
* connection is asynchronous it means that other threads may
* still be accessing the connection structure. On Win32 this
* means we leak 132 bytes and one event per connection. This
* memory will be reclaim at process exit.
*
* if (connection->shutdown)
* sysEventClose(connection->shutdown);
* freeConnection(connection);
*/
}
static jint
doAttach(SharedMemoryTransport *transport)
{
transport->shared->attachingPID = sysProcessGetID();
CHECK_ERROR(sysEventSignal(transport->attachEvent));
CHECK_ERROR(sysEventWait(NULL, transport->acceptEvent));
return SYS_OK;
}
static jint
closeStream(Stream *stream)
{
/*
* Lock stream during close - ignore shutdown event as we are
* closing down and shutdown should be signalled.
*/
CHECK_ERROR(enterMutex(stream, NULL));
/* mark the stream as closed */
stream->state = STATE_CLOSED;
/* wake up waitForData() if it is in sysEventWait() */
sysEventSignal(stream->hasData);
sysEventClose(stream->hasData);
/* wake up waitForSpace() if it is in sysEventWait() */
sysEventSignal(stream->hasSpace);
sysEventClose(stream->hasSpace);
CHECK_ERROR(leaveMutex(stream));
sysIPMutexClose(stream->mutex);
return SYS_OK;
}
jint
shmemBase_accept(SharedMemoryTransport *transport,
long timeout,
SharedMemoryConnection **connectionPtr)
{
jint error;
SharedMemoryConnection *connection;
clearLastError();
CHECK_ERROR(sysEventWait(NULL, transport->attachEvent, timeout));
error = createConnection(transport, transport->shared->attachingPID,
&connection);
if (error != SYS_OK) {
/*
* Reject the attacher
*/
transport->shared->isAccepted = JNI_FALSE;
sysEventSignal(transport->acceptEvent);
freeConnection(connection);
return error;
}
transport->shared->isAccepted = JNI_TRUE;
error = sysEventSignal(transport->acceptEvent);
if (error != SYS_OK) {
/*
* No real point trying to reject it.
*/
closeConnection(connection);
return error;
}
*connectionPtr = connection;
return SYS_OK;
}
static jint
closeStream(Stream *stream, jboolean linger)
{
/*
* Lock stream during close - ignore shutdown event as we are
* closing down and shutdown should be signalled.
*/
CHECK_ERROR(enterMutex(stream, NULL));
/* mark the stream as closed */
stream->state = STATE_CLOSED;
/* wake up waitForData() if it is in sysEventWait() */
sysEventSignal(stream->hasData);
sysEventClose(stream->hasData);
/* wake up waitForSpace() if it is in sysEventWait() */
sysEventSignal(stream->hasSpace);
sysEventClose(stream->hasSpace);
/*
* If linger requested then give the stream a few seconds to
* drain before closing it.
*/
if (linger) {
int attempts = 10;
while (!EMPTY(stream) && attempts>0) {
CHECK_ERROR(leaveMutex(stream));
sysSleep(200);
CHECK_ERROR(enterMutex(stream, NULL));
attempts--;
}
}
CHECK_ERROR(leaveMutex(stream));
sysIPMutexClose(stream->mutex);
return SYS_OK;
}
static jint
signalData(Stream *stream)
{
return sysEventSignal(stream->hasData);
}
static jint
signalSpace(Stream *stream)
{
return sysEventSignal(stream->hasSpace);
}
