static RsslRet snapshotSessionSendSymbolListRequest(SnapshotSession *pSession)
{
RsslRet ret;
RsslError error;
RsslBuffer* msgBuf = 0;
/* get a buffer for the item request*/
msgBuf = rsslGetBuffer(pSession->pRsslChannel, 128, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
/*encode symbol list request*/
if (encodeSymbolListRequest(pSession, msgBuf, SYMBOL_LIST_STREAM_ID) != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\n<%s> Symbol List encodeSymbolListRequest() failed\n", pSession->name);
return RSSL_RET_FAILURE;
}
if ((ret = snapshotSessionWrite(pSession, msgBuf)) != RSSL_RET_SUCCESS)
return ret;
}
else
{
printf("<%s> rsslGetBuffer(): Failed <%s>\n", pSession->name, error.text);
return RSSL_RET_FAILURE;
}
return RSSL_RET_SUCCESS;
}
/*
* Close an item stream for a specific stream id.
* chnl - The channel to send an item close to
* streamId - The stream id of the item close
*/
static RsslRet closeMPItemStream(RsslChannel* chnl, RsslInt32 streamId)
{
RsslError error;
RsslBuffer* msgBuf = 0;
/* get a buffer for the item close */
msgBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
/* encode item close */
if (encodeItemClose(chnl, msgBuf, streamId) != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\nMarket Price encodeItemClose() failed\n");
return RSSL_RET_FAILURE;
}
/* send close */
if (sendMessage(chnl, msgBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
else
{
printf("rsslGetBuffer(): Failed <%s>\n", error.text);
return RSSL_RET_FAILURE;
}
return RSSL_RET_SUCCESS;
}
RsslRet UPAProvider::SendAck(RsslChannel *chnl, RsslPostMsg *postMsg, RsslUInt8 nakCode, char *errText)
{
RsslBuffer *ackBuf;
RsslError error;
RsslRet ret;
// send an ack if it was requested
if (postMsg->flags & RSSL_PSMF_ACK)
{
if ((ackBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error)) == NULL)
{
t42log_error(" UPAProvider::SendAc - rsslGetBuffer() Failed (rsslErrorId = %d)\n", error.rsslErrorId);
return RSSL_RET_FAILURE;
}
if ((ret = EncodeAck(chnl, ackBuf, postMsg, nakCode, errText)) < RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(ackBuf, &error);
t42log_error(" UPAProvider::SendAck - encodeAck() Failed (ret = %d)\n", ret);
return RSSL_RET_FAILURE;
}
if (SendUPAMessage(chnl, ackBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
return RSSL_RET_SUCCESS;
}
/* Sends a basic Login Request on the given streamID, using the RDM package. */
RsslRet sendLoginRequest(ChannelHandler *pChannelHandler, ChannelInfo *pChannelInfo, RsslInt32 streamId, RsslError *error)
{
RsslRDMLoginRequest loginRequest;
RsslRet ret;
RsslBuffer *msgBuf;
RsslErrorInfo errorInfo;
RsslEncodeIterator eIter;
RsslChannelInfo chanInfo;
RsslChannel *pChannel = pChannelInfo->pChannel;
if ((ret = rsslGetChannelInfo(pChannel, &chanInfo, error)) != RSSL_RET_SUCCESS)
{
printf("rsslGetChannelInfo() failed: %d(%s)\n", ret, error->text);
return RSSL_RET_FAILURE;
}
/* Send Login Request */
if ((ret = rsslInitDefaultRDMLoginRequest(&loginRequest, streamId)) != RSSL_RET_SUCCESS)
{
printf("rsslInitDefaultRDMLoginRequest() failed: %d\n", ret);
return RSSL_RET_FAILURE;
}
if (strlen(niProvPerfConfig.username))
{
loginRequest.userName.data = niProvPerfConfig.username;
loginRequest.userName.length = (RsslUInt32)strlen(niProvPerfConfig.username);
}
loginRequest.flags |= RDM_LG_RQF_HAS_ROLE | RDM_LG_RQF_HAS_APPLICATION_NAME;
loginRequest.role = RDM_LOGIN_ROLE_PROV;
loginRequest.applicationName = applicationName;
if (!(msgBuf = rsslGetBuffer(pChannel, chanInfo.maxFragmentSize, RSSL_FALSE, error)))
{
printf("rsslGetBuffer() failed: (%d) %s\n", error->rsslErrorId, error->text);
return ret;
}
rsslClearEncodeIterator(&eIter);
rsslSetEncodeIteratorRWFVersion(&eIter, pChannel->majorVersion, pChannel->minorVersion);
if ( (ret = rsslSetEncodeIteratorBuffer(&eIter, msgBuf)) != RSSL_RET_SUCCESS)
{
printf("rsslSetEncodeIteratorBuffer() failed: %d(%s)\n", ret, errorInfo.rsslError.text);
return ret;
}
if ((ret = rsslEncodeRDMLoginMsg(&eIter, (RsslRDMLoginMsg*)&loginRequest, &msgBuf->length, &errorInfo)) != RSSL_RET_SUCCESS)
{
printf("rsslEncodeRDMLoginMsg() failed: %d(%s)\n", ret, errorInfo.rsslError.text);
return ret;
}
return channelHandlerWriteChannel(pChannelHandler, pChannelInfo, msgBuf, 0);
}
RsslRet snapshotSessionProcessChannelActive(SnapshotSession *pSession)
{
RsslEncodeIterator encodeIter;
RsslRDMLoginRequest loginRequest;
RsslBuffer *pBuffer;
RsslErrorInfo rsslErrorInfo;
RsslError rsslError;
RsslRet ret = RSSL_RET_FAILURE;
/* Get a buffer from the channel for writing. */
if (!(pBuffer = rsslGetBuffer(pSession->pRsslChannel, 1024, RSSL_FALSE, &rsslError)))
{
printf("<%s> rsslGetBuffer() failed while sending login request: %d (%s -- %s).\n\n",
pSession->name,
rsslError.rsslErrorId, rsslRetCodeToString(rsslError.rsslErrorId), rsslError.text);
return rsslError.rsslErrorId;
}
/* Populate the login request with some default information. */
if ((ret = rsslInitDefaultRDMLoginRequest(&loginRequest, LOGIN_STREAM_ID)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslInitDefaultRDMLoginRequest() failed: %d(%s).\n\n",
pSession->name, ret, rsslRetCodeToString(ret));
rsslReleaseBuffer(pBuffer, &rsslError);
return ret;
}
/* Encode the login request using the RDM package encoder utility. This will
* translate the login request structure to an encoded message and set the proper length
* on the buffer. */
rsslClearEncodeIterator(&encodeIter);
rsslSetEncodeIteratorRWFVersion(&encodeIter, pSession->pRsslChannel->majorVersion,
pSession->pRsslChannel->minorVersion);
rsslSetEncodeIteratorBuffer(&encodeIter, pBuffer);
if ((ret = rsslEncodeRDMLoginMsg(&encodeIter, (RsslRDMLoginMsg*)&loginRequest, &pBuffer->length,
&rsslErrorInfo)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslEncodeRDMLoginMsg() failed: %d (%s -- %s).\n\n",
pSession->name,
ret, rsslRetCodeToString(ret), rsslErrorInfo.rsslError.text);
rsslReleaseBuffer(pBuffer, &rsslError);
return ret;
}
/* Write the message. */
if ((ret = snapshotSessionWrite(pSession, pBuffer)) != RSSL_RET_SUCCESS)
return ret;
pSession->state = SNAPSHOT_STATE_LOGIN_REQUESTED;
return RSSL_RET_SUCCESS;
}
RsslRet publishDirectoryRefresh(ChannelHandler *pChannelHandler, ChannelInfo *pChannelInfo, RsslInt32 streamId)
{
RsslError error;
RsslBuffer* msgBuf = 0;
RsslRet ret;
RsslChannel *pChannel = pChannelInfo->pChannel;
/* get a buffer for the source directory response */
msgBuf = rsslGetBuffer(pChannel, 512, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
RsslEncodeIterator eIter;
RsslErrorInfo errorInfo;
RsslRDMDirectoryRefresh directoryRefresh;
rsslClearRDMDirectoryRefresh(&directoryRefresh);
directoryRefresh.flags = RDM_DR_RFF_HAS_SERVICE_ID | RDM_DR_RFF_CLEAR_CACHE;
directoryRefresh.filter = RDM_DIRECTORY_SERVICE_INFO_FILTER | RDM_DIRECTORY_SERVICE_STATE_FILTER | RDM_DIRECTORY_SERVICE_GROUP_FILTER;
/* StreamId */
directoryRefresh.rdmMsgBase.streamId = streamId;
directoryRefresh.serviceList = &service;
directoryRefresh.serviceCount = 1;
rsslClearEncodeIterator(&eIter);
rsslSetEncodeIteratorRWFVersion(&eIter, pChannel->majorVersion, pChannel->minorVersion);
rsslSetEncodeIteratorBuffer(&eIter, msgBuf);
if ((ret = rsslEncodeRDMDirectoryMsg(&eIter, (RsslRDMDirectoryMsg*)&directoryRefresh, &msgBuf->length, &errorInfo)) != RSSL_RET_SUCCESS)
{
printf("rsslEncodeRDMDirectoryMsg() failed: %d(%s)", ret, errorInfo.rsslError.text);
return ret;
}
return channelHandlerWriteChannel(pChannelHandler, pChannelInfo, msgBuf, 0);
}
else
{
printf("rsslGetBuffer(): Failed <%s>\n", error.text);
return error.rsslErrorId;
}
}
/*
* Redirect a request to a private stream.
* streamId - The stream id to be redirected to private stream
*/
RsslRet redirectToMarketPricePrivateStream(RsslChannel *chnl, RsslInt32 streamId)
{
RsslError error;
RsslBuffer* msgBuf = 0;
/* add item name to private stream list */
addMarketPriceItemName(marketPriceItemInfoList[streamId - MARKETPRICE_STREAM_ID_START].itemname, RSSL_TRUE);
/* remove non-private stream entry from list */
removeMarketPriceItemEntry(chnl, streamId, RSSL_FALSE);
/* get a buffer for the item request */
msgBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
/* encode item request */
if (encodeItemRequest(chnl, msgBuf, nextPrivateStreamId - 1, RSSL_TRUE) != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\nMarket Price encodeItemRequest() failed\n");
return RSSL_RET_FAILURE;
}
/* send item request */
if (sendMessage(chnl, msgBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
else
{
printf("rsslGetBuffer(): Failed <%s>\n", error.text);
return RSSL_RET_FAILURE;
}
return RSSL_RET_SUCCESS;
}
RsslRet processDirectoryRequest(ChannelHandler *pChannelHandler, ChannelInfo *pChannelInfo, RsslMsg* msg, RsslDecodeIterator* dIter)
{
RsslRet ret;
RsslState *pState = 0;
RsslRDMDirectoryMsg directoryMsg;
char directoryMsgChar[4000];
RsslBuffer memoryBuffer = { 4000, directoryMsgChar };
RsslErrorInfo errorInfo;
RsslChannel *pChannel = pChannelInfo->pChannel;
if ((ret = rsslDecodeRDMDirectoryMsg(dIter, msg, &directoryMsg, &memoryBuffer, &errorInfo)) != RSSL_RET_SUCCESS)
{
printf("rsslDecodeRDMDirectoryMsg() failed: %d(%s)\n", ret, errorInfo.rsslError.text);
return ret;
}
switch(directoryMsg.rdmMsgBase.rdmMsgType)
{
case RDM_DR_MT_REQUEST:
{
RsslError error;
RsslBuffer* msgBuf = 0;
RsslChannel *pChannel = pChannelInfo->pChannel;
RsslEncodeIterator eIter;
RsslRDMDirectoryRefresh directoryRefresh;
printf("Received Directory Request.\n\n");
if ((msgBuf = rsslGetBuffer(pChannel, 512, RSSL_FALSE, &error)) == NULL)
{
printf("processDirectoryRequest(): rsslGetBuffer() failed: %d(%s)\n",
error.rsslErrorId, error.text);
return error.rsslErrorId;
}
rsslClearRDMDirectoryRefresh(&directoryRefresh);
directoryRefresh.flags = RDM_DR_RFF_SOLICITED | RDM_DR_RFF_CLEAR_CACHE;
directoryRefresh.filter = directoryMsg.request.filter;
/* StreamId */
directoryRefresh.rdmMsgBase.streamId = directoryMsg.request.rdmMsgBase.streamId;
/* ServiceId */
if (directoryMsg.request.flags & RDM_DR_RQF_HAS_SERVICE_ID)
{
/* Match the ServiceID if requested */
directoryRefresh.flags |= RDM_DR_RFF_HAS_SERVICE_ID;
directoryRefresh.serviceId = directoryMsg.request.serviceId;
if (directoryMsg.request.serviceId == service.serviceId)
{
directoryRefresh.serviceList = &service;
directoryRefresh.serviceCount = 1;
}
}
else
{
directoryRefresh.serviceList = &service;
directoryRefresh.serviceCount = 1;
}
rsslClearEncodeIterator(&eIter);
rsslSetEncodeIteratorRWFVersion(&eIter, pChannel->majorVersion, pChannel->minorVersion);
rsslSetEncodeIteratorBuffer(&eIter, msgBuf);
if ((ret = rsslEncodeRDMDirectoryMsg(&eIter, (RsslRDMDirectoryMsg*)&directoryRefresh, &msgBuf->length, &errorInfo)) != RSSL_RET_SUCCESS)
{
printf("rsslEncodeRDMDirectoryMsg() failed: %d(%s)", ret, errorInfo.rsslError.text);
return ret;
}
return channelHandlerWriteChannel(pChannelHandler, pChannelInfo, msgBuf, 0);
}
case RDM_DR_MT_CLOSE:
printf("\nReceived Source Directory Close for StreamId %d\n", directoryMsg.rdmMsgBase.streamId);
return RSSL_RET_SUCCESS;
default:
printf("\nReceived Unhandled Source Directory Msg Class: %d\n", msg->msgBase.msgClass);
return RSSL_RET_FAILURE;
}
}
//APIQA
RsslRet sendGenericMsgOnLogin(RsslChannel* chnl)
{
RsslRet ret = 0;
RsslGenericMsg msg = RSSL_INIT_GENERIC_MSG;
RsslMap map = RSSL_INIT_MAP;
RsslMapEntry mEntry = RSSL_INIT_MAP_ENTRY;
RsslElementList rsslElementList = RSSL_INIT_ELEMENT_LIST;
RsslBuffer serviceNameBuffer;
RsslEncodeIterator encodeIter;
RsslElementEntry element = RSSL_INIT_ELEMENT_ENTRY;
RsslBuffer* msgBuf;
RsslError error;
RsslUInt warmStandByMode = 1;
serviceNameBuffer.length = 11;
serviceNameBuffer.data = "DIRECT_FEED";
/* clear encode iterator */
rsslClearEncodeIterator(&encodeIter);
/* set-up message */
msg.msgBase.msgClass = RSSL_MC_GENERIC;
msg.msgBase.domainType = RSSL_DMT_LOGIN;
msg.msgBase.containerType = RSSL_DT_MAP;
msg.msgBase.msgKey.name.length = 24;
msg.msgBase.msgKey.name.data = "ConsumerConnectionStatus";
msg.msgBase.msgKey.flags = RSSL_MKF_HAS_NAME;
msg.flags = RSSL_GNMF_HAS_MSG_KEY | RSSL_GNMF_MESSAGE_COMPLETE;
/* get a buffer for the login request */
msgBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error);
/* StreamId */
msg.msgBase.streamId = LOGIN_STREAM_ID;
/* encode message */
if ((ret = rsslSetEncodeIteratorBuffer(&encodeIter, msgBuf)) < RSSL_RET_SUCCESS)
{
printf("rsslSetEncodeIteratorBuffer() failed with return code: %d\n", ret);
return ret;
}
rsslSetEncodeIteratorRWFVersion(&encodeIter, chnl->majorVersion, chnl->minorVersion);
if ((ret = rsslEncodeMsgInit(&encodeIter, (RsslMsg*)&msg, 0)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMsgInit() failed with return code: %d\n", ret);
return ret;
}
/* encode map */
map.keyPrimitiveType = RSSL_DT_ASCII_STRING;
map.containerType = RSSL_DT_ELEMENT_LIST;
if ((ret = rsslEncodeMapInit(&encodeIter, &map, 0, 0)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMapInit() failed with return code: %d\n", ret);
return ret;
}
/* encode map entry */
mEntry.action = RSSL_MPEA_ADD_ENTRY;
if ((ret = rsslEncodeMapEntryInit(&encodeIter, &mEntry, &serviceNameBuffer, 0)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMapEntry() failed with return code: %d\n", ret);
return ret;
}
/* encode the element list */
rsslElementList.flags = RSSL_ELF_HAS_STANDARD_DATA;
if ((ret = rsslEncodeElementListInit(&encodeIter, &rsslElementList, 0, 0)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeElementListInit() failed with return code: %d\n", ret);
return ret;
}
/* WarmStandbyMode */
element.dataType = RSSL_DT_UINT;
element.name = RSSL_ENAME_WARMSTANDBY_MODE;
if ((ret = rsslEncodeElementEntry(&encodeIter, &element, &warmStandByMode)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeElementEntry() failed with return code: %d\n", ret);
return ret;
}
/* complete encode element list */
if ((ret = rsslEncodeElementListComplete(&encodeIter, RSSL_TRUE)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeElementListComplete() failed with return code: %d\n", ret);
return ret;
}
/* complete encode map entry */
if ((ret = rsslEncodeMapEntryComplete(&encodeIter, RSSL_TRUE)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMapEntryComplete() failed with return code: %d\n", ret);
return ret;
}
/* complete encode map */
if ((ret = rsslEncodeMapComplete(&encodeIter, RSSL_TRUE)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMapComplete() failed with return code: %d\n", ret);
return ret;
}
/* complete encode message */
if ((ret = rsslEncodeMsgComplete(&encodeIter, RSSL_TRUE)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMsgComplete() failed with return code: %d\n", ret);
return ret;
}
msgBuf->length = rsslGetEncodedBufferLength(&encodeIter);
if (ret != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\nsendGenericMsgOnLogin() failed with return code: %d\n", ret);
return ret;
}
/* send login request */
if (sendMessage(chnl, msgBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
return RSSL_RET_SUCCESS;
}
RsslRet snapshotSessionRequestItems(SnapshotSession *pSession)
{
RsslUInt32 i;
RsslEncodeIterator encodeIter;
RsslRequestMsg requestMsg;
RsslBuffer *pBuffer;
RsslError rsslError;
RsslRet ret;
for (i = 0; i < itemList.itemCount; ++i)
{
Item *pItem = &itemList.items[i];
if (!(pBuffer = rsslGetBuffer(pSession->pRsslChannel, 128, RSSL_FALSE, &rsslError)))
{
printf("<%s> rsslGetBuffer() failed while sending item request: %d (%s -- %s).\n\n",
pSession->name,
rsslError.rsslErrorId, rsslRetCodeToString(rsslError.rsslErrorId), rsslError.text);
return ret;
}
rsslClearRequestMsg(&requestMsg);
requestMsg.flags = RSSL_RQMF_HAS_QOS;
requestMsg.msgBase.streamId = pItem->snapshotServerStreamId;
requestMsg.msgBase.domainType = pItem->domainType;
requestMsg.msgBase.containerType = RSSL_DT_NO_DATA;
requestMsg.qos.rate = RSSL_QOS_RATE_TICK_BY_TICK;
requestMsg.qos.timeliness = RSSL_QOS_TIME_REALTIME;
/* This system uses the real-time feed's stream ID as the name. */
requestMsg.msgBase.msgKey.flags = RSSL_MKF_HAS_SERVICE_ID | RSSL_MKF_HAS_IDENTIFIER;
requestMsg.msgBase.msgKey.identifier = pItem->feedStreamId;
requestMsg.msgBase.msgKey.serviceId = exampleConfig.serviceId;
rsslClearEncodeIterator(&encodeIter);
rsslSetEncodeIteratorRWFVersion(&encodeIter, pSession->pRsslChannel->majorVersion,
pSession->pRsslChannel->minorVersion);
rsslSetEncodeIteratorBuffer(&encodeIter, pBuffer);
if ((ret = rsslEncodeMsg(&encodeIter, (RsslMsg*)&requestMsg)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslEncodeMsg() failed while sending item request: %d (%s).\n\n",
pSession->name,
ret, rsslRetCodeToString(ret));
rsslReleaseBuffer(pBuffer, &rsslError);
return ret;
}
pBuffer->length = rsslGetEncodedBufferLength(&encodeIter);
/* Write the message. */
if ((ret = snapshotSessionWrite(pSession, pBuffer)) != RSSL_RET_SUCCESS)
return ret;
printf("<%s> Sent request for item %s, %s on stream %d.\n\n",
pSession->name, pItem->symbolName,
rsslDomainTypeToString(pItem->domainType), pItem->snapshotServerStreamId);
}
return RSSL_RET_SUCCESS;
}
/*
* Publically visable market price request function
*
* Sends item requests to a channel. For each item, this
* consists of getting a message buffer, encoding the item
* request, and sending the item request to the server.
* chnl - The channel to send an item request to
*/
RsslRet sendMarketPriceItemRequests(RsslChannel* chnl)
{
RsslError error;
RsslBuffer* msgBuf = 0;
RsslLoginResponseInfo* loginInfo = getLoginResponseInfo();
int i;
/* Do not send a request if there are no items in the item list. */
if(itemCount == 0 && privateStreamItemCount == 0)
return RSSL_RET_SUCCESS;
/* check to see if the provider supports the market price domain */
if(getSourceDirectoryCapabilities(RSSL_DMT_MARKET_PRICE) == RSSL_FALSE)
{
printf("RSSL_DMT_MARKET_PRICE is not supported by the indicated provider\n");
return RSSL_RET_SUCCESS;
}
for (i = 0; i < (MAX_STREAM_ID_RANGE_PER_DOMAIN/2) ; i++)
{
/* initialize state management array */
/* these will be updated as refresh and status messages are received */
marketPriceItemInfoList[i].itemState.dataState = RSSL_DATA_NO_CHANGE;
marketPriceItemInfoList[i].itemState.streamState = RSSL_STREAM_UNSPECIFIED;
}
for (i = 0; i < (MAX_STREAM_ID_RANGE_PER_DOMAIN/2) ; i++)
{
/* initialize state management array */
/* these will be updated as refresh and status messages are received */
marketPricePSItemInfoList[i].itemState.dataState = RSSL_DATA_NO_CHANGE;
marketPricePSItemInfoList[i].itemState.streamState = RSSL_STREAM_UNSPECIFIED;
}
/* send out two sets of requests - one for private stream and one for non-private stream */
/* non-private stream request(s) */
if (itemCount > 0)
{
/* If there is only one item in the itemList, it is a waste of bandwidth to send a batch request */
if((loginInfo->SupportBatchRequests & RDM_LOGIN_BATCH_SUPPORT_REQUESTS) && (itemCount > 1))
{
msgBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
if(encodeBatchItemRequest(chnl, msgBuf, MARKETPRICE_BATCH_STREAM_ID_START, RSSL_FALSE) != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\nMarket Price encodeBatchItemRequest() failed\n");
return RSSL_RET_FAILURE;
}
if (sendMessage(chnl, msgBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
else
{
printf("rsslGetBuffer(): Failed <%s>\n", error.text);
return RSSL_RET_FAILURE;
}
}
else
{
if (itemCount > 1)
printf("\nConnected Provider does not support Batch Requests. Sending Market Price requests as individual request messages.\n");
for (i = 0; i < itemCount; i++)
{
/* get a buffer for the item request */
msgBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
/* encode item request */
if (encodeItemRequest(chnl, msgBuf, (i + MARKETPRICE_STREAM_ID_START), RSSL_FALSE) != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\nMarket Price encodeItemRequest() failed\n");
return RSSL_RET_FAILURE;
}
/* send item request */
if (sendMessage(chnl, msgBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
else
{
printf("rsslGetBuffer(): Failed <%s>\n", error.text);
return RSSL_RET_FAILURE;
}
}
}
}
/* private stream request(s) */
if (privateStreamItemCount > 0)
{
/* If there is only one item in the itemList, it is a waste of bandwidth to send a batch request */
if((loginInfo->SupportBatchRequests & RDM_LOGIN_BATCH_SUPPORT_REQUESTS) && (privateStreamItemCount > 1))
{
msgBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
if(encodeBatchItemRequest(chnl, msgBuf, MARKETPRICE_BATCH_PRIVATE_STREAM_ID_START, RSSL_TRUE) != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\nMarket Price encodeBatchItemRequest() failed\n");
return RSSL_RET_FAILURE;
}
if (sendMessage(chnl, msgBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
else
{
printf("rsslGetBuffer(): Failed <%s>\n", error.text);
return RSSL_RET_FAILURE;
}
}
else
{
if (privateStreamItemCount > 1)
printf("\nConnected Provider does not support Batch Requests. Sending Private Stream Market Price requests as individual request messages.\n");
for (i = 0; i < privateStreamItemCount; i++)
{
/* get a buffer for the item request */
msgBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
/* encode item request */
if (encodeItemRequest(chnl, msgBuf, (i + MARKETPRICE_PRIVATE_STREAM_ID_START), RSSL_TRUE) != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\nMarket Price encodeItemRequest() failed\n");
return RSSL_RET_FAILURE;
}
/* send item request */
if (sendMessage(chnl, msgBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
else
{
printf("rsslGetBuffer(): Failed <%s>\n", error.text);
return RSSL_RET_FAILURE;
}
}
}
}
return RSSL_RET_SUCCESS;
}
/*
* Publically visable - used to close all market price streams
*
* Close all item streams.
* chnl - The channel to send an item close to
*/
RsslRet closeMarketPriceItemStreams(RsslChannel* chnl)
{
RsslBuffer* msgBuf = 0;
RsslError error;
int i;
RsslInt32 batchCloseStreamId;
RsslLoginResponseInfo* loginInfo = getLoginResponseInfo();
/* If provider supports batch close, will use batch close */
if((loginInfo->SupportBatchRequests & RDM_LOGIN_BATCH_SUPPORT_CLOSES) && (itemCount + privateStreamItemCount) > 1)
{
/* get a buffer for the item request */
msgBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
batchCloseStreamId = nextStreamId++;
/* encode batch close */
if (encodeBatchItemClose(chnl, msgBuf, batchCloseStreamId) != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\nMarket Price encodeBatchItemClose() failed\n");
return RSSL_RET_FAILURE;
}
/* send batch close */
if (sendMessage(chnl, msgBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
else
{
printf("rsslGetBuffer(): Failed <%s>\n", error.text);
return RSSL_RET_FAILURE;
}
}
else
{
if ((itemCount + privateStreamItemCount) > 1)
printf("\nConnected Provider does not support Batch Closes. Sending Market Price closes as individual close messages.\n");
/* non-private streams */
for (i = 0; i < itemCount; i++)
{
/* we only want to close a stream if it was not already closed (e.g. rejected by provider, closed via refresh or status, or redirected) */
if (!rsslIsFinalState(&marketPriceItemInfoList[i].itemState))
{
if (closeMPItemStream(chnl, i + MARKETPRICE_STREAM_ID_START) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
}
/* private streams */
for (i = 0; i < privateStreamItemCount; i++)
{
/* we only want to close a stream if it was not already closed (e.g. rejected by provider, closed via refresh or status, or redirected) */
if (!rsslIsFinalState(&marketPricePSItemInfoList[i].itemState))
{
if (closeMPItemStream(chnl, i + MARKETPRICE_PRIVATE_STREAM_ID_START) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
}
}
return RSSL_RET_SUCCESS;
}
/*
* Sends a source directory response to a channel. This consists
* of getting a message buffer, setting the source directory response
* information, encoding the source directory response, and sending
* the source directory response to the server.
* chnl - The channel to send a source directory response to
*/
RsslRet sendSourceDirectoryResponse(RsslChannel* chnl)
{
RsslError error;
RsslBuffer* msgBuf = 0;
RsslSourceDirectoryResponseInfo srcDirRespInfo;
RsslUInt16 refreshFlags = 0;
RsslMsgKey key = RSSL_INIT_MSG_KEY;
/* initialize source directory response info */
initSourceDirRespInfo(&srcDirRespInfo);
/* get a buffer for the source directory response */
msgBuf = rsslGetBuffer(chnl, MAX_MSG_SIZE, RSSL_FALSE, &error);
if (msgBuf != NULL)
{
/* provide source directory response information */
/* set refresh flags */
refreshFlags = RSSL_RFMF_HAS_MSG_KEY | RSSL_RFMF_REFRESH_COMPLETE | RSSL_RFMF_CLEAR_CACHE;
/* set filter flags */
key.filter = RDM_DIRECTORY_SERVICE_INFO_FILTER | \
RDM_DIRECTORY_SERVICE_STATE_FILTER| \
/*RDM_DIRECTORY_SERVICE_GROUP_FILTER | \ not applicable for refresh message - here for reference*/
RDM_DIRECTORY_SERVICE_LOAD_FILTER | \
/*RDM_DIRECTORY_SERVICE_DATA_FILTER | \ not applicable for non-ANSI Page based provider - here for reference*/
RDM_DIRECTORY_SERVICE_LINK_FILTER;
/* StreamId */
srcDirRespInfo.StreamId = SRCDIR_STREAM_ID;
/* ServiceId */
srcDirRespInfo.ServiceId = getServiceId();
/* ServiceName */
snprintf(srcDirRespInfo.ServiceGeneralInfo.ServiceName, 256, "%s", serviceName);
/* Vendor */
snprintf(srcDirRespInfo.ServiceGeneralInfo.Vendor, 256, "%s", vendorName);
/* Capabilities */
srcDirRespInfo.ServiceGeneralInfo.Capabilities[0] = RSSL_DMT_DICTIONARY;
srcDirRespInfo.ServiceGeneralInfo.Capabilities[1] = RSSL_DMT_MARKET_PRICE;
srcDirRespInfo.ServiceGeneralInfo.Capabilities[2] = RSSL_DMT_MARKET_BY_ORDER;
/* DictionariesProvided */
snprintf(srcDirRespInfo.ServiceGeneralInfo.DictionariesProvided[0], 256, "%s", fieldDictionaryName);
snprintf(srcDirRespInfo.ServiceGeneralInfo.DictionariesProvided[1], 256, "%s", enumTypeDictionaryName);
/* DictionariesUsed */
snprintf(srcDirRespInfo.ServiceGeneralInfo.DictionariesUsed[0], 256, "%s", fieldDictionaryName);
snprintf(srcDirRespInfo.ServiceGeneralInfo.DictionariesUsed[1], 256, "%s", enumTypeDictionaryName);
/* Qos */
srcDirRespInfo.ServiceGeneralInfo.QoS[0].dynamic = RSSL_FALSE;
srcDirRespInfo.ServiceGeneralInfo.QoS[0].rate = RSSL_QOS_RATE_TICK_BY_TICK;
srcDirRespInfo.ServiceGeneralInfo.QoS[0].timeliness = RSSL_QOS_TIME_REALTIME;
/* ItemList */
snprintf(srcDirRespInfo.ServiceGeneralInfo.ItemList, 256, "");
/* Service StateInfo Status */
srcDirRespInfo.ServiceStateInfo.Status.streamState = RSSL_STREAM_OPEN;
srcDirRespInfo.ServiceStateInfo.Status.dataState = RSSL_DATA_OK;
srcDirRespInfo.ServiceStateInfo.Status.code = RSSL_SC_NONE;
srcDirRespInfo.ServiceStateInfo.Status.text.data = (char *)"OK";
srcDirRespInfo.ServiceStateInfo.Status.text.length = (RsslUInt32)strlen("OK");
/* OpenLimit */
srcDirRespInfo.ServiceLoadInfo.OpenLimit = OPEN_LIMIT;
srcDirRespInfo.ServiceLoadInfo.OpenWindow = 0; /* Don't send OpenWindow. */
/* Link Name */
snprintf(srcDirRespInfo.ServiceLinkInfo[0].LinkName, 256, "%s", linkName);
/* Link Text */
snprintf(srcDirRespInfo.ServiceLinkInfo[0].Text, 256, "Link state is up");
/* keep default values for all others */
/* encode source directory response */
if (encodeSourceDirectoryResponse(chnl, &srcDirRespInfo, &key, msgBuf, refreshFlags) != RSSL_RET_SUCCESS)
{
rsslReleaseBuffer(msgBuf, &error);
printf("\nencodeSourceDirectoryResponse() failed\n");
return RSSL_RET_FAILURE;
}
/* send source directory response */
if (sendMessage(chnl, msgBuf) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
else
{
printf("rsslGetBuffer(): Failed <%s>\n", error.text);
return RSSL_RET_FAILURE;
}
return RSSL_RET_SUCCESS;
}
