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