Example #1
0
void L1InterfaceStub::processServiceDeallocateRequest(CDataAccessor & accessor)
{
    UInt32 channel_id = accessor.getChannelID();
    LOG4CPLUS_INFO(logger, "L1InterfaceStub::processServiceDeallocateRequest() => "
            "Channel deallocate request id = " + convertIntegerToString(channel_id));

    ConnectivityAgentError ret = deallocateChannel(channel_id );
    accessor.setOpCode(E_DEALLOCATE_CHANNEL_RESP);
    UInt32 data = ret.getCode();
    accessor.setData(reinterpret_cast<UInt8 *>(&data), sizeof(UInt32));
    sendRequest(accessor);

    if (ret.isNoError())
    {
        LOG4CPLUS_INFO(logger, "L1InterfaceStub::processServiceDeallocateRequest() => "
                "channel successfully deallocated. "
        "Notifying client");

        iviLink::Ipc::DirectionID dirId;
        bool found = false;

        mRegistryMutex.lock();
        tChannelsRegistryMap::iterator iter = mL1ChannelRegistry.find(accessor.getChannelID());
        if (mL1ChannelRegistry.end() != iter)
        {
            dirId = iter->second.mClientDir;
            found = true;

            LOG4CPLUS_INFO(logger, "L1InterfaceStub::processServiceDeallocateRequest() => "
                    "channel found in registry - removing");
            mL1ChannelRegistry.erase(accessor.getChannelID());
        }
        mRegistryMutex.unlock();

        if (found)
        {
            accessor.setOpCode(E_DEALLOCATE_CHANNEL_NTF);
            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;
        }
    } // ret == OK
}
Example #2
0
bool L1InterfaceStub::processClientDeallocateRequest(CDataAccessor & accessor,
        const iviLink::Ipc::DirectionID dirId)
{
    UInt32 channel_id = accessor.getChannelID();
    if(CA_SERVICE_CHANNEL !=channel_id)
    {
        LOG4CPLUS_INFO(logger, "L1InterfaceStub::processClientDeallocateRequest() => "
                "Deallocate Channel Request: ChID = " + convertIntegerToString(channel_id));
        mRegistryMutex.lock();
        tChannelsRegistryMap::iterator iter =  mL1ChannelRegistry.find(channel_id);
        if (iter != mL1ChannelRegistry.end())
        {
            iter->second.mState = E_TRANSITION_CLIENT;
            sendRequest(accessor);
            assert(mTimeoutManager);
            mTimeoutManager->addSubscriber(new RequestTimeout(static_cast<tOpCode>
            (accessor.getOpCode()),channel_id,this ), 250000);
            // ret = ERR_OK;
        }
        else
        {
            LOG4CPLUS_INFO(logger, "L1InterfaceStub::processClientDeallocateRequest() "
                    "=> Deallocate Channel Request: ChID = " +
                    convertIntegerToString(channel_id) + " NOT FOUND!");
            // ret = ERR_NOTFOUND;
        }
        mRegistryMutex.unlock();
    }

    return false;
}
Example #3
0
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;
}
Example #4
0
void L1InterfaceStub::processServiceAllocateResponse(CDataAccessor & accessor)
{
    const UInt32 channel_id = accessor.getChannelID();
    ConnectivityAgentError err(static_cast<ConnectivityAgentError::AgentErrorCodes>
            (accessor.getErrorCode()));

    LOG4CPLUS_TRACE_METHOD(logger, "L1InterfaceStub::processServiceAllocateResponse() => "
            "Channel allocated responce id = "
            + convertIntegerToString(channel_id) + ", err = " +
            convertIntegerToString((int)err.getCode()));

    iviLink::Ipc::DirectionID dirId = -1;

    /// @todo better processing of error codes. PIlin, 31.08.12
    /// There is the error case with wrong processing:
    /// 1) if response with error, obtain ERR_DEFERRED from failAllocateChannel and
    ///   begin deallocation procedure.
    /// 2) if there is no known dirId, channel also needs to be deallocated, even
    /// if its allocation was successfull.
    ///
    /// Here we must initialize channel deallocation procedure, because we unable
    /// to send some message - there is no such in existing protocol.

    if (err.isNoError())
    {
        err = endAllocateChannel(channel_id, dirId);

        if (err.getCode() == ConnectivityAgentError::ERROR_DEFERRED)
        {
            LOG4CPLUS_INFO(logger, "L1InterfaceStub::processServiceAllocateResponse() => "
                    "was E_TRANSITION_AGENT, messaging to other side");
            accessor.setErrorCode(BaseError::IVILINK_NO_ERROR);
            err = sendRequest(accessor);
        }
    }

    if (!err.isNoError() || dirId == -1)
    {
        // SEQ_E_4

        LOG4CPLUS_ERROR(logger, "L1InterfaceStub::processServiceAllocateResponse() => "
                "failed channel allocation");

        failAllocateChannel(channel_id, dirId);
        accessor.setErrorCode(err.getCode());
    }

    if (dirId != -1)
    {
        LOG4CPLUS_INFO(logger, "L1InterfaceStub::processServiceAllocateResponse() => "
                "message about allocation result");
        sendIpcNotification(accessor, dirId);
    }
    else
    {
        LOG4CPLUS_ERROR(logger, "L1InterfaceStub::processServiceAllocateResponse() => "
                "unknown client, failing channel");
    }
}
Example #5
0
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;
    }
}
Example #6
0
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");
            }

        }
    }
}
Example #7
0
bool L1InterfaceStub::processClientSendRequest(CDataAccessor & accessor,
        const iviLink::Ipc::DirectionID dirId)
{
    UInt32 channel_id = accessor.getChannelID();
    if (CA_SERVICE_CHANNEL !=channel_id)
    {
        LOG4CPLUS_INFO(logger, "L1InterfaceStub::processClientSendRequest() => "
                "Send Data Request: ChID = " + convertIntegerToString(channel_id));
        sendData(accessor);
    }
    return false;
}
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();
}
Example #9
0
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 CConnectivityAgentProxy::channelDeletedNotification(CDataAccessor & accessor)
{
	LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
	UInt32 channel_id = accessor.getChannelID();

	mRegistryMutex.lockWrite();
	{
		tChannelsRegistryMap::iterator iter = mChannelRegistry.find(channel_id);
		if (iter == mChannelRegistry.end())
		{
			LOG4CPLUS_INFO(logger,
					"channel " + convertIntegerToString(channel_id) + " is not found");
			if (mChannelOnDeallocSet.find(channel_id) != mChannelOnDeallocSet.end())
			{
				LOG4CPLUS_INFO(logger,
						"channel is being deallocated from this side, signaling about it");
				mDeallocateRequestResultCond.lock();

				mDeallocateRequestResultMap[channel_id] = CDataAccessor();

				mDeallocateRequestResultCond.broadcast();
				mDeallocateRequestResultCond.unlock();
			}
		} else
		{
			LOG4CPLUS_INFO(logger, "channel " + convertIntegerToString(channel_id) + " found");
			mCallbackListMutex.lock();
			{
				CCallbackWrapper* pCallback = new CChannelDeletedCallback(iter->second.mpClient,
						channel_id);
				mCallbackList.push_back(pCallback);
				mCallbackSema.signal();
			}
			mCallbackListMutex.unlock();

			mChannelRegistry.erase(channel_id);
		}

	}
	mRegistryMutex.unlockWrite();
}
Example #11
0
bool L1InterfaceStub::processClientDeallocateByWD(CDataAccessor & accessor,
        const iviLink::Ipc::DirectionID dirId)
{
    LOG4CPLUS_TRACE_METHOD(logger, __PRETTY_FUNCTION__);
    UInt32 channel_id = accessor.getChannelID();
    if(CA_SERVICE_CHANNEL !=channel_id)
    {
        LOG4CPLUS_INFO(logger, "L1InterfaceStub::processClientDeallocateByWD() => "
                "Deallocate Channel Request: ChID = " + convertIntegerToString(channel_id));
        mRegistryMutex.lock();
        tChannelsRegistryMap::iterator iter =  mL1ChannelRegistry.find(channel_id);
        if (iter != mL1ChannelRegistry.end())
        {
            iter->second.mClientDir = dirId; // so that Negotiator receives the response
            iter->second.mState = E_TRANSITION_CLIENT;
            accessor.setOpCode(E_DEALLOCATE_CHANNEL);
            sendRequest(accessor);
            assert(mTimeoutManager);
            mTimeoutManager->addSubscriber(new RequestTimeout(static_cast<tOpCode>
            (accessor.getOpCode()),channel_id,this ), 250000);
            accessor.setErrorCode(0);
        }
        else
        {
            LOG4CPLUS_INFO(logger, "L1InterfaceStub::processClientDeallocateByWD() "
                    "=> Deallocate Channel Request: ChID = " +
                    convertIntegerToString(channel_id) + " NOT FOUND!");
            accessor.setErrorCode(ConnectivityAgentError::ERROR_NOT_FOUND);
        }
        mRegistryMutex.unlock();
    }
    else
    {
        accessor.setErrorCode(ConnectivityAgentError::ERROR_OTHER);
    }

    return true;
}
void CConnectivityAgentProxy::receiveAllocateChannelResponse(CDataAccessor & accessor)
{
	UInt32 channel_id = accessor.getChannelID();
	ERROR_CODE err = static_cast<ERROR_CODE>(accessor.getErrorCode());

	LOG4CPLUS_TRACE_METHOD(logger,
			"CConnectivityAgentProxy::receiveAllocateChannelResponse"
					" channel_id = " + convertIntegerToString(channel_id) + " err = "
					+ convertIntegerToString((int) err));

	mAllocateRequestCond.lock();
	{
		tAllocateRequestMap::iterator it = mAllocateRequestMap.find(channel_id);
		if (it == mAllocateRequestMap.end())
		{
			LOG4CPLUS_WARN(logger,
					"CConnectivityAgentProxy::receiveAllocateChannelResponse() => channel is not requested");
		} else
		{
			AllocateRequestInfo & info = it->second;
			info.mRequestDone = true;
			info.mResult = err;

			if (ERR_OK == err)
			{
				mRegistryMutex.lockWrite();
				mChannelRegistry[channel_id].mType = info.mType;
				mChannelRegistry[channel_id].mpClient = info.mpClient;
				mChannelRegistry[channel_id].mChannelBuffer.reserveSize(MAX_SIZE);
				mRegistryMutex.unlockWrite();
			}

			mAllocateRequestCond.broadcast();
		}
	}
	mAllocateRequestCond.unlock();
}
Example #13
0
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);
        }
    }
}
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;
}