MyServer::~MyServer()
{
Disconnect();
}
void ConsoleSocket::OnRead()
{
uint32 readlen = (uint32)readBuffer.GetSize();
uint32 len;
char* p;
if ((readlen + m_pBufferPos) >= m_pBufferLen)
{
Disconnect();
return;
}
readBuffer.Read((uint8*)&m_pBuffer[m_pBufferPos], readlen);
m_pBufferPos += readlen;
// let's look for any newline bytes.
p = strchr(m_pBuffer, '\n');
while (p != NULL)
{
// windows is stupid. :P
len = (uint32)((p + 1) - m_pBuffer);
if (*(p - 1) == '\r')
*(p - 1) = '\0';
*p = '\0';
// handle the command
if (*m_pBuffer != '\0')
{
switch (m_state)
{
case STATE_USER:
m_username = string(m_pBuffer);
m_pConsole->Write("password: "******"\r\nAttempting to authenticate. Please wait.\r\n");
m_state = STATE_WAITING;
m_requestNo = ConsoleAuthMgr::getSingleton().GenerateRequestId();
ConsoleAuthMgr::getSingleton().SetRequest(m_requestNo, this);
TestConsoleLogin(m_username, m_password, m_requestNo);
break;
case STATE_LOGGED:
if (!strnicmp(m_pBuffer, "quit", 4))
{
Disconnect();
break;
}
HandleConsoleInput(m_pConsole, m_pBuffer);
break;
}
}
// move the bytes back
if (len == m_pBufferPos)
{
m_pBuffer[0] = '\0';
m_pBufferPos = 0;
}
else
{
memcpy(m_pBuffer, &m_pBuffer[len], m_pBufferPos - len);
m_pBufferPos -= len;
}
p = strchr(m_pBuffer, '\n');
}
}
// ---------------------------------------------------------
// CT_LbsClientPosTp178::CloseTest
// Always called after the test, even if the test leaves
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp178::CloseTest()
{
ClosePositioner();
Disconnect();
}
//-----------------------------------------------------------------------------
// Name: empty()
// Desc:
//-----------------------------------------------------------------------------
void CArmyWar::ReadPackets(void)
{
char data[1400];
struct sockaddr address;
clientData *clList;
int type;
int ind;
int local;
int ret;
char name[50];
DreamMessage mes;
mes.Init(data, sizeof(data));
while(ret = networkClient->GetPacket(mes.data, &address))
{
mes.SetSize(ret);
mes.BeginReading();
type = mes.ReadByte();
switch(type)
{
case DREAMSOCK_MES_ADDCLIENT:
local = mes.ReadByte();
ind = mes.ReadByte();
strcpy(name, mes.ReadString());
AddClient(local, ind, name);
break;
case DREAMSOCK_MES_REMOVECLIENT:
ind = mes.ReadByte();
LogString("Got removeclient %d message", ind);
RemoveClient(ind);
break;
case USER_MES_FRAME:
// Skip sequences
mes.ReadShort();
mes.ReadShort();
for(clList = clientList; clList != NULL; clList = clList->next)
{
// LogString("Reading DELTAFRAME for client %d", clList->index);
ReadDeltaMoveCommand(&mes, clList);
}
break;
case USER_MES_NONDELTAFRAME:
// Skip sequences
mes.ReadShort();
mes.ReadShort();
clList = clientList;
for(clList = clientList; clList != NULL; clList = clList->next)
{
LogString("Reading NONDELTAFRAME for client %d", clList->index);
ReadMoveCommand(&mes, clList);
}
break;
case USER_MES_SERVEREXIT:
MessageBox(NULL, "Server disconnected", "Info", MB_OK);
Disconnect();
break;
}
}
}
void CUser::SelectCharacter(Packet & pkt)
{
Packet result(WIZ_SEL_CHAR);
uint8 bResult, bInit;
if (isBanned())
{
Disconnect();
return;
}
pkt >> bResult >> bInit;
result << bResult;
if (bResult == 0 || !GetZoneID())
goto fail_return;
m_pMap = g_pMain->GetZoneByID(GetZoneID());
if (GetMap() == nullptr)
goto fail_return;
if (g_pMain->m_nServerNo != GetMap()->m_nServerNo)
{
_ZONE_SERVERINFO *pInfo = g_pMain->m_ServerArray.GetData(GetMap()->m_nServerNo);
if (pInfo == nullptr)
goto fail_return;
SendServerChange(pInfo->strServerIP, bInit);
return;
}
if (g_pMain->m_byBattleOpen == NO_BATTLE && GetFame() == COMMAND_CAPTAIN)
m_bFame = CHIEF;
// Disallow players from relogging in the opposite nation's home zone when an invasion's not running.
if (((GetZoneID() != GetNation() && GetZoneID() <= ZONE_ELMORAD && !g_pMain->m_byBattleOpen)
// also disallow players from logging back into war zones that aren't currently active...
|| (GetMap()->isWarZone() && (GetZoneID() - ZONE_BATTLE_BASE) != g_pMain->m_byBattleZone)
// Chaos, bdw and juraid montuain
|| isInTempleEventZone()
// Ronark Land, Ardream, RLB, Bifrost, Krowaz Dominion.
|| (g_pMain->m_byBattleOpen && (GetZoneID() == ZONE_RONARK_LAND
|| GetZoneID() == ZONE_ARDREAM
|| GetZoneID() == ZONE_RONARK_LAND_BASE
|| GetZoneID() == ZONE_BIFROST
|| GetZoneID() == ZONE_KROWAZ_DOMINION)) && !isGM()))
{
NativeZoneReturn();
Disconnect();
return;
}
SetLogInInfoToDB(bInit);
result << GetZoneID() << GetSPosX() << GetSPosZ() << GetSPosY() << g_pMain->m_byOldVictory;
m_bSelectedCharacter = true;
Send(&result);
SetUserAbility(false);
if (GetLevel() > MAX_LEVEL)
{
Disconnect();
return;
}
m_iMaxExp = g_pMain->GetExpByLevel(GetLevel());
SetRegion(GetNewRegionX(), GetNewRegionZ());
if (GetClanID() == -1)
{
SetClanID(0);
m_bFame = 0;
return;
}
else if (GetClanID() != 0
&& GetZoneID() > 2)
{
result.Initialize(WIZ_KNIGHTS_PROCESS);
result << uint8(KNIGHTS_LIST_REQ) << GetClanID();
g_pMain->AddDatabaseRequest(result, this);
}
return;
fail_return:
Send(&result);
}
// ---------------------------------------------------------
// CT_LbsClientPosTp261::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp261::StartL()
{
_LIT(KService1, "Service1");
_LIT(KService2, "Service2");
_LIT(KService3, "Service3");
_LIT(KContact1, "Contact1");
_LIT(KContact2, "Contact2");
_LIT(KContact3, "Contact3");
CRequestor* serviceId1 =
CRequestor::NewL(CRequestor::ERequestorService, CRequestor::EFormatApplication,
KService1);
CRequestor* serviceId2 =
CRequestor::NewL(CRequestor::ERequestorService, CRequestor::EFormatApplication,
KService2);
CRequestor* serviceId3 =
CRequestor::NewL(CRequestor::ERequestorService, CRequestor::EFormatApplication,
KService3);
CRequestor* contactId1 =
CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatTelephone,
KContact1);
CRequestor* contactId2 =
CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatUrl,
KContact2);
CRequestor* contactId3 =
CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatMail,
KContact3);
RRequestorStack stack = RRequestorStack();
CleanupStack::PushL(TCleanupItem(CleanOp ,&stack));
CleanupStack::PushL(serviceId1);
CleanupStack::PushL(serviceId2);
CleanupStack::PushL(serviceId3);
CleanupStack::PushL(contactId1);
CleanupStack::PushL(contactId2);
CleanupStack::PushL(contactId3);
ConnectL();
OpenPositioner();
stack.Append(serviceId1);
stack.Append(contactId1);
stack.Append(contactId2);
stack.Append(serviceId2);
stack.Append(contactId3);
stack.Append(serviceId3);
CleanupStack::Pop(contactId3);
CleanupStack::Pop(contactId2);
CleanupStack::Pop(contactId1);
CleanupStack::Pop(serviceId3);
CleanupStack::Pop(serviceId2);
CleanupStack::Pop(serviceId1);
TInt err = iPositioner.SetRequestor(stack);
if (err != KErrNone)
{
_LIT(KErrorAndLeave, "Problems setting requestorstack");
LogErrorAndLeaveL(KErrorAndLeave);
}
const TInt KPosBufFlatExpandSize = 100;
//ExternalizeL
CBufFlat* bufFlat = CBufFlat::NewL(KPosBufFlatExpandSize);
CleanupStack::PushL(bufFlat);
RBufWriteStream stream(*bufFlat);
CleanupClosePushL(stream);
stack.ExternalizeL(stream);
TPtr8 dataPtr((TUint8*)NULL, 0);
dataPtr.Set(bufFlat->Ptr(0));
CleanupStack::PopAndDestroy(&stream);
HBufC8* tempBuf = HBufC8::NewLC(bufFlat->Size());
TPtr8 ptr = tempBuf->Des();
ptr = dataPtr;
//Internalize
bufFlat->InsertL(0, ptr);
RBufReadStream rstream(*bufFlat);
CleanupClosePushL(rstream);
RRequestorStack stack2 = RRequestorStack();
CleanupStack::PushL(TCleanupItem(CleanOp ,&stack2));
stack2.InternalizeL(rstream);
// Verify the requestor stack
VerifyRequestorStackL(stack2);
_LIT(KResult, "The RequestorStack is correct after Externalize/Internalize");
INFO_PRINTF1(KResult);
CleanupStack::PopAndDestroy(1); // CleanupOp stack2
CleanupStack::PopAndDestroy(&rstream);
CleanupStack::PopAndDestroy(tempBuf);
CleanupStack::PopAndDestroy(bufFlat);
CleanupStack::PopAndDestroy(1); // CleanupOp stack1
ClosePositioner();
Disconnect();
}
///////////////////////////////////////////////////////////////////////////////
// Destruktor
MySQL::~MySQL(void)
{
Disconnect();
}
wxNumericTextCtrl::~wxNumericTextCtrl() {
Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( wxNumericTextCtrl::onTextChanged ), NULL, this );
}
// ---------------------------------------------------------
// CDownloadMgrSession::DispatchMessageL
// ---------------------------------------------------------
//
void CDownloadMgrSession::DispatchMessageL( const RMessage2& aMessage )
{
CLOG_ENTERFN( "CDownloadMgrSession::DispatchMessageL" )
CLOG_WRITE_FORMAT( "Message function: %d", aMessage.Function() )
// Set this false in case of the asyncron requests!!!
iComplete = ETrue;
SetCurrentMessage( aMessage );
// Fixed for Bug id - JJUN-78WCJ3 (DownloadMgrServer crashes under IPC attack)
//This check will make sure that before start of any download, InitializeL() should
// be called so that all the member variables will be initialized.
if(aMessage.Function() != EHttpDownloadMgrInitialize && iClientAppInstance == NULL)
{
User::Leave(KErrGeneral);
}
// check for session-relative requests
switch( aMessage.Function() )
{
case EHttpDownloadMgrInitialize:
{
InitializeL();
return;
}
case EHttpDownloadMgrCreateDownload:
{
NewDownloadL();
return;
}
case EHttpDownloadMgrAttach:
{
DownloadMgrAttachL();
return;
}
case EHttpDownloadAttach:
{
DownloadAttachL();
return;
}
case EHttpDownloadAttachToDownload:
{
AttachToDownloadL();
return;
}
case EHttpDownloadMgrPauseAll:
{
PauseAllL();
return;
}
case EHttpDownloadMgrStartAllL:
{
StartAllL();
return;
}
case EHttpDownloadMgrResetAll:
{
ResetAll();
return;
}
case EHttpDownloadMgrDeleteAll:
{
DeleteAll();
return;
}
case EHttpDownloadMgrDisconnect:
{
Disconnect();
return;
}
case EHttpDownloadMgrGetIntAttribute:
{
GetIntAttributeL();
return;
}
case EHttpDownloadMgrGetBoolAttribute:
{
GetBoolAttributeL();
return;
}
case EHttpDownloadMgrGetStringAttribute:
{
GetStringAttributeL();
return;
}
case EHttpDownloadMgrGetString8Attribute:
{
GetString8AttributeL();
return;
}
case EHttpDownloadMgrSetIntAttribute:
{
SetIntAttributeL();
return;
}
case EHttpDownloadMgrSetBoolAttribute:
{
SetBoolAttributeL();
return;
}
case EHttpDownloadMgrSetStringAttribute:
{
SetStringAttributeL();
return;
}
case EHttpDownloadMgrSetString8Attribute:
{
SetString8AttributeL();
return;
}
case EHttpDownloadMgrSessionEventSubscription:
{
InitSessionEvent( aMessage );
// Send event from the queue
TUint dummy( 0 );
Event( NULL, (THttpDownloadState)dummy, (THttpProgressState)dummy, dummy );
// This is an asyncron request will be completed later!
SetComplete( EFalse );
return;
}
case EHttpDownloadMgrSessionEventCancel:
{
CancelMovedEvent();
return;
}
}
// ok, it must be subsession relative
CDownloadSubSession* download = DownloadFromHandle( aMessage.Int3() );
__ASSERT_DEBUG( download, PanicClient( EBadSubsessionHandle ) );
TRAPD( err, download->DispatchMessageL( aMessage ) );
if( err )
{
download->OnError( err );
User::Leave( err );
}
}
CDatagrams::~CDatagrams()
{
Disconnect();
}
void
JabberProtocol::OnTag(XMLEntity *entity)
{
char buffer[4096]; // general buffer space
static int seen_streams = 0;
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "iq"))
{
// handle roster retrival
if (entity->Child("query") && entity->Child("query")->Attribute("xmlns") &&
!strcasecmp(entity->Child("query")->Attribute("xmlns"),"jabber:iq:roster"))
{
ParseRosterList(entity);
return;
}
// handle session retrival
if (entity->Attribute("id") && entity->Attribute("type") &&
!strcasecmp(entity->Attribute("type"), "result") &&
!strcasecmp(entity->Attribute("id"), "sess_1"))
{
release_sem(logged);
mainWindow->Lock();
mainWindow->PostMessage(JAB_LOGGED_IN);
mainWindow->Unlock();
return;
}
// handle binding retrival
if (entity->Attribute("id") && entity->Attribute("type") &&
!strcasecmp(entity->Attribute("type"), "result") &&
!strcasecmp(entity->Attribute("id"), "bind_0"))
{
jid = BString(entity->Child("bind")->Child("jid")->Data());
fprintf(stderr, "JID: %s.\n", jid.String());
Session();
return;
}
if (entity->Attribute("type") && entity->Child("query") &&
!strcasecmp(entity->Attribute("type"), "result") &&
entity->Child("query", "xmlns", "jabber:iq:register"))
{
Authorize();
return;
}
if (entity->Attribute("type") && entity->Attribute("id") &&
!strcasecmp(entity->Attribute("type"), "result") &&
!strcasecmp(entity->Attribute("id"), "request_room_info"))
{
BMessage msg(JAB_PREFERENCES_DATAFORM);
msg.AddPointer("XMLEntity", entity);
MessageRepeater::Instance()->PostMessage(&msg);
return;
}
if (entity->Attribute("type") && entity->Attribute("id") &&
!strcasecmp(entity->Attribute("type"), "error"))
{
if (!strcasecmp(entity->Attribute("id"), "storage_request"))
{
_storage_supported = false;
return;
}
else if (!strcasecmp(entity->Attribute("id"), "save_conferences"))
{
_storage_supported = false;
sprintf(buffer, "Storage XEP-0049 is not supported on server. Cannot save conferences.\n\nNext time will try save to roster.");
ModalAlertFactory::Alert(buffer, "Pity", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
return;
}
else if (!strcasecmp(entity->Attribute("id"), "request_room_info"))
{
if (entity->Child("error") &&
entity->Child("error")->Child("text") &&
entity->Child("error")->Attribute("code"))
sprintf(buffer, "Error %s:\n\n%s", entity->Child("error")->Attribute("code"),
entity->Child("error")->Child("text")->Data());
else
sprintf(buffer, "Error %s", entity->Child("error")->Attribute("code"));
ModalAlertFactory::Alert(buffer, "OK", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
return;
}
if (entity->Child("error") &&
entity->Child("error")->Child("text") &&
entity->Child("error")->Attribute("code"))
sprintf(buffer, "Error %s:\n\n%s", entity->Child("error")->Attribute("code"),
entity->Child("error")->Child("text")->Data());
else
sprintf(buffer, "Error %s", entity->Child("error")->Attribute("code"));
ModalAlertFactory::Alert(buffer, "OK", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
Disconnect();
return;
}
if (entity->Attribute("id") && entity->Child("query") && entity->Child("query")->Attribute("xmlns") &&
entity->Attribute("type") &&
!strcasecmp(entity->Attribute("id"), "storage_request") &&
!strcasecmp(entity->Attribute("type"), "result") &&
!strcasecmp(entity->Child("query")->Attribute("xmlns"), "jabber:iq:private"))
{
if (entity->Child("query")->Child("storage"))
ParseStorage(entity->Child("query")->Child("storage"));
return;
}
if (entity->Attribute("type") && !strcasecmp(entity->Attribute("type"), "get"))
{
BString iq_from;
BString iq_id;
if (entity->Attribute("from")) {
iq_from = BString(entity->Attribute("from"));
}
if (entity->Attribute("id")) {
iq_id = BString(entity->Attribute("id"));
}
// handle version request
XMLEntity *query = entity->Child("query");
if (query && query->Attribute("xmlns")) {
if (!strcasecmp(query->Attribute("xmlns"), "jabber:iq:version")) {
ProcessVersionRequest(iq_id, iq_from);
}
}
// handle version request
query = entity->Child("ping");
if (query && query->Attribute("xmlns")) {
if (!strcasecmp(query->Attribute("xmlns"), "urn:xmpp:ping"))
{
Pong(iq_id, iq_from);
}
}
return;
}
fprintf(stderr, "Unknown IQ message.\n");
return;
}
// handle authorization success
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "success"))
{
InitSession();
return;
}
// handle presence messages
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "presence"))
{
ProcessPresence(entity);
return;
}
// handle stream error
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "stream:error")) {
sprintf(buffer, "An stream error has occurred.");
ModalAlertFactory::Alert(buffer, "Sorry", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
Disconnect();
return;
}
// handle stream error
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "stream:features"))
{
mainWindow->Lock();
int wantRegister = mainWindow->_login_new_account->Value();
mainWindow->Unlock();
if (wantRegister == B_CONTROL_ON)
{
if (entity->Child("register"))
{
mainWindow->Lock();
mainWindow->_login_new_account->SetValue(B_CONTROL_OFF);
mainWindow->Unlock();
SendUserRegistration(user, pass, "haiku");
} else
{
sprintf(buffer, "Registration not supported on this server.");
ModalAlertFactory::Alert(buffer, "Sorry", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
Disconnect();
}
}
else if (entity->Child("mechanisms"))
Authorize();
else if (entity->Child("bind"))
Bind();
else if (entity->Child("session"))
Session();
return;
}
// handle failures
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "failure")) {
if (entity->Child("not-authorized") != NULL)
sprintf(buffer, "Not authorized failure.");
else if (entity->Child("invalid-mechanism") != NULL)
sprintf(buffer, "Invalid mechanism failure.");
else if (entity->Child("invalid-authzid") != NULL)
sprintf(buffer, "Invalid authorization Id.");
else
sprintf(buffer, "An failure occured.");
ModalAlertFactory::Alert(buffer, "Sorry", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
Disconnect();
return;
}
// handle disconnection
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "stream:stream"))
{
++seen_streams;
if (seen_streams % 2 == 1)
Disconnect();
return;
}
// handle incoming messages
if (entity->IsCompleted() && !strcasecmp(entity->Name(), "message"))
{
//TalkManager::Instance()->Lock();
TalkManager::Instance()->ProcessMessageData(entity);
//TalkManager::Instance()->Unlock();
return;
}
//delete entity;
}
bool NetPlayClient::Connect()
{
// send connect message
sf::Packet spac;
spac << NETPLAY_VERSION;
spac << netplay_dolphin_ver;
spac << m_player_name;
Send(spac);
enet_host_flush(m_client);
sf::Packet rpac;
// TODO: make this not hang
ENetEvent netEvent;
if (enet_host_service(m_client, &netEvent, 5000) > 0 && netEvent.type == ENET_EVENT_TYPE_RECEIVE)
{
rpac.append(netEvent.packet->data, netEvent.packet->dataLength);
}
else
{
return false;
}
MessageId error;
rpac >> error;
// got error message
if (error)
{
switch (error)
{
case CON_ERR_SERVER_FULL:
PanicAlertT("The server is full!");
break;
case CON_ERR_VERSION_MISMATCH:
PanicAlertT("The server and client's NetPlay versions are incompatible!");
break;
case CON_ERR_GAME_RUNNING:
PanicAlertT("The server responded: the game is currently running!");
break;
default:
PanicAlertT("The server sent an unknown error message!");
break;
}
Disconnect();
return false;
}
else
{
rpac >> m_pid;
Player player;
player.name = m_player_name;
player.pid = m_pid;
player.revision = netplay_dolphin_ver;
// add self to player list
m_players[m_pid] = player;
m_local_player = &m_players[m_pid];
m_dialog->Update();
is_connected = true;
return true;
}
}
void AutocloseMessageBox::EndModal( int retCode )
{
Disconnect( delay_timerID, wxEVT_TIMER, wxTimerEventHandler( AutocloseMessageBox::OnUnlock) );
m_delay_timer.Stop();
TimedMessageBox::EndModal( retCode );
}
// VPN Azure client main thread
void AcMainThread(THREAD *thread, void *param)
{
AZURE_CLIENT *ac = (AZURE_CLIENT *)param;
UINT last_ip_revision = INFINITE;
UINT64 last_reconnect_tick = 0;
UINT64 next_reconnect_interval = AZURE_CONNECT_INITIAL_RETRY_INTERVAL;
UINT num_reconnect_retry = 0;
UINT64 next_ddns_retry_tick = 0;
bool last_connect_ok = false;
// Validate arguments
if (ac == NULL || thread == NULL)
{
return;
}
while (ac->Halt == false)
{
UINT64 now = Tick64();
bool connect_was_ok = false;
// Wait for enabling VPN Azure function
if (ac->IsEnabled)
{
// VPN Azure is enabled
DDNS_CLIENT_STATUS st;
bool connect_now = false;
bool azure_ip_changed = false;
Lock(ac->Lock);
{
Copy(&st, &ac->DDnsStatus, sizeof(DDNS_CLIENT_STATUS));
if (StrCmpi(st.CurrentAzureIp, ac->DDnsStatusCopy.CurrentAzureIp) != 0)
{
if (IsEmptyStr(st.CurrentAzureIp) == false)
{
// Destination IP address is changed
connect_now = true;
num_reconnect_retry = 0;
}
}
if (StrCmpi(st.CurrentHostName, ac->DDnsStatusCopy.CurrentHostName) != 0)
{
// DDNS host name is changed
connect_now = true;
num_reconnect_retry = 0;
}
Copy(&ac->DDnsStatusCopy, &st, sizeof(DDNS_CLIENT_STATUS));
}
Unlock(ac->Lock);
if (last_ip_revision != ac->IpStatusRevision)
{
last_ip_revision = ac->IpStatusRevision;
connect_now = true;
num_reconnect_retry = 0;
}
if (last_reconnect_tick == 0 || (now >= (last_reconnect_tick + next_reconnect_interval)))
{
UINT r;
last_reconnect_tick = now;
num_reconnect_retry++;
next_reconnect_interval = (UINT64)num_reconnect_retry * AZURE_CONNECT_INITIAL_RETRY_INTERVAL;
next_reconnect_interval = MIN(next_reconnect_interval, AZURE_CONNECT_MAX_RETRY_INTERVAL);
r = (UINT)next_reconnect_interval;
r = GenRandInterval(r / 2, r);
next_reconnect_interval = r;
connect_now = true;
}
if (IsEmptyStr(st.CurrentAzureIp) == false && IsEmptyStr(st.CurrentHostName) == false)
{
if (connect_now)
{
SOCK *s;
char *host = NULL;
UINT port = AZURE_SERVER_PORT;
Debug("VPN Azure: Connecting to %s...\n", st.CurrentAzureIp);
if (ParseHostPort(st.CurrentAzureIp, &host, &port, AZURE_SERVER_PORT))
{
if (st.InternetSetting.ProxyType == PROXY_DIRECT)
{
s = ConnectEx2(host, port, 0, (bool *)&ac->Halt);
}
else
{
s = WpcSockConnect2(host, port, &st.InternetSetting, NULL, AZURE_VIA_PROXY_TIMEOUT);
}
if (s != NULL)
{
PACK *p;
UINT64 established_tick = 0;
Debug("VPN Azure: Connected.\n");
SetTimeout(s, AZURE_PROTOCOL_CONTROL_TIMEOUT_DEFAULT);
Lock(ac->Lock);
{
ac->CurrentSock = s;
ac->IsConnected = true;
StrCpy(ac->ConnectingAzureIp, sizeof(ac->ConnectingAzureIp), st.CurrentAzureIp);
}
Unlock(ac->Lock);
SendAll(s, AZURE_PROTOCOL_CONTROL_SIGNATURE, StrLen(AZURE_PROTOCOL_CONTROL_SIGNATURE), false);
// Receive parameter
p = RecvPackWithHash(s);
if (p != NULL)
{
UCHAR c;
AZURE_PARAM param;
bool hostname_changed = false;
Zero(¶m, sizeof(param));
param.ControlKeepAlive = PackGetInt(p, "ControlKeepAlive");
param.ControlTimeout = PackGetInt(p, "ControlTimeout");
param.DataTimeout = PackGetInt(p, "DataTimeout");
param.SslTimeout = PackGetInt(p, "SslTimeout");
FreePack(p);
param.ControlKeepAlive = MAKESURE(param.ControlKeepAlive, 1000, AZURE_SERVER_MAX_KEEPALIVE);
param.ControlTimeout = MAKESURE(param.ControlTimeout, 1000, AZURE_SERVER_MAX_TIMEOUT);
param.DataTimeout = MAKESURE(param.DataTimeout, 1000, AZURE_SERVER_MAX_TIMEOUT);
param.SslTimeout = MAKESURE(param.SslTimeout, 1000, AZURE_SERVER_MAX_TIMEOUT);
Lock(ac->Lock);
{
Copy(&ac->AzureParam, ¶m, sizeof(AZURE_PARAM));
}
Unlock(ac->Lock);
SetTimeout(s, param.ControlTimeout);
// Send parameter
p = NewPack();
PackAddStr(p, "CurrentHostName", st.CurrentHostName);
PackAddStr(p, "CurrentAzureIp", st.CurrentAzureIp);
PackAddInt64(p, "CurrentAzureTimestamp", st.CurrentAzureTimestamp);
PackAddStr(p, "CurrentAzureSignature", st.CurrentAzureSignature);
Lock(ac->Lock);
{
if (StrCmpi(st.CurrentHostName, ac->DDnsStatus.CurrentHostName) != 0)
{
hostname_changed = true;
}
}
Unlock(ac->Lock);
if (hostname_changed == false)
{
if (SendPackWithHash(s, p))
{
// Receive result
if (RecvAll(s, &c, 1, false))
{
if (c && ac->Halt == false)
{
connect_was_ok = true;
established_tick = Tick64();
AcWaitForRequest(ac, s, ¶m);
}
}
}
}
FreePack(p);
}
else
{
WHERE;
}
Debug("VPN Azure: Disconnected.\n");
Lock(ac->Lock);
{
ac->IsConnected = false;
ac->CurrentSock = NULL;
ClearStr(ac->ConnectingAzureIp, sizeof(ac->ConnectingAzureIp));
}
Unlock(ac->Lock);
if (established_tick != 0)
{
if ((established_tick + (UINT64)AZURE_CONNECT_MAX_RETRY_INTERVAL) <= Tick64())
{
// If the connected time exceeds the AZURE_CONNECT_MAX_RETRY_INTERVAL, reset the retry counter.
last_reconnect_tick = 0;
num_reconnect_retry = 0;
next_reconnect_interval = AZURE_CONNECT_INITIAL_RETRY_INTERVAL;
}
}
Disconnect(s);
ReleaseSock(s);
}
else
{
Debug("VPN Azure: Error: Connect Failed.\n");
}
Free(host);
}
}
}
}
else
{
last_reconnect_tick = 0;
num_reconnect_retry = 0;
next_reconnect_interval = AZURE_CONNECT_INITIAL_RETRY_INTERVAL;
}
if (ac->Halt)
{
break;
}
if (connect_was_ok)
{
// If connection goes out after connected, increment connection success count to urge DDNS client query
next_ddns_retry_tick = Tick64() + MIN((UINT64)DDNS_VPN_AZURE_CONNECT_ERROR_DDNS_RETRY_TIME_DIFF * (UINT64)(num_reconnect_retry + 1), (UINT64)DDNS_VPN_AZURE_CONNECT_ERROR_DDNS_RETRY_TIME_DIFF_MAX);
}
if ((next_ddns_retry_tick != 0) && (Tick64() >= next_ddns_retry_tick))
{
next_ddns_retry_tick = 0;
ac->DDnsTriggerInt++;
}
Wait(ac->Event, rand() % 1000);
}
}
// Listener thread
void ElListenerProc(THREAD *thread, void *param)
{
TCP_ACCEPTED_PARAM *data = (TCP_ACCEPTED_PARAM *)param;
EL *e;
SOCK *s;
UCHAR rand[SHA1_SIZE];
UCHAR pass1[SHA1_SIZE], pass2[SHA1_SIZE];
// Validate arguments
if (data == NULL || thread == NULL)
{
return;
}
e = (EL *)data->r->ThreadParam;
s = data->s;
AddRef(s->ref);
SetTimeout(s, 5000);
LockList(e->AdminThreadList);
{
AddRef(thread->ref);
AddRef(s->ref);
Insert(e->AdminThreadList, thread);
Insert(e->AdminSockList, s);
}
UnlockList(e->AdminThreadList);
NoticeThreadInit(thread);
// Submit a challenge
Rand(rand, sizeof(rand));
SendAll(s, rand, sizeof(rand), false);
// Receive a response
SecurePassword(pass1, e->HashedPassword, rand);
Zero(pass2, sizeof(pass2));
RecvAll(s, pass2, sizeof(pass2), false);
if (Cmp(pass1, pass2, SHA1_SIZE) != 0)
{
// Password incorrect
bool code = false;
code = Endian32(code);
SendAll(s, &code, sizeof(code), false);
}
else
{
// Password match
bool code = true;
RPC *r;
code = Endian32(code);
SendAll(s, &code, sizeof(code), false);
SetTimeout(s, INFINITE);
// Start operation as a RPC server
r = StartRpcServer(s, ElRpcServer, e);
RpcServer(r);
RpcFree(r);
}
Disconnect(s);
ReleaseSock(s);
LockList(e->AdminThreadList);
{
if (Delete(e->AdminThreadList, thread))
{
ReleaseThread(thread);
}
if (Delete(e->AdminSockList, s))
{
ReleaseSock(s);
}
}
UnlockList(e->AdminThreadList);
}
void EDA_DRAW_PANEL_GAL::StopDrawing()
{
m_pendingRefresh = true;
m_refreshTimer.Stop();
Disconnect( wxEVT_PAINT, wxPaintEventHandler( EDA_DRAW_PANEL_GAL::onPaint ), NULL, this );
}
ClientInfo::~ClientInfo()
{
Disconnect();
m_thread.join();
Cli::writeDebugMsg("Client Destructed");
}
/**************************************************************************//**
* @brief
* The main command line loop. Placed in Ram so that it can still run after
* a destructive write operation.
* NOTE: __ramfunc is a IAR specific instruction to put code into RAM.
* This allows the bootloader to survive a destructive upload.
*****************************************************************************/
static void commandlineLoop( void )
{
uint8_t c;
/* The main command loop */
while (1)
{
/* Retrieve new character */
c = BOOTLDIO_rxByte();
/* Echo */
if (c != 0)
{
BOOTLDIO_txByte( c );
}
switch (c)
{
/* Bootloader version command */
case 'i':
/* Print version */
BOOTLDIO_printString("\r\n\r\n" BOOTLOADER_VERSION_STRING );
/* Print the chip ID */
BOOTLDIO_printHex(DEVINFO->UNIQUEH);
BOOTLDIO_printHex(DEVINFO->UNIQUEL);
BOOTLDIO_printString("\r\n");
break;
/* Upload command */
case 'u':
BOOTLDIO_printString( readyString );
XMODEM_download( BOOTLOADER_SIZE, flashSize );
break;
/* Destructive upload command */
case 'd':
BOOTLDIO_printString( readyString );
XMODEM_download( 0, flashSize );
break;
/* Write to user page */
case 't':
BOOTLDIO_printString( readyString );
XMODEM_download( USER_PAGE_START, USER_PAGE_END );
break;
/* Write to lock bits */
case 'p':
BOOTLDIO_printString( readyString );
XMODEM_download( LOCK_PAGE_START, LOCK_PAGE_END );
break;
/* Boot into new program */
case 'b':
Disconnect( 5000, 2000 );
BOOT_boot();
break;
/* Debug lock */
case 'l':
#if defined( BL_DEBUG )
/* We check if there is a debug session active in DHCSR. If there is we
* abort the locking. This is because we wish to make sure that the debug
* lock functionality works without a debugger attatched. */
if ((CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk) != 0x0)
{
USB_PUTS( "\r\n\r\n **** WARNING: DEBUG SESSION ACTIVE. NOT LOCKING! **** \r\n\r\n" );
BOOTLDIO_printString( "Debug active.\r\n" );
}
else
{
USB_PUTS( "Starting debug lock sequence.\r\n" );
#endif
FLASH_writeWord( DEBUG_LOCK_WORD, 0x0 );
if ( *(volatile uint32_t*)DEBUG_LOCK_WORD == 0x0 )
{
BOOTLDIO_printString( okString );
}
else
{
BOOTLDIO_printString( failString );
}
#if defined( BL_DEBUG )
USB_PRINTF( "Debug lock word: 0x%x \r\n", *((uint32_t *) DEBUG_LOCK_WORD) );
}
#endif
break;
/* Verify content by calculating CRC of entire flash */
case 'v':
verify( 0, flashSize );
break;
/* Verify content by calculating CRC of application area */
case 'c':
verify( BOOTLOADER_SIZE, flashSize );
break;
/* Verify content by calculating CRC of user page.*/
case 'n':
verify( USER_PAGE_START, USER_PAGE_END );
break;
/* Verify content by calculating CRC of lock page */
case 'm':
verify( LOCK_PAGE_START, LOCK_PAGE_END );
break;
/* Reset command */
case 'r':
Disconnect( 5000, 2000 );
/* Write to the Application Interrupt/Reset Command Register to reset
* the EFM32. See section 9.3.7 in the reference manual. */
SCB->AIRCR = 0x05FA0004;
break;
/* Unknown command */
case 0:
/* Timeout waiting for RX - avoid printing the unknown string. */
break;
default:
BOOTLDIO_printString( unknownString );
}
}
}
// OnReceive
//------------------------------------------------------------------------------
/*virtual*/ void Client::OnReceive( const ConnectionInfo * connection, void * data, uint32_t size, bool & keepMemory )
{
keepMemory = true; // we'll take care of freeing the memory
MutexHolder mh( m_ServerListMutex );
ServerState * ss = (ServerState *)connection->GetUserData();
ASSERT( ss );
// are we expecting a msg, or the payload for a msg?
void * payload = nullptr;
size_t payloadSize = 0;
if ( ss->m_CurrentMessage == nullptr )
{
// message
ss->m_CurrentMessage = reinterpret_cast< const Protocol::IMessage * >( data );
if ( ss->m_CurrentMessage->HasPayload() )
{
return;
}
}
else
{
// payload
ASSERT( ss->m_CurrentMessage->HasPayload() );
payload = data;
payloadSize = size;
}
// determine message type
const Protocol::IMessage * imsg = ss->m_CurrentMessage;
Protocol::MessageType messageType = imsg->GetType();
PROTOCOL_DEBUG( "Server -> Client : %u (%s)\n", messageType, GetProtocolMessageDebugName( messageType ) );
switch ( messageType )
{
case Protocol::MSG_REQUEST_JOB:
{
const Protocol::MsgRequestJob * msg = static_cast< const Protocol::MsgRequestJob * >( imsg );
Process( connection, msg );
break;
}
case Protocol::MSG_JOB_RESULT:
{
const Protocol::MsgJobResult * msg = static_cast< const Protocol::MsgJobResult * >( imsg );
Process( connection, msg, payload, payloadSize );
break;
}
case Protocol::MSG_REQUEST_MANIFEST:
{
const Protocol::MsgRequestManifest * msg = static_cast< const Protocol::MsgRequestManifest * >( imsg );
Process( connection, msg );
break;
}
case Protocol::MSG_REQUEST_FILE:
{
const Protocol::MsgRequestFile * msg = static_cast< const Protocol::MsgRequestFile * >( imsg );
Process( connection, msg );
break;
}
case Protocol::MSG_SERVER_STATUS:
{
const Protocol::MsgServerStatus * msg = static_cast< const Protocol::MsgServerStatus * >( imsg );
Process( connection, msg );
break;
}
default:
{
// unknown message type
ASSERT( false ); // this indicates a protocol bug
Disconnect( connection );
break;
}
}
// free everything
FREE( (void *)( ss->m_CurrentMessage ) );
FREE( payload );
ss->m_CurrentMessage = nullptr;
}
/**************************************************************************//**
* The main entry point.
*****************************************************************************/
int main(void)
{
int msElapsed, i;
/* Set new vector table pointer */
SCB->VTOR = 0x20000000;
/* Enable peripheral clocks. */
CMU->HFPERCLKDIV = CMU_HFPERCLKDIV_HFPERCLKEN;
CMU->HFPERCLKEN0 = CMU_HFPERCLKEN0_GPIO | BOOTLOADER_USART_CLOCK |
AUTOBAUD_TIMER_CLOCK ;
/* Enable DMA interface */
CMU->HFCORECLKEN0 = CMU_HFCORECLKEN0_DMA;
#if defined( BL_DEBUG )
RETARGET_SerialInit(); /* Setup debug serialport etc. */
USB_PUTS( "EFM32 USB/USART0 bootloader\r\n" );
#endif
/* Calculate CRC16 for the bootloader itself and the Device Information page. */
/* This is used for production testing and can safely be omitted in */
/* your own code. */
bootloaderCRC = CRC_calc((void *) 0x0, (void *) BOOTLOADER_SIZE);
bootloaderCRC |= CRC_calc((void *) 0x0FE081B2, (void *) 0x0FE08200) << 16;
StartRTC();
#if !defined( SIMULATE_SWDCLK_PIN_HI )
while ( SWDCLK_PIN_IS_LO() )
{
USB_PUTS( "SWDCLK is low\r\n" );
if ( BOOT_checkFirmwareIsValid() )
{
USB_PUTS( "Booting application\r\n " );
BOOT_boot();
}
else
{
USB_PUTS( "No valid application, resetting EFM32... \r\n" );
/* Go to EM2 and wait for RTC wakeup. */
EMU_EnterEM2( false );
}
}
#endif
NVIC_DisableIRQ( RTC_IRQn );
/* Try to start HFXO. */
CMU_OscillatorEnable( cmuOsc_HFXO, true, false );
/* Wait approx. 1 second to see if HFXO starts. */
i = 1500000;
while ( i && !( CMU->STATUS & CMU_STATUS_HFXORDY ) )
{
i--;
}
USBTIMER_Init();
if ( i == 0 )
{
CMU_HFRCOBandSet( cmuHFRCOBand_28MHz );
}
else
{
CMU_ClockSelectSet( cmuClock_HF, cmuSelect_HFXO );
USBD_Init( &initstruct ); /* Start USB CDC functionality */
}
AUTOBAUD_start(); /* Start autobaud */
/* Wait 30 seconds for USART or USB connection */
msElapsed = 0;
while ( msElapsed < 30000 )
{
if ( AUTOBAUD_completed() )
break;
if ( CDC_Configured )
{
BOOTLDIO_setMode( CDC_Configured );
break;
}
USBTIMER_DelayMs( 100 );
msElapsed += 100;
}
AUTOBAUD_stop();
if ( msElapsed >= 30000 )
{
USB_PUTS( "USART0/USB timeout, resetting EFM32...\r\n " );
Disconnect( 0, 2000 );
SCB->AIRCR = 0x05FA0004; /* Reset EFM32. */
}
/* Print a message to show that we are in bootloader mode */
BOOTLDIO_printString("\r\n\r\n" BOOTLOADER_VERSION_STRING );
/* Print the chip ID. This is useful for production tracking */
BOOTLDIO_printHex(DEVINFO->UNIQUEH);
BOOTLDIO_printHex(DEVINFO->UNIQUEL);
BOOTLDIO_printString("\r\n");
/* Figure out correct flash geometry. */
FLASH_CalcPageSize();
/* Initialize flash for writing */
FLASH_init();
/* Start executing command line */
commandlineLoop();
}
CPullPin::~CPullPin() {
Disconnect();
}
CRmqCli::~CRmqCli()
{
Disconnect();
}
void SyncSocketConnection::Shutdown()
{
Disconnect();
m_bInitialized = FALSE;
}
nsXULCommandDispatcher::~nsXULCommandDispatcher()
{
Disconnect();
}
void CUser::RecvLoginInfo(Packet & pkt)
{
int8 bResult = pkt.read<uint8>();
if (bResult < 0)
Disconnect();
}
void CustomVirtListCtrl<T,L>::StopTimer()
{
m_periodic_sort_timer.Stop();
Disconnect( m_periodic_sort_timer_id, wxTimerEvent().GetEventType(), wxTimerEventHandler( ThisType::OnPeriodicSort ) );
}
// ---------------------------------------------------------
// CT_LbsClientPosTp178::TestTimeout
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp178::TestTimeoutL()
{
_LIT(KSTART, "TestTimeout()");
_LIT(KEND, "TestTimeout() passed");
_LIT(KTIME, "Request took %d us");
// Setup verification stuff
INFO_PRINTF1(KSTART);
//TPrivDlgDiagnostics tmpdiag;
TTime requestStartTime;
TTime requestStopTime;
TTimeIntervalMicroSeconds durationMicro;
TBuf<100> buf;
_LIT(KService, "SAAA");
TPositionUpdateOptions updateOptions;
TTimeIntervalMicroSeconds longInterval(7000000);
ConnectL();
SetupPsyL(iUidTestPsy3);
OpenPositionerByName(iUidTestPsy3);
updateOptions.SetUpdateTimeOut(longInterval);
// Access protected member (iPositioner) here
iPositioner.SetUpdateOptions(updateOptions);
_LIT(KONE, "Perform first request, should NOT time out");
INFO_PRINTF1(KONE);
requestStartTime.UniversalTime();
//Make one request to verify psy
PerformRequestL(KService, CRequestor::ERequestorService, CRequestor::EFormatApplication);
CheckRequestResultL(KErrNone);
requestStopTime.UniversalTime();
durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime);
TInt duration = durationMicro.Int64();
buf.Format(KTIME, duration);
INFO_PRINTF1(buf);
ClosePositioner();
OpenPositionerByName(iUidTestPsy3);
// ECancelButton means that the Automatised class should wait for a cancel call
// before returning result
updateOptions.SetUpdateTimeOut(longInterval);
// Access protected (iPositioner) member here
iPositioner.SetUpdateOptions(updateOptions);
_LIT(KTWO, "Perform second request, should not time out");
INFO_PRINTF1(KTWO);
//Make one request to verify psy
TPositionInfo info = TPositionInfo();
requestStartTime.UniversalTime();
TInt err = PerformSyncRequest(KService, &info);
requestStopTime.UniversalTime();
if (err != KErrNone)
{
_LIT(KError, "Wrong result from iStatus, should be KErrNone, was %d");
TBuf<100> buf;
buf.Format(KError, err);
LogErrorAndLeaveL(buf);
}
durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime);
duration = durationMicro.Int64();
buf.Format(KTIME, duration);
INFO_PRINTF1(buf);
ClosePositioner();
Disconnect();
INFO_PRINTF1(KEND);
}
void CUser::SelectCharacter(Packet & pkt)
{
Packet result(WIZ_SEL_CHAR);
uint8 bResult, bInit;
if (isBanned())
{
Disconnect();
return;
}
pkt >> bResult >> bInit;
result << bResult;
if (bResult == 0 || !GetZoneID())
goto fail_return;
m_pMap = g_pMain->GetZoneByID(GetZoneID());
if (GetMap() == NULL)
goto fail_return;
// Temporarily convert the old quest storage format to the new one.
// This won't be necessary when Aujard's out of the picture.
m_questMap.clear();
for (int i = 0, index = 0; i < m_pUserData->m_sQuestCount; i++)
{
uint16 sQuestID = GetShort(m_pUserData->m_bstrQuest, index);
uint8 bQuestState = GetByte(m_pUserData->m_bstrQuest, index);
m_questMap.insert(std::make_pair(sQuestID, bQuestState));
}
if (g_pMain->m_nServerNo != GetMap()->m_nServerNo)
{
_ZONE_SERVERINFO *pInfo = g_pMain->m_ServerArray.GetData(GetMap()->m_nServerNo);
if (pInfo == NULL)
goto fail_return;
SendServerChange(pInfo->strServerIP, bInit);
return;
}
if (g_pMain->m_byBattleOpen == NO_BATTLE && getFame() == COMMAND_CAPTAIN)
m_pUserData->m_bFame = CHIEF;
if ((GetZoneID() != GetNation() && GetZoneID() < 3 && !g_pMain->m_byBattleOpen)
|| (GetZoneID() == ZONE_BATTLE && (g_pMain->m_byBattleOpen != NATION_BATTLE))
|| (GetZoneID() == ZONE_SNOW_BATTLE && (g_pMain->m_byBattleOpen != SNOW_BATTLE))
|| (GetZoneID() == ZONE_FRONTIER && g_pMain->m_byBattleOpen))
{
NativeZoneReturn();
Disconnect();
return;
}
SetLogInInfoToDB(bInit);
result << GetZoneID() << GetSPosX() << GetSPosZ() << GetSPosY() << g_pMain->m_byOldVictory;
m_bSelectedCharacter = true;
Send(&result);
SetSlotItemValue();
SetUserAbility(false);
if (GetLevel() > MAX_LEVEL)
{
Disconnect();
return;
}
m_iMaxExp = g_pMain->GetExpByLevel(GetLevel());
SetRegion(GetNewRegionX(), GetNewRegionZ());
if (m_pUserData->m_bKnights == -1)
{
m_pUserData->m_bKnights = m_pUserData->m_bFame = 0;
return;
}
else if (m_pUserData->m_bKnights != 0)
{
CKnights* pKnights = g_pMain->GetClanPtr( m_pUserData->m_bKnights );
if (pKnights != NULL)
{
g_pMain->m_KnightsManager.SetKnightsUser( m_pUserData->m_bKnights, m_pUserData->m_id );
}
else if (GetZoneID() > 2)
{
result.Initialize(WIZ_KNIGHTS_PROCESS);
result << uint8(KNIGHTS_LIST_REQ) << m_pUserData->m_bKnights;
g_pMain->m_LoggerSendQueue.PutData(&result, GetSocketID());
}
}
return;
fail_return:
Send(&result);
}
// ---------------------------------------------------------
// CT_LbsClientPosTp178::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsClientPosTp178::StartL()
{
_LIT(KServiceAccept, "SAAA");
SetupPsyL(iUidTestPsy3);
RPositioner positioner;
TPositionInfo info = TPositionInfo();
ConnectL();
User::LeaveIfError(positioner.Open(iPosServer,iUidTestPsy3));
CleanupClosePushL(positioner);
TInt Err = positioner.SetRequestor(CRequestor::ERequestorService,
CRequestor::EFormatApplication, KServiceAccept);
TPositionUpdateOptions updateOptionsLong, updateOptionsShort;
TTimeIntervalMicroSeconds longInterval(7000000);
updateOptionsLong.SetUpdateTimeOut(longInterval);
Err = positioner.SetUpdateOptions(updateOptionsLong);
TTimeIntervalMicroSeconds shortInterval(2000000);
updateOptionsShort.SetUpdateTimeOut(shortInterval);
TPositionUpdateOptions theUpdateOptions;
Err = positioner.GetUpdateOptions(theUpdateOptions);
if (theUpdateOptions.UpdateTimeOut() != updateOptionsLong.UpdateTimeOut() ||
updateOptionsLong.UpdateTimeOut() != longInterval)
{
_LIT(KUpdateOptions, "The update option was not set correctly");
LogErrorAndLeaveL(KUpdateOptions);
}
_LIT(KDelayMsg, "The successfull requests was completed within %d microsecs.");
_LIT(KCancelMsg, "The canceled requests was completed within %d microsecs.");
TRequestStatus status;
for (TInt i = 0; i < 10; i++) // makes 10 test inorder to get some statistic
{
positioner.SetUpdateOptions(updateOptionsLong);
TTime requestStartTime;
requestStartTime.UniversalTime();
positioner.NotifyPositionUpdate(info, status);
User::WaitForRequest(status);
TTime requestStopTime;
requestStopTime.UniversalTime();
TTimeIntervalMicroSeconds durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime);
TInt duration = durationMicro.Int64();
TBuf<100> timeMsg;
timeMsg.Format(KDelayMsg, duration);
INFO_PRINTF1(timeMsg);
//check error status
if (status != KErrNone)
{
_LIT(KErrPositionRequest, "error code returned from NotifyPositionUpdate, error code = %d");
TBuf<100> buf;
buf.Format(KErrPositionRequest, status.Int());
LogErrorAndLeaveL(buf);
}
TTimeIntervalMicroSeconds shortInterval(2000000);
updateOptionsShort.SetUpdateTimeOut(shortInterval);
positioner.SetUpdateOptions(updateOptionsShort);
requestStartTime.UniversalTime();
positioner.NotifyPositionUpdate(info, status);
User::WaitForRequest(status);
requestStopTime.UniversalTime();
durationMicro = requestStopTime.MicroSecondsFrom(requestStartTime);
duration = durationMicro.Int64();
#ifdef __WINS__
TTimeIntervalMicroSeconds winsFail(100000);
durationMicro = TTimeIntervalMicroSeconds(durationMicro.Int64()+winsFail.Int64());
#endif
timeMsg.Format(KCancelMsg, duration);
INFO_PRINTF1(timeMsg);
if (status != KErrTimedOut)
{
_LIT(KErrPositionRequest, "Request did not returned KErrTimedOut, status code = %d.");
TBuf<100> buf;
buf.Format(KErrPositionRequest, status.Int());
LogErrorAndLeaveL(buf);
}
//Check that the request was not aborted before the Interval
//Remove this condition if a lot of data is needed in test log.
if (durationMicro < shortInterval)
{
_LIT(KErrInterval, " The request was aborted before the set timed out ");
LogErrorAndLeaveL(KErrInterval);
}
} // end for loop
CleanupStack::PopAndDestroy(1); //positioner
Disconnect();
// Do timeout test
TestTimeoutL();
// Do cancel test
TestCancelL();
// ESLI-5QRA7U just check that it is not possible to set a timeout that is less than
// the update interval
TestOptionL();
}
void MyFrame::OnDisconnect(wxCommandEvent& WXUNUSED(event))
{
Disconnect();
}
