ClientMessageBus* ClientProtocolThread::initialize()
{
start();
qxt_d().waiter.wait(&_mutex);
_protocol->moveToThread(_bus->thread());
//Connect all the signals and slots that make the communication work....
//disconnect signal
connect(_protocol, SIGNAL(disconnected()), _bus, SIGNAL(disconnected()), Qt::DirectConnection);
//server calls callback on client
connect(_protocol, SIGNAL(sendCallback(Message)), _bus, SIGNAL(sendCallback(Message)), Qt::DirectConnection);
//server sends return to client
connect(_protocol, SIGNAL(returnReceived(Message)), &_bus->qxt_d(), SLOT(returnReceived(Message)), Qt::DirectConnection);
//server sends event to client
connect(_protocol, SIGNAL(sendEvent(Message)), _bus, SIGNAL(sendEvent(Message)), Qt::DirectConnection);
//client sends return to server
connect(_bus, SIGNAL(callbackReturn(Message)), _protocol, SLOT(callbackReturn(Message)), Qt::DirectConnection);
//client calls function on server (thread boundary)
connect(_bus, SIGNAL(sendFunction(Message)), _protocol, SLOT(sendFunction(Message)), Qt::QueuedConnection);
qxt_d().waiter.wakeAll();
_mutex.unlock();
_initMutex.unlock();
return _bus;
}
void LinksetsResponder::handleTerrainLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL)
{
mTerrainMessagingState = kReceivedError;
if (mObjectMessagingState != kWaiting)
{
sendCallback();
}
}
void LinksetsResponder::handleObjectLinksetsError(U32 pStatus, const std::string &pReason, const std::string &pURL)
{
llwarns << "error with request to URL '" << pURL << "' because " << pReason << " (statusCode:" << pStatus << ")" << llendl;
mObjectMessagingState = kReceivedError;
if (mTerrainMessagingState != kWaiting)
{
sendCallback();
}
}
void LinksetsResponder::handleTerrainLinksetsResult(const LLSD &pContent)
{
mTerrainLinksetPtr = LLPathfindingObjectPtr(new LLPathfindingLinkset(pContent));
mTerrainMessagingState = kReceivedGood;
if (mObjectMessagingState != kWaiting)
{
sendCallback();
}
}
void
handleStunRespSucsessfull(struct hiutResult* result,
int ttl,
struct sockaddr* srcAddr,
struct sockaddr* rflxAddr,
int rtt,
int retransmits)
{
/* char addr[SOCKADDR_MAX_STRLEN]; */
(void) rflxAddr;
if (ttl == MAX_TTL)
{
/* Part of far end alive test */
result->remoteAlive = true;
result->currentTTL = 1;
stunlib_createId(&result->currStunMsgId);
StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx,
result,
(struct sockaddr*)&result->remoteAddr,
(struct sockaddr*)&result->localAddr,
false,
result->username,
result->password,
result->currentTTL,
result->currStunMsgId,
result->sockfd,
result->sendFunc,
StunStatusCallBack,
NULL );
return;
}
bool done = result->num_traces < result->max_recuring ? false : true;
if ( sockaddr_sameAddr( (struct sockaddr*)&result->remoteAddr,srcAddr ) )
{
if (result->path_max_ttl >= ttl)
{
result->path_max_ttl = ttl;
sendCallback(result,
srcAddr,
ttl,
rtt,
retransmits,
true,
done);
resartIfNotDone(result);
return;
}
}
}
// Called for each message this module (program) receives.
int messageHandler(char * caller, char * message_name, long msg_id, char * arguments)
{
// printf("World module handler: %ul %s from: %s v3 \n\n", msg_id, arguments, caller);
//sleep(5);
//char * msg = " asd asdasd asd as dasd ";
char msg[4028];
sprintf(msg, "message: %s %lu \n", arguments, msg_id);
//strcat(msg, arguments);
sendCallback(caller, msg_id, msg);
return 1;
}
void
handleStunRespIcmp(struct hiutResult* result,
int ICMPtype,
int ttl,
struct sockaddr* srcAddr,
int rtt,
int retransmits)
{
if ( (ttl == MAX_TTL) &&
isDstUnreachable(ICMPtype, srcAddr->sa_family) )
{
/* Part of far end alive test */
result->remoteAlive = true;
result->currentTTL = 1;
stunlib_createId(&result->currStunMsgId);
StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx,
result,
(struct sockaddr*)&result->remoteAddr,
(struct sockaddr*)&result->localAddr,
false,
result->username,
result->password,
result->currentTTL,
result->currStunMsgId,
result->sockfd,
result->sendFunc,
StunStatusCallBack,
NULL );
return;
}
if ( isTimeExceeded(ICMPtype, srcAddr->sa_family) )
{
if (result->currentTTL < result->user_max_ttl - 1)
{
result->currentTTL++;
while (result->pathElement[result->currentTTL].inactive &&
result->currentTTL < result->path_max_ttl)
{
result->currentTTL++;
}
if (result->currentTTL <= result->path_max_ttl)
{
sendCallback(result,
srcAddr,
ttl,
rtt,
retransmits,
false,
false);
stunlib_createId(&result->currStunMsgId);
StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx,
result,
(struct sockaddr*)&result->remoteAddr,
(struct sockaddr*)&result->localAddr,
false,
result->username,
result->password,
result->currentTTL,
result->currStunMsgId,
result->sockfd,
result->sendFunc,
StunStatusCallBack,
NULL );
return;
}
}
bool done = result->num_traces < result->max_recuring ? false : true;
sendCallback(result,
srcAddr,
ttl,
rtt,
retransmits,
true,
done);
resartIfNotDone(result);
}
else if ( isDstUnreachable(ICMPtype,srcAddr->sa_family) )
{
bool done = result->num_traces < result->max_recuring ? false : true;
if (result->path_max_ttl >= ttl)
{
result->path_max_ttl = ttl;
sendCallback(result,
srcAddr,
ttl,
rtt,
retransmits,
true,
done);
resartIfNotDone(result);
}
}
}
void
handleStunNoAnswer(struct hiutResult* result)
{
result->pathElement[result->currentTTL].inactive = true;
if (result->currentTTL == MAX_TTL)
{
/* Part of far end alive test */
result->remoteAlive = false;
result->currentTTL = 1;
stunlib_createId(&result->currStunMsgId);
StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx,
result,
(struct sockaddr*)&result->remoteAddr,
(struct sockaddr*)&result->localAddr,
false,
result->username,
result->password,
result->currentTTL,
result->currStunMsgId,
result->sockfd,
result->sendFunc,
StunStatusCallBack,
NULL );
return;
}
/* Hov many no answer in a row? */
if ( (numConcecutiveInactiveNodes(result) >= MAX_CONCECUTIVE_INACTIVE) &&
!result->remoteAlive )
{
bool done = result->num_traces < result->max_recuring ? false : true;
result->path_max_ttl = result->currentTTL - MAX_CONCECUTIVE_INACTIVE;
sendCallback(result,
NULL,
result->currentTTL,
0,
0,
true,
done);
resartIfNotDone(result);
return;
}
sendCallback(result,
NULL,
result->currentTTL,
0,
0,
false,
false);
if (result->currentTTL < result->user_max_ttl)
{
while (result->pathElement[result->currentTTL].inactive &&
result->currentTTL < result->path_max_ttl)
{
result->currentTTL++;
}
stunlib_createId(&result->currStunMsgId);
StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx,
result,
(struct sockaddr*)&result->remoteAddr,
(struct sockaddr*)&result->localAddr,
false,
result->username,
result->password,
result->currentTTL,
result->currStunMsgId,
result->sockfd,
result->sendFunc,
StunStatusCallBack,
NULL );
}
}
void CheckBox::setChecked(bool newVal) {
checked = newVal;
invalidate();
sendCallback(STATECHANGED);
}
