void Client::recoverConnectionWithSessionID(int session_id, std::string user_name)
{
AppWarpSessionID = session_id;
userName = user_name;
recoverConnection();
}
/*
* Processes a response from a channel. This consists of
* performing a high level decode of the message and then
* calling the applicable specific function for further
* processing.
* chnl - The channel of the response
* buffer - The message buffer containing the response
*/
static RsslReactorCallbackRet processResponse(RsslReactor *pReactor, RsslReactorChannel *pChannel, RsslMsgEvent* pEvent)
{
NIChannelCommand* chnlCommand = (NIChannelCommand*)pChannel->userSpecPtr;
if(!pEvent->pRsslMsg)
{
printf("processResponse error: %s(%s)\n", pEvent->pErrorInfo->rsslError.text, pEvent->pErrorInfo->errorLocation);
recoverConnection(pReactor, pChannel, chnlCommand);
return RSSL_RC_CRET_SUCCESS;
}
printf("Unhandled Domain Type: %d\n", pEvent->pRsslMsg->msgBase.domainType);
return RSSL_RC_CRET_SUCCESS;
}
/*
* Reads from a channel.
* chnl - The channel to be read from
*/
static RsslRet readFromChannel(RsslChannel* chnl)
{
RsslError error;
RsslBuffer *msgBuf=0;
RsslRet readret;
RsslReadInArgs readInArgs;
if(chnl->socketId != -1 && chnl->state == RSSL_CH_STATE_ACTIVE)
{
readret = 1;
while (readret > 0) /* read until no more to read */
{
rsslClearReadInArgs(&readInArgs);
if ((msgBuf = rsslReadEx(chnl, &readInArgs, &readOutArgs, &readret,&error)) != 0)
{
if (showTransportDetails)
{
printf("\nMessage Details:\n");
printf("Cumulative bytesRead=%d\n", readOutArgs.bytesRead);
printf("Cumulative uncompressedBytesRead=%d\n", readOutArgs.uncompressedBytesRead);
}
if (processResponse(chnl, msgBuf) == RSSL_RET_SUCCESS)
{
/* set flag for server message received */
receivedServerMsg = RSSL_TRUE;
}
else
return RSSL_RET_FAILURE;
}
else
{
switch (readret)
{
case RSSL_RET_CONGESTION_DETECTED:
case RSSL_RET_SLOW_READER:
case RSSL_RET_PACKET_GAP_DETECTED:
{
if (chnl->state != RSSL_CH_STATE_CLOSED)
{
/* disconnectOnGaps must be false. Connection is not closed */
printf("\nRead Error: %s <%d>\n", error.text, readret);
/* break out of switch */
break;
}
/* if channel is closed, we want to fall through */
}
case RSSL_RET_FAILURE:
{
printf("\nchannelInactive fd="SOCKET_PRINT_TYPE" <%s>\n",
chnl->socketId,error.text);
recoverConnection();
}
break;
case RSSL_RET_READ_FD_CHANGE:
{
printf("\nrsslRead() FD Change - Old FD: "SOCKET_PRINT_TYPE" New FD: "SOCKET_PRINT_TYPE"\n", chnl->oldSocketId, chnl->socketId);
FD_CLR(chnl->oldSocketId, &readfds);
FD_CLR(chnl->oldSocketId, &exceptfds);
FD_SET(chnl->socketId, &readfds);
FD_SET(chnl->socketId, &exceptfds);
}
break;
case RSSL_RET_READ_PING:
{
/* set flag for server message received */
receivedServerMsg = RSSL_TRUE;
}
break;
default:
if (readret < 0 && readret != RSSL_RET_READ_WOULD_BLOCK)
{
printf("\nRead Error: %s <%d>\n", error.text, readret);
}
break;
}
}
}
}
else if (chnl->state == RSSL_CH_STATE_CLOSED)
{
printf("Channel fd="SOCKET_PRINT_TYPE" Closed.\n", chnl->socketId);
recoverConnection();
}
return RSSL_RET_SUCCESS;
}
//END APIQA
int main(int argc, char **argv)
{
struct timeval time_interval;
RsslError error;
fd_set useRead;
fd_set useExcept;
fd_set useWrt;
int selRet;
char errTxt[256];
RsslBuffer errorText = {255, (char*)errTxt};
RsslRet retval = 0;
RsslInProgInfo inProg = RSSL_INIT_IN_PROG_INFO;
int i;
RsslInitializeExOpts initOpts = RSSL_INIT_INITIALIZE_EX_OPTS;
time_t currentTime;
#ifdef _WIN32
int rcvBfrSize = 65535;
int sendBfrSize = 65535;
#endif
snprintf(srvrHostname, 128, "%s", defaultSrvrHostname);
snprintf(srvrPortNo, 128, "%s", defaultSrvrPortNo);
snprintf(serviceName, 128, "%s", defaultServiceName);
snprintf(interfaceName, 128, "%s", defaultInterface);
setUsername((char *)"");
setAuthenticationToken((char *)"");
setAuthenticationExtended((char *)"");
setApplicationId((char *)"");
snprintf(proxyHostname, 128, "%s", defaultProxyHost);
snprintf(proxyPort, 128, "%s", defaultProxyPort);
/* Check usage and retrieve operating parameters */
if (argc == 1) /* use default operating parameters */
{
snprintf(itemName, 128, "%s", defaultItemName);
/* add item name in market price handler */
addMarketPriceItemName(itemName, RSSL_FALSE);
mpItemReq = RSSL_TRUE;
printf("\nUsing default operating parameters...\n\n");
printf("srvrHostname: %s\n", srvrHostname);
printf("srvrPortNo: %s\n", srvrPortNo);
printf("serviceName: %s\n", serviceName);
printf("itemName: %s\n", itemName);
printf("connType: %d\n", connType);
}
else if (argc > 1) /* all operating parameters entered by user */
{
i = 1;
while(i < argc)
{
if(strcmp("-libsslName", argv[i]) == 0)
{
i += 2;
snprintf(libsslName, 128, "%s", argv[i-1]);
initOpts.jitOpts.libsslName = libsslName;
}
//APIQA
else if (strcmp("-reissueDir", argv[i]) == 0)
{
printf("Found -reissueDir ");
_initialDirFilter = atoi(argv[++i]);
printf("%d ", _initialDirFilter);
_reissueDirFilter = atoi(argv[++i]);
printf("%d\n", _reissueDirFilter);
setDirectoryFilter(_initialDirFilter, _reissueDirFilter);
break;
}
else if (strcmp("-reissueDict", argv[i]) == 0)
{
printf("Found -reissueDict ");
_initialDictFilter = atoi(argv[++i]);
printf("%d ", _initialDictFilter);
_reissueDictFilter = atoi(argv[++i]);
printf("%d\n", _reissueDictFilter);
setDictionaryFilter(_initialDictFilter, _reissueDictFilter);
break;
}
else if (strcmp("-xmlTrace", argv[i]) == 0)
{
xmlTrace = RSSL_TRUE;
++i;
}
else if (strcmp("-loadDictFromFile", argv[i]) == 0)
{
_loadDictFromFile = RSSL_TRUE;
++i;
}
else if (strcmp("-reissueQos", argv[i]) == 0)
{
_reissueQos = RSSL_TRUE;
_qosRate = atoi(argv[++i]);
_qosTimeliness = atoi(argv[++i]);
printf("\nReissueQoS for rate = %d and timeline = %d\n", _qosRate, _qosTimeliness);
setReissueQos(_qosRate, _qosTimeliness);
break;
}
else if (strcmp("-reissueQosAndWorstQos", argv[i]) == 0)
{
_reissueQosAndWorstQos = RSSL_TRUE;
_qosRate = atoi(argv[++i]);
_qosTimeliness = atoi(argv[++i]);
_worstQosRate = atoi(argv[++i]);
_worstQosTimeliness = atoi(argv[++i]);
printf("\nReissueQoS for rate = %d and timeline = %d\n", _qosRate, _qosTimeliness);
printf("ReissueWorstQos QoS for worstRate = %d and worstTimeliness = %d\n", _worstQosRate, _worstQosTimeliness);
setReissueQosAndWorstQos(_qosRate, _qosTimeliness, _worstQosRate, _worstQosTimeliness);
break;
}
else if (strcmp("-sendGenericMsgOnLogin", argv[i]) == 0)
{
_sendGenMsgOnLogin = RSSL_TRUE;
break;
}
else if (strcmp("-sendGenericMsgOnDirectory", argv[i]) == 0)
{
_sendGenMsgOnDirectory = RSSL_TRUE;
break;
}
else if (strcmp("-requestDict", argv[i]) == 0)
{
_initialDictFilter = atoi(argv[++i]);
break;
}
else if (strcmp("-requestDir", argv[i]) == 0)
{
_initialDirFilter = atoi(argv[++i]);
break;
}
else if (strcmp("-reissueServiceId", argv[i]) == 0)
{
_changeServiceId = atoi(argv[++i]);
printf("\nReissueServiceId to service ID = %d\n", _changeServiceId);
setReissueChangeServiceName(_changeServiceId);
break;
}
else if (strcmp("-privateStreamForItemReq", argv[i]) == 0)
{
setPriviateStream();
++i;
}
else if (strcmp("-requestSameKeyWithDiffStreamId", argv[i]) == 0)
{
setReqSameKeyWithDiffStreamId();
snprintf(itemName, 128, "%s", defaultItemName);
addMarketPriceItemName(itemName, RSSL_FALSE);
break;
}
else if (strcmp("-specificServiceId", argv[i]) == 0)
{
setSpecificServiceId(atoi(argv[++i]));
++i;
}
else if (strcmp("-sendDirReqWithoutLogin", argv[i]) == 0)
{
_sendDirReqWithoutLogin = RSSL_TRUE;
++i;
}
else if (strcmp("-sendDictReqWithoutLogin", argv[i]) == 0)
{
_sendDictReqWithoutLogin = RSSL_TRUE;
++i;
}
else if (strcmp("-sendItemReqWithoutLogin", argv[i]) == 0)
{
_sendItemReqWithoutLogin = RSSL_TRUE;
++i;
}
//END APIQA
else if(strcmp("-libcryptoName", argv[i]) == 0)
{
i += 2;
snprintf(libcryptoName, 128, "%s", argv[i-1]);
initOpts.jitOpts.libcryptoName = libcryptoName;
}
else if(strcmp("-uname", argv[i]) == 0)
{
i += 2;
setUsername(argv[i-1]);
}
else if(strcmp("-at", argv[i]) == 0)
{
i += 2;
setAuthenticationToken(argv[i-1]);
}
else if(strcmp("-ax", argv[i]) == 0)
{
i += 2;
setAuthenticationExtended(argv[i-1]);
}
else if(strcmp("-aid", argv[i]) == 0)
{
i += 2;
setApplicationId(argv[i-1]);
}
else if(strcmp("-h", argv[i]) == 0)
{
i += 2;
snprintf(srvrHostname, 128, "%s", argv[i-1]);
}
else if(strcmp("-p", argv[i]) == 0)
{
i += 2;
snprintf(srvrPortNo, 128, "%s", argv[i-1]);
}
else if(strcmp("-ph", argv[i]) == 0)
{
i += 2;
snprintf(proxyHostname, 128, "%s", argv[i-1]);
}
else if(strcmp("-pp", argv[i]) == 0)
{
i += 2;
snprintf(proxyPort, 128, "%s", argv[i-1]);
}
else if(strcmp("-s", argv[i]) == 0)
{
i += 2;
snprintf(serviceName, 128, "%s", argv[i-1]);
}
else if (strcmp("-c", argv[i]) == 0)
{
i += 1;
if (0 == strcmp(argv[i], "socket") || 0 == strcmp(argv[i], "0"))
connType = RSSL_CONN_TYPE_SOCKET;
else if (0 == strcmp(argv[i], "http") || 0 == strcmp(argv[i], "2"))
connType = RSSL_CONN_TYPE_HTTP;
else if (0 == strcmp(argv[i], "encrypted") || 0 == strcmp(argv[i], "1"))
connType = RSSL_CONN_TYPE_ENCRYPTED;
else if (0 == strcmp(argv[i], "reliableMCast") || 0 == strcmp(argv[i], "4"))
connType = RSSL_CONN_TYPE_RELIABLE_MCAST;
else
{
connType = (RsslConnectionTypes)atoi(argv[i]);
}
i += 1;
}
else if (strcmp("-yc", argv[i]) == 0)
{
i += 2;
/* add item name in yield curve handler */
addYieldCurveItemName(argv[i-1], RSSL_FALSE);
ycItemReq = RSSL_TRUE;
}
else if(strcmp("-mp", argv[i]) == 0)
{
i += 2;
/* add item name in market price handler */
addMarketPriceItemName(argv[i-1], RSSL_FALSE);
mpItemReq = RSSL_TRUE;
}
else if(strcmp("-mbo", argv[i]) == 0)
{
i += 2;
/* add item name in market by order handler */
addMarketByOrderItemName(argv[i-1], RSSL_FALSE);
mboItemReq = RSSL_TRUE;
}
else if(strcmp("-mbp", argv[i]) == 0)
{
i += 2;
/* add item name in market by price handler */
addMarketByPriceItemName(argv[i-1], RSSL_FALSE);
mbpItemReq = RSSL_TRUE;
}
else if(strcmp("-sl", argv[i]) == 0)
{
i++;
slReq = RSSL_TRUE;
/* check the rest of the command line arguments */
if(i != argc)
{
/* check to see if next strings is the symbol list name */
if(!(strncmp("-", argv[i], 1)))
{
/* user didn't specifiy name */
setSymbolListInfo(RSSL_FALSE, slReq);
}
else
{
i++;
setSymbolListName(argv[i-1]);
setSymbolListInfo(RSSL_TRUE, slReq);
}
}
else
{
/* no more command line arguments, so user didn't specifiy SL name */
setSymbolListInfo(RSSL_FALSE, slReq);
}
}
else if(strcmp("-view", argv[i]) == 0)
{
i++;
setViewRequest();
}
else if (strcmp("-post", argv[i]) == 0)
{
i++;
onPostEnabled = RSSL_TRUE;
enableOnstreamPost();
}
else if (strcmp("-x", argv[i]) == 0)
{
i++;
xmlTrace = RSSL_TRUE;
snprintf(traceOutputFile, 128, "RsslConsumer\0");
}
else if (strcmp("-td", argv[i]) == 0)
{
i++;
showTransportDetails = RSSL_TRUE;
}
else if (strcmp("-offpost", argv[i]) == 0)
{
i++;
offPostEnabled = RSSL_TRUE;
}
else if(strcmp("-snapshot", argv[i]) == 0)
{
i++;
setMPSnapshotRequest();
setMBOSnapshotRequest();
setMBPSnapshotRequest();
setSLSnapshotRequest();
setYCSnapshotRequest();
}
else if(strcmp("-mpps", argv[i]) == 0)
{
i += 2;
/* add item name in market price handler */
addMarketPriceItemName(argv[i-1], RSSL_TRUE);
mpItemReq = RSSL_TRUE;
}
else if(strcmp("-mbops", argv[i]) == 0)
{
i += 2;
/* add item name in market by order handler */
addMarketByOrderItemName(argv[i-1], RSSL_TRUE);
mboItemReq = RSSL_TRUE;
}
else if(strcmp("-mbpps", argv[i]) == 0)
{
i += 2;
/* add item name in market by price handler */
addMarketByPriceItemName(argv[i-1], RSSL_TRUE);
mbpItemReq = RSSL_TRUE;
}
else if (strcmp("-ycps", argv[i]) == 0)
{
i += 2;
/* add item name in yield curve handler */
addYieldCurveItemName(argv[i-1], RSSL_TRUE);
ycItemReq = RSSL_TRUE;
}
else if(strcmp("-runtime", argv[i]) == 0)
{
i += 2;
timeToRun = atoi(argv[i-1]);
}
else
{
printf("Error: Unrecognized option: %s\n\n", argv[i]);
printf("Usage: %s or\n%s [-uname <LoginUsername>] [-h <SrvrHostname>] [-p <SrvrPortNo>] [-c <ConnType>] [-s <ServiceName>] [-view] [-post] [-offpost] [-snapshot] [-sl [<SymbolList Name>]] [-mp|-mpps <MarketPrice ItemName>] [-mbo|-mbops <MarketByOrder ItemName>] [-mbp|-mbpps <MarketByPrice ItemName>] [-runtime <seconds>] [-td]\n", argv[0], argv[0]);
printf("\n -mp or -mpps For each occurance, requests item using Market Price domain. (-mpps for private stream)\n");
printf("\n -mbo or -mbops For each occurance, requests item using Market By Order domain. (-mbops for private stream)\n");
printf("\n -mbp or -mbpps For each occurance, requests item using Market By Price domain. (-mbpps for private stream)\n");
printf("\n -yc or -ycps For each occurance, requests item using Yield Curve domain. (-ycps for private stream)\n");
printf("\n -view specifies each request using a basic dynamic view.\n");
printf("\n -post specifies that the application should attempt to send post messages on the first requested Market Price item (i.e., on-stream)\n");
printf("\n -offpost specifies that the application should attempt to send post messages on the login stream (i.e., off-stream)\n");
printf("\n -snapshot specifies each request using non-streaming.\n");
printf("\n -sl requests symbol list using Symbol List domain. (symbol list name optional)\n");
printf("\n -td prints out additional transport details from rsslReadEx() and rsslWriteEx() function calls \n");
printf("\n -x provides an XML trace of messages.\n");
printf("\n -at Specifies the Authentication Token. If this is present, the login user name type will be RDM_LOGIN_USER_AUTHN_TOKEN.\n");
printf("\n -ax Specifies the Authentication Extended information.\n");
printf("\n -aid Specifies the Application ID.\n");
printf("\n -runtime adjusts the time the application runs.\n");
//APIQA
printf("-sendGenericMsgOnLogin\n");
printf("-sendGenericMsgOnDirectory\n");
printf("-requestDict <verbosity>\n");
printf("-requestDir <filters>\n");
printf("-reissueServiceId <service ID>\n");
printf("-reissueDir <initial filter> <reissue filter>\n");
printf("-reissueDict <initial filter> <reissue filter>\n");
printf("-reissueQos <rate> <timeliness>\n");
printf("-reissueQosAndWorstQos <rate> <timeliness> <worstRate> <worstTimeliness>\n");
printf("\nRate value definition\n\t- rate == 0 then RSSL_QOS_RATE_TICK_BY_TICK\n\t- rate == -1 then RSSL_QOS_RATE_JIT_CONFLATED\n\t- if 0 < rate <= 65535, RSSL_QOS_RATE_TIME_CONFLATED using the rate for rateInfo\n");
printf("\nTimeliness value definition\n\t- timeliness == 0 then RSSL_QOS_TIME_REALTIME\n\t- timeliness == -1 then RSSL_QOS_TIME_DELAYED_UNKNOWN\n\t- if 0 < timeliness <= 65535, RSSL_QOS_TIME_DELAYED using the timelines for timeInfo");
//END APIQA
#ifdef _WIN32
/* WINDOWS: wait for user to enter something before exiting */
printf("\nPress Enter or Return key to exit application:");
getchar();
#endif
exit(RSSL_RET_FAILURE);
}
}
//APIQA
setDirectoryFilter(_initialDirFilter, _reissueDirFilter);
setDictionaryFilter(_initialDictFilter, _reissueDictFilter);
//END APIQA
printf("Proxy host: %s\n", proxyHostname);
printf("Proxy port: %s\n", proxyPort);
printf("\nInput arguments...\n\n");
printf("Using Connection Type = %d\n", connType);
printf("srvrHostname: %s\n", srvrHostname);
printf("srvrPortNo: %s\n", srvrPortNo);
printf("serviceName: %s\n", serviceName);
/* if no items were requested but a command line was specified, use the default item */
if (!mpItemReq && !mboItemReq && !mbpItemReq && !slReq && !ycItemReq)
{
snprintf(itemName, 128, "%s", defaultItemName);
/* add item name in market price handler */
addMarketPriceItemName(itemName, RSSL_FALSE);
mpItemReq = RSSL_TRUE;
}
/* this application requires at least one market price item to be requested
for on-stream posting to be performed */
if (onPostEnabled && !mpItemReq)
{
printf("\nPosting will not be performed as no Market Price items were requested\n");
onPostEnabled = RSSL_FALSE;
}
}
/* set service name in directory handler */
setServiceName(serviceName);
/* load dictionary */
//APIQA
//loadDictionary();
if (_loadDictFromFile)
{
loadDictionary();
}
//APIQA
/* Initialize RSSL */
/* RSSL_LOCK_NONE is used since this is a single threaded application. */
if (rsslInitializeEx(&initOpts, &error) != RSSL_RET_SUCCESS)
{
printf("rsslInitialize(): failed <%s>\n", error.text);
/* WINDOWS: wait for user to enter something before exiting */
#ifdef _WIN32
printf("\nPress Enter or Return key to exit application:");
getchar();
#endif
exit(RSSL_RET_FAILURE);
}
FD_ZERO(&readfds);
FD_ZERO(&exceptfds);
FD_ZERO(&wrtfds);
/* Initialize run-time */
initRuntime();
/* this is the main loop */
while(1)
{
/* this is the connection recovery loop */
while(shouldRecoverConnection)
{
/* Connect to RSSL server */
printf("\nAttempting to connect to server %s:%s...\n", srvrHostname, srvrPortNo);
if ((rsslConsumerChannel = connectToRsslServer(connType, &error)) == NULL)
{
printf("Unable to connect to RSSL server: <%s>\n",error.text);
}
else
{
FD_SET(rsslConsumerChannel->socketId, &readfds);
FD_SET(rsslConsumerChannel->socketId, &wrtfds);
FD_SET(rsslConsumerChannel->socketId, &exceptfds);
}
if (rsslConsumerChannel != NULL && rsslConsumerChannel->state == RSSL_CH_STATE_ACTIVE)
shouldRecoverConnection = RSSL_FALSE;
/* Wait for channel to become active. This finalizes the three-way handshake. */
while (rsslConsumerChannel != NULL && rsslConsumerChannel->state != RSSL_CH_STATE_ACTIVE)
{
useRead = readfds;
useWrt = wrtfds;
useExcept = exceptfds;
/* Set a timeout value if the provider accepts the connection, but does not initialize it */
time_interval.tv_sec = 60;
time_interval.tv_usec = 0;
selRet = select(FD_SETSIZE, &useRead, &useWrt, &useExcept, &time_interval);
/* select has timed out, close the channel and attempt to reconnect */
if(selRet == 0)
{
printf("\nChannel initialization has timed out, attempting to reconnect...\n");
FD_CLR(rsslConsumerChannel->socketId, &readfds);
FD_CLR(rsslConsumerChannel->socketId, &exceptfds);
if (FD_ISSET(rsslConsumerChannel->socketId, &wrtfds))
FD_CLR(rsslConsumerChannel->socketId, &wrtfds);
recoverConnection();
}
else
/* Received a response from the provider. */
if(selRet > 0 && (FD_ISSET(rsslConsumerChannel->socketId, &useRead) || FD_ISSET(rsslConsumerChannel->socketId, &useWrt) || FD_ISSET(rsslConsumerChannel->socketId, &useExcept)))
{
if (rsslConsumerChannel->state == RSSL_CH_STATE_INITIALIZING)
{
FD_CLR(rsslConsumerChannel->socketId,&wrtfds);
if ((retval = rsslInitChannel(rsslConsumerChannel, &inProg, &error)) < RSSL_RET_SUCCESS)
{
printf("\nchannelInactive fd="SOCKET_PRINT_TYPE" <%s>\n",
rsslConsumerChannel->socketId,error.text);
recoverConnection();
break;
}
else
{
switch (retval)
{
case RSSL_RET_CHAN_INIT_IN_PROGRESS:
if (inProg.flags & RSSL_IP_FD_CHANGE)
{
printf("\nChannel In Progress - New FD: "SOCKET_PRINT_TYPE" Old FD: "SOCKET_PRINT_TYPE"\n",rsslConsumerChannel->socketId, inProg.oldSocket );
FD_CLR(inProg.oldSocket,&readfds);
FD_CLR(inProg.oldSocket,&exceptfds);
FD_SET(rsslConsumerChannel->socketId,&readfds);
FD_SET(rsslConsumerChannel->socketId,&exceptfds);
FD_SET(rsslConsumerChannel->socketId,&wrtfds);
}
else
{
printf("\nChannel "SOCKET_PRINT_TYPE" In Progress...\n", rsslConsumerChannel->socketId);
//Sleep(1000);
}
break;
case RSSL_RET_SUCCESS:
{
RsslChannelInfo chanInfo;
printf("\nChannel "SOCKET_PRINT_TYPE" Is Active\n" ,rsslConsumerChannel->socketId);
/* reset should recover connection flag */
shouldRecoverConnection = RSSL_FALSE;
/* if device we connect to supports connected component versioning,
* also display the product version of what this connection is to */
if ((retval = rsslGetChannelInfo(rsslConsumerChannel, &chanInfo, &error)) >= RSSL_RET_SUCCESS)
{
RsslUInt32 i;
for (i = 0; i < chanInfo.componentInfoCount; i++)
{
printf("Connected to %s device.\n", chanInfo.componentInfo[i]->componentVersion.data);
}
}
}
break;
default:
printf("\nBad return value fd="SOCKET_PRINT_TYPE" <%s>\n",
rsslConsumerChannel->socketId,error.text);
cleanUpAndExit();
break;
}
}
}
}
else
if(selRet < 0)
{
printf("\nSelect error.\n");
cleanUpAndExit();
}
handleRuntime();
}
/* sleep before trying again */
if (shouldRecoverConnection)
{
for(i = 0; i < CONSUMER_CONNECTION_RETRY_TIME; ++i)
{
#ifdef _WIN32
Sleep(1000);
#else
sleep(1);
#endif
handleRuntime();
}
}
}
/* WINDOWS: change size of send/receive buffer since it's small by default */
#ifdef _WIN32
if (rsslIoctl(rsslConsumerChannel, RSSL_SYSTEM_WRITE_BUFFERS, &sendBfrSize, &error) != RSSL_RET_SUCCESS)
{
printf("rsslIoctl(): failed <%s>\n", error.text);
}
if (rsslIoctl(rsslConsumerChannel, RSSL_SYSTEM_READ_BUFFERS, &rcvBfrSize, &error) != RSSL_RET_SUCCESS)
{
printf("rsslIoctl(): failed <%s>\n", error.text);
}
#endif
/* Initialize ping handler */
initPingHandler(rsslConsumerChannel);
/* Send login request message */
isLoginReissue = RSSL_FALSE;
//APIQA
/*if (sendLoginRequest(rsslConsumerChannel, "rsslConsumer", RSSL_CONSUMER, &loginSuccessCallBack) != RSSL_RET_SUCCESS)
{
cleanUpAndExit();
}*/
if (!_sendDirReqWithoutLogin && !_sendDictReqWithoutLogin && !_sendItemReqWithoutLogin)
{
if (sendLoginRequest(rsslConsumerChannel, "rsslConsumer", RSSL_CONSUMER, &loginSuccessCallBack) != RSSL_RET_SUCCESS)
{
cleanUpAndExit();
}
}
else
{
printf("FALSE\n");
if (_sendDirReqWithoutLogin)
{
sendSourceDirectoryRequest(rsslConsumerChannel, _sendGenMsgOnDirectory);
}
else if (_sendDictReqWithoutLogin)
{
sendDictionaryRequest(rsslConsumerChannel, "RWFFld", FIELD_DICTIONARY_STREAM_ID, _initialDictFilter);
sendDictionaryRequest(rsslConsumerChannel, "RWFEnum", ENUM_TYPE_DICTIONARY_STREAM_ID, _initialDictFilter);
}
else if (_sendItemReqWithoutLogin)
{
printf("Sending MP REQUEST\n");
sendMarketPriceItemRequests(rsslConsumerChannel);
}
}
//END APIQA
/* this is the message processing loop */
while(1)
{
useRead = readfds;
useExcept = exceptfds;
useWrt = wrtfds;
time_interval.tv_sec = 1;
time_interval.tv_usec = 0;
/* Call select() to check for any messages */
selRet = select(FD_SETSIZE,&useRead,
&useWrt,&useExcept,&time_interval);
if (selRet < 0) /* no messages received, continue */
{
#ifdef _WIN32
if (WSAGetLastError() == WSAEINTR)
continue;
#else
if (errno == EINTR)
{
continue;
}
#endif
}
else if (selRet > 0) /* messages received, read from channel */
{
if ((rsslConsumerChannel != NULL) && (rsslConsumerChannel->socketId != -1))
{
if ((FD_ISSET(rsslConsumerChannel->socketId, &useRead)) ||
(FD_ISSET(rsslConsumerChannel->socketId, &useExcept)))
{
if (readFromChannel(rsslConsumerChannel) != RSSL_RET_SUCCESS)
recoverConnection();
}
/* flush for write file descriptor and active state */
if (rsslConsumerChannel != NULL &&
FD_ISSET(rsslConsumerChannel->socketId, &useWrt) &&
rsslConsumerChannel->state == RSSL_CH_STATE_ACTIVE)
{
if ((retval = rsslFlush(rsslConsumerChannel, &error)) < RSSL_RET_SUCCESS)
{
printf("rsslFlush() failed with return code %d - <%s>\n", retval, error.text);
}
else if (retval == RSSL_RET_SUCCESS)
{
/* clear write fd */
FD_CLR(rsslConsumerChannel->socketId, &wrtfds);
}
}
}
}
/* break out of message processing loop if should recover connection */
if (shouldRecoverConnection == RSSL_TRUE)
{
printf("Recovering connection in 5 seconds\n");
connectionRecovery = RSSL_TRUE;
#ifdef _WIN32
Sleep(5000);
#else
sleep(5);
#endif
break;
}
/* Handle pings */
handlePings(rsslConsumerChannel);
/* Handle run-time */
handleRuntime();
if (onPostEnabled || offPostEnabled)
{
/* if configured to post, send post messages if its time */
/* Handle Post */
if (handlePosts(rsslConsumerChannel, connectionRecovery) != RSSL_RET_SUCCESS)
recoverConnection();
connectionRecovery = RSSL_FALSE;
}
if ((currentTime = time(NULL)) < 0)
{
printf("time() failed.\n");
}
// send login reissue if login reissue time has passed
if (canSendLoginReissue == RSSL_TRUE &&
currentTime >= (RsslInt)loginReissueTime)
{
isLoginReissue = RSSL_TRUE;
if (sendLoginRequest(rsslConsumerChannel, "rsslConsumer", RSSL_CONSUMER, &loginSuccessCallBack) != RSSL_RET_SUCCESS)
{
printf("Login reissue failed\n");
}
else
{
printf("Login reissue sent\n");
}
canSendLoginReissue = RSSL_FALSE;
}
}
}
}
/*
* Processes a response from a channel. This consists of
* performing a high level decode of the message and then
* calling the applicable specific function for further
* processing.
* chnl - The channel of the response
* buffer - The message buffer containing the response
*/
static RsslRet processResponse(RsslChannel* chnl, RsslBuffer* buffer)
{
RsslRet ret = 0;
RsslMsg msg = RSSL_INIT_MSG;
RsslDecodeIterator dIter;
RsslLoginResponseInfo *loginRespInfo = NULL;
/* clear decode iterator */
rsslClearDecodeIterator(&dIter);
/* set version info */
rsslSetDecodeIteratorRWFVersion(&dIter, chnl->majorVersion, chnl->minorVersion);
if((ret = rsslSetDecodeIteratorBuffer(&dIter, buffer)) != RSSL_RET_SUCCESS)
{
printf("\nrsslSetDecodeIteratorBuffer() failed with return code: %d\n", ret);
return RSSL_RET_FAILURE;
}
ret = rsslDecodeMsg(&dIter, &msg);
if (ret != RSSL_RET_SUCCESS)
{
printf("\nrsslDecodeMsg(): Error %d on SessionData fd="SOCKET_PRINT_TYPE" Size %d \n", ret, chnl->socketId, buffer->length);
return RSSL_RET_FAILURE;
}
switch ( msg.msgBase.domainType )
{
case RSSL_DMT_LOGIN:
if (processLoginResponse(chnl, &msg, &dIter) != RSSL_RET_SUCCESS)
{
if (isLoginStreamClosed())
{
return RSSL_RET_FAILURE;
}
else if (isLoginStreamClosedRecoverable())
{
recoverConnection();
}
else if (isLoginStreamSuspect())
{
loginRespInfo = getLoginResponseInfo();
/* if not single open provider, close source directory stream and item streams */
if (!loginRespInfo->SingleOpen)
{
if (closeSourceDirectoryStream(rsslConsumerChannel) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
if (closeSymbolListStream(rsslConsumerChannel) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
if (closeYieldCurveItemStreams(rsslConsumerChannel) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
if (closeMarketPriceItemStreams(rsslConsumerChannel) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
if (closeMarketByOrderItemStreams(rsslConsumerChannel) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
if (closeMarketByPriceItemStreams(rsslConsumerChannel) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
isInLoginSuspectState = RSSL_TRUE;
}
}
else
{
if (isInLoginSuspectState)
{
isInLoginSuspectState = RSSL_FALSE;
}
}
break;
case RSSL_DMT_SOURCE:
if (processSourceDirectoryResponse(chnl, &msg, &dIter) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
/* if we have loaded the dictionaries, now that we have the directory, set up posting if its enabled */
if ((isFieldDictionaryLoaded() || isEnumTypeDictionaryLoaded()) && ((onPostEnabled || offPostEnabled) && !postInit))
{
/* Initialize Post Processing after sending the login request message */
/* ensure that provider supports posting - if not, disable posting */
RsslLoginResponseInfo* loginInfo = getLoginResponseInfo();
if (loginInfo->SupportOMMPost == RSSL_TRUE)
{
/* This sets up our basic timing so post messages will be sent periodically */
initPostHandler();
/* posting has been initialized */
postInit = RSSL_TRUE;
}
else
{
/* provider does not support posting, disable it */
onPostEnabled = RSSL_FALSE;
offPostEnabled = RSSL_FALSE;
disableOnstreamPost();
disableOffstreamPost();
printf("\nConnected Provider does not support OMM Posting. Disabling Post functionality.\n");
}
}
break;
case RSSL_DMT_DICTIONARY:
if (processDictionaryResponse(chnl, &msg, &dIter) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
/* Now that we have downloaded dictionaries and directory set up posting if its enabled */
if ((onPostEnabled || offPostEnabled) && !postInit)
{
/* Initialize Post Processing after sending the login request message */
/* ensure that provider supports posting - if not, disable posting */
RsslLoginResponseInfo* loginInfo = getLoginResponseInfo();
if (loginInfo->SupportOMMPost == RSSL_TRUE)
{
/* This sets up our basic timing so post messages will be sent periodically */
initPostHandler();
/* posting has been initialized */
postInit = RSSL_TRUE;
}
else
{
/* provider does not support posting, disable it */
onPostEnabled = RSSL_FALSE;
offPostEnabled = RSSL_FALSE;
disableOnstreamPost();
disableOffstreamPost();
printf("\nConnected Provider does not support OMM Posting. Disabling Post functionality.\n");
}
}
break;
case RSSL_DMT_MARKET_PRICE:
if (!isInLoginSuspectState)
{
if (processMarketPriceResponse(chnl, &msg, &dIter) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
break;
case RSSL_DMT_MARKET_BY_ORDER:
if (!isInLoginSuspectState)
{
if (processMarketByOrderResponse(chnl, &msg, &dIter) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
break;
case RSSL_DMT_MARKET_BY_PRICE:
if (!isInLoginSuspectState)
{
if (processMarketByPriceResponse(chnl, &msg, &dIter) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
break;
case RSSL_DMT_YIELD_CURVE:
if(!isInLoginSuspectState)
{
if (processYieldCurveResponse(chnl, &msg, &dIter) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
break;
case RSSL_DMT_SYMBOL_LIST:
if(!isInLoginSuspectState)
{
if (processSymbolListResponse(&msg, &dIter) != RSSL_RET_SUCCESS)
return RSSL_RET_FAILURE;
}
break;
default:
printf("Unhandled Domain Type: %d\n", msg.msgBase.domainType);
break;
}
return RSSL_RET_SUCCESS;
}
/*** MAIN ***/
int main(int argc, char **argv)
{
RsslErrorInfo error;
RsslError rsslErr;
RsslCreateReactorOptions reactorOpts;
RsslReactorDispatchOptions dispatchOpts;
RsslInt32 j;
RsslReactorOMMNIProviderRole role;
RsslDataDictionary dictionary = RSSL_INIT_DATA_DICTIONARY;
char err[128];
RsslBuffer errBuf = {128, &err[0]};
int selRet;
time_t currentTime = 0;
RsslRet ret;
RsslInitializeExOpts initOpts = RSSL_INIT_INITIALIZE_EX_OPTS;
rsslInitNIChannelCommand(&chnlCommand);
handleConfig(argc, argv, &chnlCommand);
initializeCache(cacheCommandlineOption);
initOpts.jitOpts.libcryptoName = libcryptoName;
initOpts.jitOpts.libsslName = libsslName;
initOpts.jitOpts.libcurlName = libcurlName;
initOpts.rsslLocking = RSSL_LOCK_GLOBAL_AND_CHANNEL;
/* Initialize run-time */
initRuntime();
rsslInitializeEx(&initOpts, &rsslErr);
/* Setup role */
rsslClearOMMNIProviderRole((RsslReactorOMMNIProviderRole*)&role);
role.pLoginRequest = (RsslRDMLoginRequest*)&chnlCommand.loginRequest;
role.loginMsgCallback = processLoginResponse;
role.pDirectoryRefresh = &chnlCommand.directoryRefresh;
role.base.channelEventCallback = channelEventCallback;
role.base.defaultMsgCallback = processResponse;
printf("Connections:\n");
chnlCommand.pRole = (RsslReactorChannelRole*)&role;
chnlCommand.cOpts.rsslConnectOptions.guaranteedOutputBuffers = 500;
chnlCommand.cOpts.rsslConnectOptions.majorVersion = RSSL_RWF_MAJOR_VERSION;
chnlCommand.cOpts.rsslConnectOptions.minorVersion = RSSL_RWF_MINOR_VERSION;
chnlCommand.cOpts.rsslConnectOptions.userSpecPtr = (void*)&chnlCommand;
// printf(" %s:%s:%s\n", chnlCommand.hostName, chnlCommand.port, chnlCommand.serviceName);
printf(" MarketPriceItems:");
for(j = 0; j < CHAN_CMD_MAX_ITEMS; ++j)
{
RsslNIItemInfo *pItem = &chnlCommand.marketPriceItemInfo[j];
if (pItem->isActive)
printf(" %.*s", (int)sizeof(pItem->Itemname), pItem->Itemname);
}
printf(" MarketByOrderItems:");
for(j = 0; j < CHAN_CMD_MAX_ITEMS; ++j)
{
RsslNIItemInfo *pItem = &chnlCommand.marketByOrderItemInfo[j];
if (pItem->isActive)
printf(" %.*s", (int)sizeof(pItem->Itemname), pItem->Itemname);
}
printf("\n");
printf("\n");
/* Load local dictionary */
if(rsslLoadFieldDictionary("RDMFieldDictionary", &dictionary, &errBuf) < RSSL_RET_SUCCESS)
{
printf("Dictionary error: %s\n", errBuf.data);
exit(-1);
}
chnlCommand.dictionary = &dictionary;
initializeCacheDictionary(&dictionary);
rsslClearCreateReactorOptions(&reactorOpts);
reactorOpts.dispatchDecodeMemoryBufferSize = 1024;
setupLoginRequest(&chnlCommand, 1);
setupDirectoryResponseMsg(&chnlCommand, -1);
if (!(pReactor = rsslCreateReactor(&reactorOpts, &error)))
{
printf("Error: %s", error.rsslError.text);
exit(-1);
}
FD_ZERO(&readFds);
FD_ZERO(&writeFds);
FD_ZERO(&exceptFds);
FD_SET(pReactor->eventFd, &readFds);
if (rsslReactorConnect(pReactor, &chnlCommand.cOpts, chnlCommand.pRole, &error) != RSSL_RET_SUCCESS)
printf("Error rsslReactorConnect(): %s\n", error.rsslError.text);
rsslClearReactorDispatchOptions(&dispatchOpts);
//dispatchOpts.pReactorChannel = &chnlCommand.reactorChannel;
printf("Connection started!\n");
while ( RSSL_TRUE )
{
struct timeval selectTime;
int dispatchCount = 0;
fd_set useReadFds = readFds, useWriteFds = writeFds, useExceptFds = exceptFds;
selectTime.tv_sec = 1; selectTime.tv_usec = 0;
handleRuntime();
selRet = select(FD_SETSIZE, &useReadFds, &useWriteFds, &useExceptFds, &selectTime);
if (selRet == 0 ) /* no messages received, send updates and continue */
{
// Update items
updateItemInfo(&chnlCommand);
/* Send market price updates for each connected channel */
if (chnlCommand.startWrite == RSSL_TRUE)
{
if ((chnlCommand.reactorChannel != NULL) && (chnlCommand.reactorChannel->socketId != -1))
{
if (sendItemUpdates(pReactor,chnlCommand.reactorChannel) != RSSL_RET_SUCCESS)
recoverConnection(pReactor, chnlCommand.reactorChannel, &chnlCommand);
}
}
else
{
if (cacheInfo.useCache)
cacheItemData(&chnlCommand);
}
}
else if (selRet > 0)
{
RsslRet ret;
while ((ret = rsslReactorDispatch(pReactor, &dispatchOpts, &error)) > 0);
if(ret < 0)
{
printf("dispatch error! %i\n %s\n %s\n", ret, error.rsslError.text, error.errorLocation);
/* Reactor has shutdown. Clean up and exit. */
cleanUpAndExit();
}
}
/* get current time */
if ((currentTime = time(NULL)) < 0)
{
printf("time() failed.\n");
}
// send login reissue if login reissue time has passed
if (chnlCommand.canSendLoginReissue == RSSL_TRUE &&
currentTime >= (RsslInt)chnlCommand.loginReissueTime)
{
RsslReactorSubmitMsgOptions submitMsgOpts;
RsslErrorInfo rsslErrorInfo;
rsslClearReactorSubmitMsgOptions(&submitMsgOpts);
submitMsgOpts.pRDMMsg = (RsslRDMMsg*)chnlCommand.pRole->ommNIProviderRole.pLoginRequest;
if ((ret = rsslReactorSubmitMsg(pReactor,chnlCommand.reactorChannel,&submitMsgOpts,&rsslErrorInfo)) != RSSL_RET_SUCCESS)
{
printf("Login reissue failed: %d(%s)\n", ret, rsslErrorInfo.rsslError.text);
}
else
{
printf("Login reissue sent\n");
}
chnlCommand.canSendLoginReissue = RSSL_FALSE;
}
}
}
RsslReactorCallbackRet channelEventCallback(RsslReactor *pReactor, RsslReactorChannel *pReactorChannel, RsslReactorChannelEvent *pConnEvent)
{
NIChannelCommand *chanCommand;
#ifdef _WIN32
int rcvBfrSize = 65535;
int sendBfrSize = 65535;
RsslErrorInfo rsslErrorInfo;
#endif
chanCommand = (NIChannelCommand*)pReactorChannel->userSpecPtr;
switch(pConnEvent->channelEventType)
{
case RSSL_RC_CET_CHANNEL_UP:
printf("Connection up!\n");
FD_SET(pReactorChannel->socketId, &readFds);
FD_SET(pReactorChannel->socketId, &exceptFds);
chanCommand->reactorChannel = pReactorChannel;
#ifdef _WIN32
/* WINDOWS: change size of send/receive buffer since it's small by default */
if (rsslReactorChannelIoctl(pReactorChannel, RSSL_SYSTEM_WRITE_BUFFERS, &sendBfrSize, &rsslErrorInfo) != RSSL_RET_SUCCESS)
{
printf("rsslReactorChannelIoctl(): failed <%s>\n", rsslErrorInfo.rsslError.text);
}
if (rsslReactorChannelIoctl(pReactorChannel, RSSL_SYSTEM_READ_BUFFERS, &rcvBfrSize, &rsslErrorInfo) != RSSL_RET_SUCCESS)
{
printf("rsslReactorChannelIoctl(): failed <%s>\n", rsslErrorInfo.rsslError.text);
}
#endif
if (xmlTrace)
{
RsslErrorInfo rsslErrorInfo;
RsslTraceOptions traceOptions;
rsslClearTraceOptions(&traceOptions);
traceOptions.traceMsgFileName = traceOutputFile;
traceOptions.traceFlags |= RSSL_TRACE_TO_FILE_ENABLE | RSSL_TRACE_TO_STDOUT | RSSL_TRACE_TO_MULTIPLE_FILES | RSSL_TRACE_WRITE | RSSL_TRACE_READ;
traceOptions.traceMsgMaxFileSize = 100000000;
rsslReactorChannelIoctl(pReactorChannel, (RsslIoctlCodes)RSSL_TRACE, (void *)&traceOptions, &rsslErrorInfo);
}
break;
case RSSL_RC_CET_WARNING:
/* We have received a warning event for this channel. Print the information and continue. */
printf("Received warning for Channel fd="SOCKET_PRINT_TYPE".\n", pReactorChannel->socketId);
printf(" Error text: %s\n", pConnEvent->pError->rsslError.text);
return RSSL_RC_CRET_SUCCESS;
case RSSL_RC_CET_FD_CHANGE:
printf("Fd change: "SOCKET_PRINT_TYPE" to "SOCKET_PRINT_TYPE"\n", pReactorChannel->oldSocketId, pReactorChannel->socketId);
FD_CLR(pReactorChannel->oldSocketId, &readFds);
FD_CLR(pReactorChannel->oldSocketId, &exceptFds);
FD_SET(pReactorChannel->socketId, &readFds);
FD_SET(pReactorChannel->socketId, &exceptFds);
break;
case RSSL_RC_CET_CHANNEL_DOWN:
printf("Connection down: Channel fd="SOCKET_PRINT_TYPE" Requesting reconnect.\n", pReactorChannel->socketId);
chanCommand = (NIChannelCommand*)pReactorChannel->userSpecPtr;
recoverConnection(pReactor, pReactorChannel, chanCommand);
break;
case RSSL_RC_CET_CHANNEL_READY:
printf("Connection is ready, starting publishing\n");
chanCommand->startWrite = RSSL_TRUE;
break;
default:
printf("Unknown connection event!\n");
return RSSL_RC_CRET_SUCCESS;
}
if (pConnEvent->pError)
printf(" Error text: %s\n", pConnEvent->pError->rsslError.text);
return RSSL_RC_CRET_SUCCESS;
}
