ConnectivityAgentError L1InterfaceStub::sendData(CDataAccessor & accessor)
{
LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
ConnectivityAgentError result(ConnectivityAgentError::ERROR_NOT_FOUND);
mRegistryMutex.lock();
tChannelsRegistryMap::iterator iter = mL1ChannelRegistry.find(accessor.getChannelID());
if (iter != mL1ChannelRegistry.end())
{
Buffer buf;
UInt32 size = accessor.getDataSize();
assert (size <= MAX_SIZE);
LOG4CPLUS_INFO(logger, "L1InterfaceStub::sendData() => Overall data bytes " +
convertIntegerToString(size));
buf.reserveSize(size);
buf.setFilledSize(size);
memcpy(buf.getData(), accessor.getData(), accessor.getDataSize());
result = (iter->second.mpSourceAgent->fillBuffer(buf));
}
else
{
LOG4CPLUS_ERROR(logger, "L1InterfaceStub::sendData() => channel not found!");
result.setErrorCode(ConnectivityAgentError::ERROR_NOT_FOUND);
}
mRegistryMutex.unlock();
return result;
}
bool L1InterfaceStub::processClientAllocateRequest(CDataAccessor & accessor,
const iviLink::Ipc::DirectionID dirId)
{
LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
const UInt32 channel_id = accessor.getChannelID();
if(CA_SERVICE_CHANNEL == channel_id)
{
// SEQ_E_5
LOG4CPLUS_WARN(logger, "Channel CA_SERVICE_CHANNEL is not allowed to be open");
accessor.resetData();
accessor.setErrorCode(ConnectivityAgentError::ERROR_CHANNEL_BUSY);
return true;
}
UInt32 prio = 0;
memcpy(&prio, accessor.getData(), accessor.getDataSize());
LOG4CPLUS_INFO(logger, "L1InterfaceStub::processClientAllocateRequest() => "
"Allocate Channel Request: ChID = "
+ convertIntegerToString(channel_id) + ", prio = " + convertIntegerToString(prio));
iviLink::Ipc::DirectionID tmpDirId = dirId;
ConnectivityAgentError err = ConnectivityAgentError(ConnectivityAgentError::ERROR_OTHER);
mRequestedMapMutex.lock();
mRegistryMutex.lock();
{
err = beginAllocateChannel(static_cast<TChannelPriority>(prio), channel_id, true,
tmpDirId);
accessor.setErrorCode(err.getCode());
if (err.isNoError())
{
LOG4CPLUS_INFO(logger, "L1InterfaceStub::processClientAllocateRequest() => "
"all ok, sending request to other side" );
err = sendRequest(accessor);
}
}
mRegistryMutex.unlock();
mRequestedMapMutex.unlock();
if (err.isNoError()) //> all ok
{
return false;
}
else
{
// something wrong, need message about error
// SEQ_E_5
assert(err.getCode() != ConnectivityAgentError::ERROR_DEFERRED);
accessor.resetData();
accessor.setErrorCode(err.getCode());
return true;
}
}
void L1InterfaceStub::processServiceDeallocateResponse(CDataAccessor & accessor)
{
UInt32 channel_id = accessor.getChannelID();
UInt32 errCode = 0;
memcpy(&errCode, accessor.getData(), sizeof(UInt32));
ConnectivityAgentError ret(static_cast<ConnectivityAgentError::AgentErrorCodes>(errCode));
LOG4CPLUS_INFO(logger, "L1InterfaceStub::processServiceDeallocateResponse() => "
"Channel deallocated responce id = "
+ convertIntegerToString(channel_id) + " err = " +
convertIntegerToString((int)ret.getCode()));
if (ret.isNoError())
{
ret = deallocateChannel(channel_id);
if (ret.isNoError())
{
bool found = false;
iviLink::Ipc::DirectionID dirId;
mRegistryMutex.lock();
{
tChannelsRegistryMap::iterator iter = mL1ChannelRegistry.find(channel_id);
if (iter != mL1ChannelRegistry.end())
{
dirId = iter->second.mClientDir;
found = true;
mL1ChannelRegistry.erase(iter);
}
}
mRegistryMutex.unlock();
if (found)
{
UInt8* buf = new UInt8[accessor.getObjectSize()];
accessor.copyToRawArray(buf);
BaseError err = mpIpc->asyncRequest(mMsgIdGen.next(),
buf, accessor.getObjectSize(), &dirId);
if (!err.isNoError())
{
LOG4CPLUS_WARN(logger, static_cast<std::string>(err));
}
delete [] buf;
}
else
{
LOG4CPLUS_INFO(logger, "Channel " + convertIntegerToString(channel_id) +
" is not found. Probably, already deleted");
}
}
}
}
void CConnectivityAgentProxy::receiveDataNotification(CDataAccessor & accessor)
{
LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
UInt32 channel_id = accessor.getChannelID();
UInt32 data_size = accessor.getDataSize();
LOG4CPLUS_INFO(logger,
"CConnectivityAgentProxy::receiveDataNotification() => channel "
+ convertIntegerToString(channel_id) + ", data_size "
+ convertIntegerToString(data_size));
mRegistryMutex.lockRead();
tChannelsRegistryMap::iterator iter = mChannelRegistry.find(channel_id);
if (iter != mChannelRegistry.end())
{
Buffer *buf = &(iter->second.mChannelBuffer);
UInt32 free_size = buf->getAllocatedSize() - buf->getFilledSize();
if (free_size < data_size)
{
mCallbackListMutex.lock();
CCallbackWrapper* pCallback = new CBufferOverflowCallback(iter->second.mpClient,
channel_id);
mCallbackList.push_back(pCallback);
mCallbackListMutex.unlock();
mCallbackSema.signal();
LOG4CPLUS_ERROR(logger,
"CConnectivityAgentProxy::receiveDataNotification() => overflow!");
//copy or not?
} else
{
buf->appendData(accessor.getData(), data_size);
free_size -= data_size;
mCallbackListMutex.lock();
CCallbackWrapper* pCallback = new CDataReceivedCallback(iter->second.mpClient,
channel_id, data_size);
mCallbackList.push_back(pCallback);
mCallbackListMutex.unlock();
mCallbackSema.signal();
}
} else
{
LOG4CPLUS_ERROR(logger,
"CConnectivityAgentProxy::receiveDataNotification() => unknown channel!");
}
mRegistryMutex.unlockRead();
}
ConnectivityAgentError L1InterfaceStub::sendRequest( CDataAccessor & accessor)
{
LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
Buffer buf;
UInt32 offset = 0;
accessor.printContent();
buf.getFilledSize() = accessor.getObjectSize() + sizeof(UInt16);
buf.reserveSize(buf.getFilledSize());
*reinterpret_cast<UInt16*> (buf.getData() + offset) =
ByteOrder::hton16((UInt16)buf.getFilledSize());
offset += 2;
*reinterpret_cast<UInt32*> (buf.getData() + offset) =
ByteOrder::hton32(accessor.getOpCode());
offset += 4;
*reinterpret_cast<UInt32*> (buf.getData() + offset) =
ByteOrder::hton32(accessor.getChannelID());
offset += 4;
*reinterpret_cast<UInt32*> (buf.getData() + offset) =
ByteOrder::hton32(accessor.getDataSize());
offset += 4;
*reinterpret_cast<UInt32*> (buf.getData() + offset) =
ByteOrder::hton32(accessor.getErrorCode());
offset += 4;
if (accessor.getDataSize())
{
memcpy(buf.getData() + offset,accessor.getData(), accessor.getDataSize() );
}
ConnectivityAgentError ret = mL1ChannelRegistry[CA_SERVICE_CHANNEL].
mpSourceAgent->fillBuffer(buf);
buf.forgetData();
return ret;
}
void L1InterfaceStub::processServiceAllocateRequest(CDataAccessor & accessor)
{
const UInt32 channel_id = accessor.getChannelID();
const UInt32 prio = *reinterpret_cast<UInt32*>(accessor.getData());
ConnectivityAgentError err(static_cast<ConnectivityAgentError::AgentErrorCodes>
(accessor.getErrorCode()));
LOG4CPLUS_INFO(logger, "L1InterfaceStub::processServiceAllocateRequest()=>"
"Allocate channel prio = " + convertIntegerToString(prio) +
" id =" + convertIntegerToString(accessor.getChannelID()));
iviLink::Ipc::DirectionID dirId = -1;
accessor.setOpCode(E_ALLOCATE_CHANNEL_RESP);
accessor.resetData();
if (!err.isNoError())
{
// SEQ_E_3
failAllocateChannel(channel_id, dirId);
accessor.setErrorCode(err.getCode());
}
else
{
mRequestedMapMutex.lock();
mRegistryMutex.lock();
{
err = beginAllocateChannel(static_cast<TChannelPriority>(prio), channel_id,
false, dirId);
if (err.getCode() != ConnectivityAgentError::ERROR_DEFERRED)
{
// sending the result to other side
// SEQ_E_4 or ok
accessor.setErrorCode(err.getCode());
sendRequest(accessor);
}
}
mRegistryMutex.unlock();
mRequestedMapMutex.unlock();
if (err.getCode() == ConnectivityAgentError::ERROR_DEFERRED)
{
// all ok, we will wait for the client requesting this channel
// setting timeout
LOG4CPLUS_INFO(logger, "L1InterfaceStub::processServiceAllocateRequest() => "
"channel wasn't requested yet ->set channel to wait and trigger timeout");
assert(mTimeoutManager);
mTimeoutManager->addSubscriber(
new RequestTimeout(E_ALLOCATE_CHANNEL,channel_id, this), 250000);
return;
}
}
if (!err.isNoError())
{
// messagign about failed channel allocation
// SEQ_E_4
if (dirId != -1)
{
sendIpcNotification(accessor, dirId);
}
}
}
bool L1InterfaceStub::processClientGetDeviceList(CDataAccessor & accessor, const iviLink::Ipc::DirectionID dirId)
{
LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
UInt32 number = 0;
if(accessor.getDataSize()<sizeof(UInt32))
{
accessor.resetData();
accessor.setErrorCode(ConnectivityAgentError::ERROR_REQUEST_FAILED);
return true;
}
number=*(reinterpret_cast<UInt32*>(accessor.getData()));
if(number!=0)
{
accessor.resetData();
accessor.setErrorCode(ConnectivityAgentError::ERROR_NOT_FOUND);
return true;
}
else
{
LOG4CPLUS_INFO(logger, "Device Number know, transmitting");
FoundDevice device;
UInt8* serializedData = NULL;
device.mName="N/a";
device.mAddress="";
device.mConnection=CON_UNKNOWN;
if (mpAgent)
{
iviLink::ConnectivityAgent::HAL::CCarrierAdapter* pca = mpAgent->getCurrentCarrierAdapter();
if (pca)
{
const char *remoteAddress = pca->getRemoteAddress();
const char *connTypeName = pca->getTypeName();
if(connTypeName == NULL)
{
connTypeName = "";
}
if(remoteAddress == NULL)
{
remoteAddress = "N/a";
}
std::string typeName = connTypeName;
device.mName = remoteAddress;
device.mAddress = remoteAddress;
if (typeName == "Bluetooth")
{
device.mConnection = CON_BLUETOOTH;
}
else if (typeName == "TCP/IP")
{
device.mConnection = CON_IP;
}
}
}
serializedData = device.serialize();
accessor.resetData();
accessor.setData(serializedData,device.getSerializedSize());
delete[] serializedData;
accessor.setErrorCode(BaseError::IVILINK_NO_ERROR);
return true;
}
}
ERROR_CODE CConnectivityAgentProxy::deallocateChannel(UInt32 channel_id)
{
LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
LOG4CPLUS_INFO(logger,
"CConnectivityAgentProxy::deallocateChannel(chID = "
+ convertIntegerToString(channel_id) + ")");
ERROR_CODE ret = ERR_NOTFOUND;
mRegistryMutex.lockWrite();
// Channel info will be saved in info and removed from registry here.
// In case of some errors, it will be restored in registry.
tChannelInfo info;
tChannelsRegistryMap::iterator iter = mChannelRegistry.find(channel_id);
if (iter == mChannelRegistry.end())
{
LOG4CPLUS_ERROR(logger,
"CConnectivityAgentProxy::deallocateChannel(chID = "
+ convertIntegerToString(channel_id) + ") => ERROR: Channel not found! ");
} else
{
ret = ERR_OK;
info = iter->second;
iter->second.mChannelBuffer.forgetData();
mChannelRegistry.erase(iter);
mChannelOnDeallocSet.insert(channel_id);
}
mRegistryMutex.unlockWrite();
if (ret != ERR_OK)
return ret;
CDataAccessor requestDA;
requestDA.setChannelID(channel_id);
requestDA.setOpCode(E_DEALLOCATE_CHANNEL);
UInt8* buf = new UInt8[requestDA.getObjectSize()];
requestDA.copyToRawArray(buf);
// response will be sent later as a separate request
UInt32 respSize = 0;
CError err = mpIpc->request(mMsgIdGen.next(), buf, requestDA.getObjectSize(), NULL, respSize);
delete[] buf;
if (!err.isNoError())
{
LOG4CPLUS_WARN(logger, static_cast<std::string>(err));
ret = ERR_FAIL;
} else
{
CDataAccessor responseDA;
mDeallocateRequestResultCond.lock();
{
LOG4CPLUS_INFO(logger,
"CConnectivityAgentProxy::deallocateChannel waiting for mLastRequestResultDA");
while (mDeallocateRequestResultMap.find(channel_id) == mDeallocateRequestResultMap.end())
{
LOG4CPLUS_INFO(logger, "before wait");
mDeallocateRequestResultCond.wait();
LOG4CPLUS_INFO(logger, "after wait");
}
responseDA = mDeallocateRequestResultMap[channel_id];
mDeallocateRequestResultMap.erase(channel_id);
}
mDeallocateRequestResultCond.unlock();
if (responseDA.getData())
{
if ((E_DEALLOCATE_CHANNEL_RESP == responseDA.getOpCode())
&& (channel_id == responseDA.getChannelID()))
{
UInt32 data = 0;
memcpy(&data, responseDA.getData(), sizeof(UInt32));
responseDA.resetAll();
ret = static_cast<ERROR_CODE>(data);
} else
{
LOG4CPLUS_ERROR(logger,
"CConnectivityAgentProxy::deallocateChannel() => ERROR: wrong response type("
+ convertIntegerToString(responseDA.getOpCode())
+ ") from Agent !!! ");
ret = ERR_WRONG_SEQUENCE;
}
} else
{
LOG4CPLUS_INFO(logger, "CConnectivityAgentProxy::deallocateChannel() => "
"channel already deleted form other side");
ret = ERR_OK;
}
}
if (ret != ERR_OK)
{
// something gone wrong, we need to restore information in registry
mRegistryMutex.lockWrite();
if (mChannelRegistry.find(channel_id) != mChannelRegistry.end())
{
LOG4CPLUS_WARN(logger, "CConnectivityAgentProxy::deallocateChannel: "
"something gone wrong and I'm unable to restore channel info - "
"there is a channel in registry with such id");
} else
{
mChannelRegistry[channel_id] = info;
info.mChannelBuffer.forgetData();
LOG4CPLUS_INFO(logger,
"CConnectivityAgentProxy::deallocateChannel:"
"unable to delete channel " + convertIntegerToString(channel_id)
+ ", so channel info is restored");
}
mRegistryMutex.unlockWrite();
}
mRegistryMutex.lockWrite();
mChannelOnDeallocSet.erase(channel_id);
mRegistryMutex.unlockWrite();
return ret;
}
