/* ci has been cleared and calling function has verified that channel arguments are non-null.
 * Calling function has also updated hostname and ipAddress
 */
void thomsonreuters::ema::access::getChannelInformation(const RsslReactorChannel* rsslReactorChannel,
												 const RsslChannel* rsslChannel,
												 ChannelInformation& ci) {
  // create channel info
  EmaString componentInfo;
  RsslErrorInfo rsslErrorInfo;
  RsslReactorChannelInfo rsslReactorChannelInfo;

  // if channel is closed, rsslReactorGetChannelInfo does not succeed
  if (rsslReactorGetChannelInfo(const_cast<RsslReactorChannel*>(rsslReactorChannel),
								&rsslReactorChannelInfo, &rsslErrorInfo) == RSSL_RET_SUCCESS) {
	for (unsigned int i = 0; i < rsslReactorChannelInfo.rsslChannelInfo.componentInfoCount; ++i) {
	  componentInfo.append(rsslReactorChannelInfo.rsslChannelInfo.componentInfo[i]->componentVersion.data);
	  if (i < (rsslReactorChannelInfo.rsslChannelInfo.componentInfoCount - 1))
		componentInfo.append(", ");
	}
  }
  else
	componentInfo.append("unavailable");

  ci.connectedComponentInfo(componentInfo)
	.channelState(static_cast<ChannelInformation::ChannelState>(rsslChannel->state))
	.connectionType(static_cast<ChannelInformation::ConnectionType>(rsslChannel->connectionType))
	.protocolType(static_cast<ChannelInformation::ProtocolType>(rsslChannel->protocolType))
	.majorVersion(rsslChannel->majorVersion)
	.minorVersion(rsslChannel->minorVersion)
	.pingTimeout(rsslChannel->pingTimeout);
}
예제 #2
0
void hexToString( EmaString& output, const EmaBuffer& in )
{
	for ( UInt32 idx = 0; idx < in.length(); ++idx )
	{
		char charOmmArray[10];

		hexToChar( charOmmArray, *(in.c_buf() + idx) );

		output.append( charOmmArray );
		
		if ( in.length() > 1 && idx < in.length() - 1 ) output.append( " " );
	}
}
예제 #3
0
char& EmaString::operator[] ( UInt32 pos )
{
    if ( pos > _length )
    {
        EmaString text ( "Attempt to access out of range position in EmaString::operator[](). Passed in index is " );
        text.append ( pos ).append ( " while length is " ).append ( _length ).append ( "." );
        throwOorException ( text );
    }

    return _pString[pos];
}
예제 #4
0
const EmaString& getFActionAsString( FilterEntry::FilterAction action )
{
	switch ( action )
	{
	case FilterEntry::SetEnum :
		return SetString;
	case FilterEntry::UpdateEnum :
		return UpdateString;
	case FilterEntry::ClearEnum :
		return ClearString;
	default :
		{
			TempFAString.set( "Unknown FilterAction value " );
			TempFAString.append( (Int64)action );
		}
		return TempFAString;
	}
}
예제 #5
0
EmaString EmaString::substr ( UInt32 index, UInt32 length ) const
{
    if ( length != EmaString::npos &&
            ( index > _length ||
              index + length > _length )
       )
    {
        EmaString text ( "Attempt to access out of range position in EmaString::substr( UInt32 , UInt32 ) const. Passed in index is " );
        text.append ( index ).append ( " and passed in length is " ).append ( length ).append ( " while length is " ).append ( _length ).append ( "." );
        throwOorException ( text );
        return EmaString();
    }

    EmaString retVal;

    retVal.set ( _pString + index, length );

    return retVal;
}
void ChannelCallbackClient::initialize( RsslRDMLoginRequest* loginRequest, RsslRDMDirectoryRequest* dirRequest )
{
	RsslReactorOMMConsumerRole consumerRole;
	rsslClearOMMConsumerRole( &consumerRole );

	consumerRole.pLoginRequest = loginRequest;
	consumerRole.pDirectoryRequest = dirRequest;
	consumerRole.dictionaryDownloadMode = RSSL_RC_DICTIONARY_DOWNLOAD_NONE;
	consumerRole.loginMsgCallback = OmmConsumerImpl::loginCallback;
	consumerRole.directoryMsgCallback = OmmConsumerImpl::directoryCallback;
	consumerRole.dictionaryMsgCallback = OmmConsumerImpl::dictionaryCallback;
	consumerRole.base.channelEventCallback = OmmConsumerImpl::channelCallback;
	consumerRole.base.defaultMsgCallback = OmmConsumerImpl::itemCallback;
	consumerRole.watchlistOptions.channelOpenCallback = OmmConsumerImpl::channelOpenCallback;
	consumerRole.watchlistOptions.enableWatchlist = RSSL_TRUE;
	consumerRole.watchlistOptions.itemCountHint = _ommConsImpl.getActiveConfig().itemCountHint;
	consumerRole.watchlistOptions.obeyOpenWindow = _ommConsImpl.getActiveConfig().obeyOpenWindow > 0 ? RSSL_TRUE : RSSL_FALSE;
	consumerRole.watchlistOptions.postAckTimeout = _ommConsImpl.getActiveConfig().postAckTimeout;
	consumerRole.watchlistOptions.requestTimeout = _ommConsImpl.getActiveConfig().requestTimeout;
	consumerRole.watchlistOptions.maxOutstandingPosts = _ommConsImpl.getActiveConfig().maxOutstandingPosts;
		
	EmaVector< ChannelConfig* > &consumerActivecfgChannelSet = _ommConsImpl.getActiveConfig().configChannelSet;
	unsigned int channelCfgSetLastIndex = consumerActivecfgChannelSet.size() - 1;

	RsslReactorConnectInfo      *reactorConnectInfo = new RsslReactorConnectInfo[consumerActivecfgChannelSet.size()];
	RsslReactorConnectOptions connectOpt;
	rsslClearReactorConnectOptions( &connectOpt );
	connectOpt.connectionCount = consumerActivecfgChannelSet.size();
	connectOpt.reactorConnectionList = reactorConnectInfo;
	connectOpt.reconnectAttemptLimit = consumerActivecfgChannelSet[channelCfgSetLastIndex]->reconnectAttemptLimit;
	connectOpt.reconnectMinDelay = consumerActivecfgChannelSet[channelCfgSetLastIndex]->reconnectMinDelay;
	connectOpt.reconnectMaxDelay = consumerActivecfgChannelSet[channelCfgSetLastIndex]->reconnectMaxDelay;
	connectOpt.initializationTimeout = 5;

	EmaString channelParams;
	EmaString temp( "Attempt to connect using ");
	if(connectOpt.connectionCount > 1)
		temp = "Attempt to connect using the following list";
	UInt32 supportedConnectionTypeChannelCount = 0;
	EmaString errorStrUnsupportedConnectionType("Unknown connection type. Passed in type is");

	EmaString channelNames;

	
	for(unsigned int i = 0; i < connectOpt.connectionCount; ++i)
	{
		rsslClearReactorConnectInfo(&reactorConnectInfo[i]);

		if ( consumerActivecfgChannelSet[i]->connectionType == RSSL_CONN_TYPE_SOCKET   ||
			consumerActivecfgChannelSet[i]->connectionType == RSSL_CONN_TYPE_HTTP ||
			consumerActivecfgChannelSet[i]->connectionType == RSSL_CONN_TYPE_ENCRYPTED ||
			consumerActivecfgChannelSet[i]->connectionType == RSSL_CONN_TYPE_RELIABLE_MCAST)
		{
			Channel* pChannel = Channel::create( _ommConsImpl, consumerActivecfgChannelSet[i]->name, _pRsslReactor );

			reactorConnectInfo[i].rsslConnectOptions.userSpecPtr = (void*)pChannel;
			consumerActivecfgChannelSet[i]->pChannel = pChannel;

			reactorConnectInfo[i].rsslConnectOptions.majorVersion = RSSL_RWF_MAJOR_VERSION;
			reactorConnectInfo[i].rsslConnectOptions.minorVersion = RSSL_RWF_MINOR_VERSION;
			reactorConnectInfo[i].rsslConnectOptions.protocolType = RSSL_RWF_PROTOCOL_TYPE;		
			reactorConnectInfo[i].rsslConnectOptions.connectionType = consumerActivecfgChannelSet[i]->connectionType;
			reactorConnectInfo[i].rsslConnectOptions.pingTimeout = consumerActivecfgChannelSet[i]->connectionPingTimeout;
			reactorConnectInfo[i].rsslConnectOptions.guaranteedOutputBuffers = consumerActivecfgChannelSet[i]->guaranteedOutputBuffers;
			reactorConnectInfo[i].rsslConnectOptions.sysRecvBufSize = consumerActivecfgChannelSet[i]->sysRecvBufSize;
			reactorConnectInfo[i].rsslConnectOptions.sysSendBufSize = consumerActivecfgChannelSet[i]->sysSendBufSize;
			reactorConnectInfo[i].rsslConnectOptions.numInputBuffers = consumerActivecfgChannelSet[i]->numInputBuffers;

			EmaString strConnectionType;
			switch ( reactorConnectInfo[i].rsslConnectOptions.connectionType )
			{
			case RSSL_CONN_TYPE_SOCKET:
				{
				reactorConnectInfo[i].rsslConnectOptions.compressionType = consumerActivecfgChannelSet[i]->compressionType;
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.address = (char*)static_cast<SocketChannelConfig*>(consumerActivecfgChannelSet[i])->hostName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.serviceName = (char*)static_cast<SocketChannelConfig*>(consumerActivecfgChannelSet[i])->serviceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.tcpOpts.tcp_nodelay = static_cast<SocketChannelConfig*>(consumerActivecfgChannelSet[i])->tcpNodelay;
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.interfaceName = (char*)consumerActivecfgChannelSet[i]->interfaceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.unicastServiceName = (char *) "";
				break;
				}
			case RSSL_CONN_TYPE_ENCRYPTED:
				{
				reactorConnectInfo[i].rsslConnectOptions.compressionType = consumerActivecfgChannelSet[i]->compressionType;
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.address = (char*)static_cast<EncryptedChannelConfig*>(consumerActivecfgChannelSet[i])->hostName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.serviceName = (char*)static_cast<EncryptedChannelConfig*>(consumerActivecfgChannelSet[i])->serviceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.tcpOpts.tcp_nodelay = static_cast<EncryptedChannelConfig*>(consumerActivecfgChannelSet[i])->tcpNodelay;
				reactorConnectInfo[i].rsslConnectOptions.objectName = (char*) static_cast<EncryptedChannelConfig*>(consumerActivecfgChannelSet[i])->objectName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.interfaceName = (char*)consumerActivecfgChannelSet[i]->interfaceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.unicastServiceName = (char *) "";
				break;
				}
			case RSSL_CONN_TYPE_HTTP:
				{
				reactorConnectInfo[i].rsslConnectOptions.compressionType = consumerActivecfgChannelSet[i]->compressionType;
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.address = (char*)static_cast<HttpChannelConfig*>(consumerActivecfgChannelSet[i])->hostName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.serviceName = (char*)static_cast<HttpChannelConfig*>(consumerActivecfgChannelSet[i])->serviceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.tcpOpts.tcp_nodelay = static_cast<HttpChannelConfig*>(consumerActivecfgChannelSet[i])->tcpNodelay;
				reactorConnectInfo[i].rsslConnectOptions.objectName = (char*) static_cast<HttpChannelConfig*>(consumerActivecfgChannelSet[i])->objectName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.interfaceName = (char*)consumerActivecfgChannelSet[i]->interfaceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.unified.unicastServiceName = (char *) "";
				strConnectionType = "RSSL_CONN_TYPE_HTTP";
				break;
				}
			case RSSL_CONN_TYPE_RELIABLE_MCAST:
				{
				ReliableMcastChannelConfig *relMcastCfg = static_cast<ReliableMcastChannelConfig*>(consumerActivecfgChannelSet[i]);
				if(consumerActivecfgChannelSet[i]->interfaceName.empty())
					reactorConnectInfo[i].rsslConnectOptions.connectionInfo.segmented.interfaceName = 0;
				else 
					reactorConnectInfo[i].rsslConnectOptions.connectionInfo.segmented.interfaceName = (char*)consumerActivecfgChannelSet[i]->interfaceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.segmented.recvAddress = (char*) relMcastCfg->recvAddress.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.segmented.recvServiceName = (char*) relMcastCfg->recvServiceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.segmented.unicastServiceName = (char*) relMcastCfg->unicastServiceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.segmented.sendAddress = (char*) relMcastCfg->sendAddress.c_str();
				reactorConnectInfo[i].rsslConnectOptions.connectionInfo.segmented.sendServiceName = (char*) relMcastCfg->sendServiceName.c_str();
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.disconnectOnGaps = relMcastCfg->disconnectOnGap;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.hsmInterface = (char *) relMcastCfg->hsmInterface.c_str();
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.hsmMultAddress = (char *) relMcastCfg->hsmMultAddress.c_str();
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.hsmPort = (char *) relMcastCfg->hsmPort.c_str();
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.hsmInterval =  relMcastCfg->hsmInterval;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.packetTTL =  relMcastCfg->packetTTL;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.tcpControlPort = (char *) relMcastCfg->tcpControlPort.c_str();
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.ndata =  relMcastCfg->ndata;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.nmissing =  relMcastCfg->nmissing;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.nrreq =  relMcastCfg->nrreq;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.tdata =  relMcastCfg->tdata;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.trreq =  relMcastCfg->trreq;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.twait =  relMcastCfg->twait;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.tpphold =  relMcastCfg->tpphold;
				reactorConnectInfo[i].rsslConnectOptions.multicastOpts.tbchold =  relMcastCfg->tbchold;
				break;
				}
			default :
				break;
			}

			pChannel->setChannelState( Channel::ChannelDownEnum );
			_channelList.addChannel( pChannel );
			supportedConnectionTypeChannelCount++;

			channelNames += pChannel->getName();
			if(i < channelCfgSetLastIndex)
			{
				channelNames.append(", ");
				consumerActivecfgChannelSet[i]->reconnectAttemptLimit = connectOpt.reconnectAttemptLimit;
				consumerActivecfgChannelSet[i]->reconnectMaxDelay = connectOpt.reconnectMaxDelay;
				consumerActivecfgChannelSet[i]->reconnectMinDelay = connectOpt.reconnectMinDelay;
				consumerActivecfgChannelSet[i]->xmlTraceFileName =  consumerActivecfgChannelSet[channelCfgSetLastIndex]->xmlTraceFileName;
				consumerActivecfgChannelSet[i]->xmlTraceToFile = consumerActivecfgChannelSet[channelCfgSetLastIndex]->xmlTraceToFile;
				consumerActivecfgChannelSet[i]->xmlTraceToStdout = consumerActivecfgChannelSet[channelCfgSetLastIndex]->xmlTraceToStdout;
				consumerActivecfgChannelSet[i]->xmlTraceToMultipleFiles = consumerActivecfgChannelSet[channelCfgSetLastIndex]->xmlTraceToMultipleFiles;
				consumerActivecfgChannelSet[i]->xmlTraceWrite = consumerActivecfgChannelSet[channelCfgSetLastIndex]->xmlTraceWrite;
				consumerActivecfgChannelSet[i]->xmlTraceRead = consumerActivecfgChannelSet[channelCfgSetLastIndex]->xmlTraceRead;
				consumerActivecfgChannelSet[i]->xmlTraceMaxFileSize = consumerActivecfgChannelSet[channelCfgSetLastIndex]->xmlTraceMaxFileSize;
				consumerActivecfgChannelSet[i]->msgKeyInUpdates = consumerActivecfgChannelSet[channelCfgSetLastIndex]->msgKeyInUpdates;
			}

			if ( OmmLoggerClient::VerboseEnum >= _ommConsImpl.getActiveConfig().loggerConfig.minLoggerSeverity )
			{
				channelParams.clear();
				channelParametersToString(consumerActivecfgChannelSet[i], channelParams);
				temp.append( CR ).append(i+1).append("] ").append(channelParams);
					if(i == (connectOpt.connectionCount -1))
						_ommConsImpl.getOmmLoggerClient().log( _clientName, OmmLoggerClient::VerboseEnum, temp );
			}
		}
		else
		{
			reactorConnectInfo[i].rsslConnectOptions.userSpecPtr = 0;
			errorStrUnsupportedConnectionType.append( consumerActivecfgChannelSet[i]->connectionType )
			.append(" for ")
			.append(consumerActivecfgChannelSet[i]->name);
			if(i < channelCfgSetLastIndex)
				errorStrUnsupportedConnectionType.append(", ");
		}
	} 

	if(supportedConnectionTypeChannelCount > 0)
	{
		connectOpt.rsslConnectOptions.userSpecPtr = (void*) consumerActivecfgChannelSet[0]->pChannel;

		RsslErrorInfo rsslErrorInfo;
		if ( RSSL_RET_SUCCESS != rsslReactorConnect( _pRsslReactor, &connectOpt, (RsslReactorChannelRole*)(&consumerRole), &rsslErrorInfo ) )
		{

			EmaString temp( "Failed to add RsslChannel(s) to RsslReactor. Channel name(s) " );
			temp.append(channelNames ).append( CR )
				.append( "Consumer Name " ).append( _ommConsImpl.getConsumerName() ).append( CR )
				.append( "RsslReactor " ).append( ptrToStringAsHex( _pRsslReactor ) ).append( CR )
				.append( "RsslChannel " ).append( (UInt64)rsslErrorInfo.rsslError.channel ).append( CR )
				.append( "Error Id " ).append( rsslErrorInfo.rsslError.rsslErrorId ).append( CR )
				.append( "Internal sysError " ).append( rsslErrorInfo.rsslError.sysError ).append( CR )
				.append( "Error Location " ).append( rsslErrorInfo.errorLocation ).append( CR )
				.append( "Error Text " ).append( rsslErrorInfo.rsslError.text );

			if ( OmmLoggerClient::ErrorEnum >= _ommConsImpl.getActiveConfig().loggerConfig.minLoggerSeverity )
				_ommConsImpl.getOmmLoggerClient().log( _clientName, OmmLoggerClient::ErrorEnum, temp.trimWhitespace() );

			for(unsigned int i = 0; i < connectOpt.connectionCount; ++i)
			{
				Channel *pChannel =(Channel *) reactorConnectInfo[i].rsslConnectOptions.userSpecPtr;
				if(pChannel)
					Channel::destroy( pChannel );
			}

			delete [] reactorConnectInfo;
			throwIueException( temp );

			return;
		}

		_ommConsImpl.setState( OmmConsumerImpl::RsslChannelDownEnum );
		

		if ( OmmLoggerClient::VerboseEnum >= _ommConsImpl.getActiveConfig().loggerConfig.minLoggerSeverity )
		{
			EmaString temp( "Successfully created a Reactor and Channel(s)" );
			temp.append( CR )
				.append(" Channel name(s) " ).append( channelNames ).append( CR )
				.append( "Consumer Name " ).append( _ommConsImpl.getConsumerName() );
			_ommConsImpl.getOmmLoggerClient().log( _clientName, OmmLoggerClient::VerboseEnum, temp );
		}	

		if(supportedConnectionTypeChannelCount < connectOpt.connectionCount)
			_ommConsImpl.getOmmLoggerClient().log( _clientName, OmmLoggerClient::WarningEnum, errorStrUnsupportedConnectionType );
	}
	else
	{
		delete [] reactorConnectInfo;
		throwIueException( errorStrUnsupportedConnectionType );
	}
	delete [] reactorConnectInfo;
}
void  ChannelCallbackClient::channelParametersToString (ChannelConfig *pChannelCfg, EmaString& strChannelParams)
{
	bool bValidChType = true;
	EmaString strConnectionType;
	EmaString cfgParameters;
	EmaString compType;
	switch ( pChannelCfg->compressionType )
	{
	case RSSL_COMP_ZLIB :
		compType.set( "ZLib" );
		break;
	case RSSL_COMP_LZ4 :
		compType.set( "LZ4" );
		break;
	case RSSL_COMP_NONE :
		compType.set( "None" );
		break;
	default :
		compType.set( "Unknown Compression Type" );
		break;
	}
	switch(pChannelCfg->connectionType)
	{
		case RSSL_CONN_TYPE_SOCKET:
		{
			SocketChannelConfig  *pTempChannelCfg = static_cast<SocketChannelConfig*> (pChannelCfg);
			strConnectionType = "RSSL_CONN_TYPE_SOCKET";
			cfgParameters.append( "hostName " ).append( pTempChannelCfg->hostName ).append( CR )
				.append( "port " ).append( pTempChannelCfg->serviceName ).append( CR )
				.append( "CompressionType " ).append( compType ).append( CR )
				.append( "tcpNodelay " ).append( (pTempChannelCfg->tcpNodelay ? "true" : "false" ) ).append( CR );
			break;
		}
		case RSSL_CONN_TYPE_HTTP:
		{
			HttpChannelConfig  *pTempChannelCfg = static_cast<HttpChannelConfig*> (pChannelCfg);
			strConnectionType = "RSSL_CONN_TYPE_HTTP";
			cfgParameters.append( "hostName " ).append( pTempChannelCfg->hostName ).append( CR )
				.append( "port " ).append( pTempChannelCfg->serviceName ).append( CR )
				.append( "CompressionType " ).append( compType ).append( CR )
				.append( "tcpNodelay " ).append( (pTempChannelCfg->tcpNodelay ? "true" : "false" ) ).append( CR )
				.append("ObjectName ").append(pTempChannelCfg->objectName).append( CR );
			break;
		}
		case RSSL_CONN_TYPE_ENCRYPTED:
		{
			EncryptedChannelConfig  *pTempChannelCfg = static_cast<EncryptedChannelConfig*> (pChannelCfg);
			strConnectionType = "RSSL_CONN_TYPE_ENCRYPTED";
			cfgParameters.append( "hostName " ).append( pTempChannelCfg->hostName ).append( CR )
				.append( "port " ).append( pTempChannelCfg->serviceName ).append( CR )
				.append( "CompressionType " ).append( compType ).append( CR )
				.append( "tcpNodelay " ).append( (pTempChannelCfg->tcpNodelay ? "true" : "false" ) ).append( CR )
				.append("ObjectName ").append(pTempChannelCfg->objectName).append( CR );
			break;
		}
		case RSSL_CONN_TYPE_RELIABLE_MCAST:
		{
			ReliableMcastChannelConfig  *pTempChannelCfg = static_cast<ReliableMcastChannelConfig*> (pChannelCfg);
			strConnectionType = "RSSL_CONN_TYPE_MCAST";
			cfgParameters.append( "RecvAddress " ).append( pTempChannelCfg->recvAddress ).append( CR )
				.append( "RecvPort " ).append( pTempChannelCfg->recvServiceName ).append( CR )
				.append( "SendAddress " ).append( pTempChannelCfg->sendAddress ).append( CR )
				.append( "SendPort " ).append( pTempChannelCfg->sendServiceName ).append( CR )
				.append("UnicastPort ").append( pTempChannelCfg->unicastServiceName).append( CR )
				.append("HsmInterface ").append( pTempChannelCfg->hsmInterface).append( CR )
				.append("HsmMultAddress ").append( pTempChannelCfg->hsmMultAddress).append( CR )
				.append("HsmPort ").append( pTempChannelCfg->hsmPort).append( CR )
				.append("HsmInterval ").append( pTempChannelCfg->hsmInterval).append( CR )
				.append("tcpControlPort ").append( pTempChannelCfg->tcpControlPort).append( CR )
				.append( "DisconnectOnGap " ).append( ( pTempChannelCfg->disconnectOnGap ? "true" : "false" ) ).append( CR )
				.append("PacketTTL ").append( pTempChannelCfg->packetTTL).append( CR )
				.append( "ndata " ).append( pTempChannelCfg->ndata ).append( CR )
				.append( "nmissing " ).append( pTempChannelCfg->nmissing ).append( CR )
				.append( "nrreq " ).append( pTempChannelCfg->nrreq ).append( CR )
				.append( "tdata " ).append( pTempChannelCfg->tdata ).append( CR )
				.append( "trreq " ).append( pTempChannelCfg->trreq ).append( CR )
				.append( "twait " ).append( pTempChannelCfg->twait ).append( CR )
				.append( "tbchold " ).append( pTempChannelCfg->tbchold ).append( CR )
				.append( "tpphold " ).append( pTempChannelCfg->tpphold ).append( CR )
				.append( "pktPoolLimitHigh " ).append( pTempChannelCfg->pktPoolLimitHigh ).append( CR )
				.append( "pktPoolLimitLow " ).append( pTempChannelCfg->pktPoolLimitLow ).append( CR )
				.append( "userQLimit " ).append( pTempChannelCfg->userQLimit ).append( CR );

			break;
		}
		default:
		{
			strConnectionType = "Invalid ChannelType: ";
			strConnectionType.append(pChannelCfg->connectionType)
				.append(" ");
			bValidChType = false;
			break;
		}
	}
	
	strChannelParams.append( strConnectionType ).append( CR )
		.append( "Channel name ").append( pChannelCfg->name ).append( CR )
		.append( "Consumer Name " ).append( _ommConsImpl.getConsumerName() ).append( CR );

	if(bValidChType)
	{
		strChannelParams.append( "RsslReactor " ).append( ptrToStringAsHex( _pRsslReactor ) ).append( CR )
			.append( "InterfaceName " ).append( pChannelCfg->interfaceName ).append( CR )
			.append( cfgParameters)
			.append( "reconnectAttemptLimit " ).append( pChannelCfg->reconnectAttemptLimit ).append( CR )
			.append( "reconnectMinDelay " ).append( pChannelCfg->reconnectMinDelay ).append( " msec" ).append( CR )
			.append( "reconnectMaxDelay " ).append( pChannelCfg->reconnectMaxDelay).append( " msec" ).append( CR )					
			.append( "connectionPingTimeout " ).append( pChannelCfg->connectionPingTimeout ).append( " msec" ).append( CR );
	}
}