/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: ?Description
*
*/
#include <sys/socket.h>
#include <string.h>
#include <signal.h>
#include "logger.h"
#include "socketconnection.h"
const unsigned int INVALID_THREAD_ID = 0;
namespace java
{
namespace comms
{
using java::util::ScopedLock;
SocketConnection::SocketConnection(IpcListener* aListener)
: mThreadId(INVALID_THREAD_ID), mListener(aListener), mPort(0)
{
init();
}
SocketConnection::SocketConnection(IpcListener* aListener, int aSocketFd)
: mThreadId(INVALID_THREAD_ID), mSocket(aSocketFd), mListener(aListener), mPort(0)
{
init();
}
void SocketConnection::init()
{
// JELOG2(EJavaComms);
/*
* The SIGPIPE signal will be received if the peer has gone away
* and an attempt is made to write data to the peer. Ignoring this
* signal causes the write operation to receive an EPIPE error.
* Thus, the user is informed about what happened.
*/
#ifndef __SYMBIAN32__
signal(SIGPIPE, SIG_IGN);
#endif
}
SocketConnection::~SocketConnection()
{
}
int SocketConnection::connect(int aPort)
{
// JELOG2(EJavaComms);
if (mThreadId != INVALID_THREAD_ID) return 0;
mPort = aPort;
int rc = mSocket.open(aPort);
if (!rc)
{
rc = pthread_create(&mThreadId, 0, SocketConnection::messageLoop, this);
if (rc!=0)
{
mThreadId = INVALID_THREAD_ID;
ELOG1(EJavaComms, "SocketConnection::start(): pthread_create failed, errno = %d", rc);
}
}
else
{
ELOG1(EJavaComms, "SocketConnection::connect(): failed, rc = %d", rc);
}
return rc;
}
void* SocketConnection::messageLoop(void* params)
{
SocketConnection* me = reinterpret_cast<SocketConnection*>(params);
me->mListener->onStart();
LOG2(EJavaComms, EInfo, "Client %d connected to server %d", me->getSocket(), me->mPort);
int rc = 0;
while (!rc)
{
rc = me->receive();
}
me->mListener->onExit();
LOG2(EJavaComms, EInfo, "Client %d disconnected from server %d", me->getSocket(), me->mPort);
me->mSocket.close();
return 0;
}
void SocketConnection::disconnect()
{
close();
if (mThreadId != INVALID_THREAD_ID)
{
// mSocket.shutdown(SHUT_WR); // sends EOF
int rc = pthread_join(mThreadId, 0);
if (rc)
{
ELOG2(EJavaComms,
"SocketConnection::disconnect(): pthread_join failed %d - %s", rc, strerror(rc));
}
}
mSocket.close();
mThreadId = INVALID_THREAD_ID;
}
void SocketConnection::close()
{
// If a process forks to children processes some things can prevent
// EOF from being seen by a client even though a parent process calls
// close() on a client socket if children processes do not close their
// handle
// let's use additional 'do exit' message to signal other party that
// connection should be closed so that we don't rely on EOF only
ipcMessage_t msg;
msg.ipcHeader.length = 0;
send(&msg);
mSocket.shutdown(SHUT_WR); // sends EOF
}
// returns: 0 in ok
// < 0 in error
int SocketConnection::receive()
{
unsigned int len = 0;
int rc = mSocket.read((char*)&len, sizeof(len));
if (!rc)
{
if (len < sizeof(ipcHeader_t))
{
return -1;
}
char* buf = new char[len];
rc = mSocket.read(buf, len);
if (!rc)
{
ipcMessage_t* msg = reinterpret_cast<ipcMessage_t*>(buf);
msg->ipcHeader.sender = mSocket.getSocket();
msg->ipcHeader.receiver = mSocket.getSocket();
// messages are considered to be always trusted
msg->ipcHeader.permissions = -1;
mListener->processMessage(msg);
}
delete [] buf;
}
return rc;
}
// returns: 0 in ok
// < 0 in error
int SocketConnection::send(ipcMessage_t* aMsg)
{
ScopedLock lock(mSendMutex);
int len = aMsg->ipcHeader.length;
int rc = mSocket.write((char*)&len, sizeof(len));
if (!rc)
{
rc = mSocket.write((char*)aMsg, len);
}
return rc;
}
int SocketConnection::getSocket() const
{
return mSocket.getSocket();
}
} // namespace comms
} // namespace java