void MvcController::UponChildFocus(wxChildFocusEvent& event)
{
event.Skip();
wxWindow* new_focused_window = FindFocus();
// A wxChildFocusEvent is sent for every window in the hierarchy,
// from new_focused_window up to this MvcController. Ignore all
// but the "deepest" one--see:
// http://lists.nongnu.org/archive/html/lmi/2009-01/msg00001.html
if(event.GetWindow() != new_focused_window)
{
return;
}
// Do nothing if focus hasn't changed. This case arises when
// another application is activated, and then this application
// is reactivated.
if(last_focused_window_ == new_focused_window)
{
return;
}
if
( wxID_CANCEL == new_focused_window->GetId()
|| wxID_HELP == new_focused_window->GetId()
)
{
return;
}
if(Validate())
{
if(new_focused_window)
{
last_focused_window_ = new_focused_window;
}
else
{
warning() << "Keyboard focus was lost." << LMI_FLUSH;
RefocusLastFocusedWindow();
}
}
else
{
LMI_ASSERT(!unit_test_refocus_event_pending_);
if(!unit_test_under_way_)
{
wxCommandEvent event0(wxEVT_REFOCUS_INVALID_CONTROL);
wxPostEvent(this, event0);
}
unit_test_refocus_event_pending_ = true;
}
}
int main(int argc, char ** argv)
{
// our identity and the identity of the other partner
unsigned char * host, * xhost;
size_t host_len, xhost_len;
unsigned char * pkey, * skey, * xkey;
size_t pkey_len, skey_len, xkey_len;
unsigned char * m1, * m1_e;
unsigned char * xNa, * xNb;
size_t m1_len, m1_e_len;
size_t m1_l;
unsigned char * m2, * m2_e;
unsigned char * Nb;
size_t m2_len, m2_e_len;
unsigned char * m3, * m3_e;
size_t m3_len, m3_e_len;
unsigned char * p;
// for dropping encryption tags
unsigned char * dummy = malloc(4);
BIO * bio = socket_listen();
host = get_host(&host_len, 'B');
pkey = get_pkey(&pkey_len, 'B');
skey = get_skey(&skey_len, 'B');
#ifdef VERBOSE
printf("B pkey = ");
print_buffer(pkey, pkey_len);
printf("\n");
printf("B skey = ");
print_buffer(skey, skey_len);
printf("\n");
#endif
/* Receive message 1 */
recv(bio, (unsigned char*) &m1_e_len, sizeof(m1_e_len));
if(m1_e_len > MAX_SIZE_CIPHER)
fail("Server: cipher in message 1 too long");
m1_e = malloc(m1_e_len);
recv(bio, m1_e, m1_e_len);
m1_len = decrypt_len(skey, skey_len, m1_e, m1_e_len);
m1 = malloc(m1_len);
m1_len = decrypt(skey, skey_len, m1_e, m1_e_len, m1);
if(sizeof(size_t) + SIZE_NONCE + 4 > m1_len)
{
fprintf(stderr, "m1 has wrong length\n");
exit(1);
}
if(memcmp(m1, "msg1", 4))
{
fprintf(stderr, "B: m1 not properly tagged, aborting\n");
exit(1);
}
m1_l = * (size_t *) (m1 + 4);
if(m1_l != SIZE_NONCE)
{
fprintf(stderr, "A: m1 contains wrong length for xNa\n");
exit(1);
}
xhost_len = m1_len - (4 + sizeof(size_t) + m1_l);
xhost = m1 + 4 + sizeof(size_t) + m1_l;
if(xhost_len > MAX_SIZE_HOST)
fail("B: host size in m1 too long");
#ifdef VERBOSE
printf("B xhost = ");
print_buffer(xhost, xhost_len);
printf("\n");
#endif
xkey = lookup_xkey(&xkey_len, xhost, xhost_len, 'B');
#ifdef VERBOSE
printf("B xkey = ");
print_buffer(xkey, xkey_len);
printf("\n");
#endif
/*
if(memcmp(m1 + sizeof(size_t) + m1_l + 4, xkey, xkey_len))
{
fprintf(stderr, "x_xkey in m1 doesn't match xkey\n");
exit(1);
}
*/
xNa = m1 + 4 + sizeof(size_t);
typehint(xNa, m1_l, "fixed_20_nonce");
#ifdef VERBOSE
fprintf(stderr, "B: m1 received and checked");
fprintf(stderr, "\n");
fflush(stderr);
#endif
#ifdef CSEC_VERIFY
#ifdef USE_EVENT_PARAMS
event2("server_begin", xhost, xhost_len, host, host_len);
#else
event0("server_begin");
#endif
#endif
/* Send message 2 */
m2_len = 2 * SIZE_NONCE + 2 * sizeof(size_t) + 4 + host_len;
p = m2 = malloc(m2_len);
memcpy(p, "msg2", 4);
p += 4;
* (size_t *) p = m1_l;
p += sizeof(size_t);
* (size_t *) p = SIZE_NONCE;
p += sizeof(size_t);
memcpy(p, xNa, m1_l);
p += m1_l;
Nb = p;
nonce(Nb);
p += SIZE_NONCE;
memcpy(p, host, host_len);
m2_e_len = encrypt_len(xkey, xkey_len, m2, m2_len);
if(m2_e_len > MAX_SIZE_CIPHER)
fail("Server: cipher in message 2 too long");
m2_e = malloc(m2_e_len);
m2_e_len = encrypt(xkey, xkey_len, m2, m2_len, m2_e);
send(bio, &m2_e_len, sizeof(m2_e_len));
send(bio, m2_e, m2_e_len);
#ifdef VERBOSE
printf("B: m2_e sent, m2_e = ");
print_buffer(m2_e, m2_e_len);
printf("\n");
fflush(stdout);
#endif
/* Receive message 3 */
recv(bio, (unsigned char*) &m3_e_len, sizeof(m3_e_len));
if(m3_e_len > MAX_SIZE_CIPHER)
fail("Server: cipher in message 3 too long");
m3_e = malloc(m3_e_len);
recv(bio, m3_e, m3_e_len);
m3_len = decrypt_len(skey, skey_len, m3_e, m3_e_len);
m3 = malloc(m3_len);
m3_len = decrypt(skey, skey_len, m3_e, m3_e_len, m3);
if(memcmp(m3, "msg3", 4))
{
fprintf(stderr, "B: m3 not properly tagged, aborting\n");
exit(1);
}
if(m3_len != SIZE_NONCE + 4)
{
fprintf(stderr, "B: m3 has wrong length\n");
exit(1);
}
xNb = m3 + 4;
typehint(xNb, SIZE_NONCE, "fixed_20_nonce");
if(memcmp(xNb, Nb, SIZE_NONCE))
{
fprintf(stderr, "xNb in m3 doesn't match Nb\n");
exit(1);
}
#ifdef VERBOSE
printf("B: Na = ");
print_buffer(xNa, SIZE_NONCE);
printf("\n");
printf("B: Nb = ");
print_buffer(Nb, SIZE_NONCE);
printf("\n");
fflush(stdout);
#endif
#ifdef CSEC_VERIFY
#ifdef USE_EVENT_PARAMS
event2("server_end", xhost, xhost_len, host, host_len);
#else
event0("server_end");
#endif
#endif
// wait for the client to close, to avoid "Address already in use" errors
wait_close(bio);
return 0;
}
void UT_CMceStateOffering::UT_CMceStateOffering_AcceptLL()
{
TMceIds ids;
CMceMsgBase* msg = NULL;
TMceStateTransitionEvent event0( *iSipSession, EMceUpdate );
EUNIT_ASSERT ( iState->AcceptL( event0 ) );
TMceStateTransitionEvent event1( *iSipSession, EMceItcCancel, ids, *msg );
EUNIT_ASSERT ( iState->AcceptL( event1 ) );
TMceStateTransitionEvent event2( *iSipSession, EMceResponse );
EUNIT_ASSERT ( iState->AcceptL( event2 ) );
TMceStateTransitionEvent event3( *iSipSession, EMceProvisionalResponse );
EUNIT_ASSERT ( iState->AcceptL( event3 ) );
TMceStateTransitionEvent event4( *iSipSession, EMceErrorResponse );
EUNIT_ASSERT ( iState->AcceptL( event4 ) );
TMceStateTransitionEvent event5( *iSipSession, EMceMediaUpdated );
EUNIT_ASSERT ( iState->AcceptL( event5 ) );
TMceStateTransitionEvent event6( *iSipSession, EMceRedirectionResponse );
EUNIT_ASSERT ( iState->AcceptL( event6 ) );
TMceStateTransitionEvent event7( *iSipSession, EMceMediaSessionStopped );
TRAPD( e1, iState->AcceptL( event7 ) );
EUNIT_ASSERT ( e1 == KErrTotalLossOfPrecision );
// Following Events will be accepted for Extenssion Requests
CSIPClientTransaction* clitransaction2 =
MCETestHelper::ClientTransactionLC( SipStrConsts::EInfo, KMceSipSessionProgress,
SipStrConsts::EPhraseSessionProgress, ETrue );
iSipSession->SetPendingTransactionL( clitransaction2 );
CleanupStack::Pop( clitransaction2 );
iSipSession->iResponse = clitransaction2;
TMceStateTransitionEvent event2a( *iSipSession, EMceResponse );
TRAPD( e2a, iState->AcceptL( event2a ) );
EUNIT_ASSERT ( e2a == KErrNone );
TMceStateTransitionEvent event2b( *iSipSession, EMceProvisionalResponse );
TRAPD( e2b, iState->AcceptL( event2b ) );
EUNIT_ASSERT ( e2b == KErrNone );
TMceStateTransitionEvent event2c( *iSipSession, EMceRedirectionResponse );
TRAPD( e2c, iState->AcceptL( event2c ) );
EUNIT_ASSERT ( e2c == KErrNone );
TMceStateTransitionEvent event2d( *iSipSession, EMceErrorResponse );
TRAPD( e2d, iState->AcceptL( event2d ) );
EUNIT_ASSERT ( e2d == KErrNone );
TMceStateTransitionEvent event2e( *iSipSession, EMceItcReplySend, ids, *msg );
TRAPD( e2e, iState->AcceptL( event2e ) );
EUNIT_ASSERT ( e2e == KErrNone );
TMceStateTransitionEvent event2f( *iSipSession, EMceRequest );
TRAPD( e2f, iState->AcceptL( event2f ) );
EUNIT_ASSERT ( e2f == KErrNone );
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("Bug_3541_Regression_Test"));
int ret = 0;
#if defined(ACE_WIN32) && !defined (ACE_USES_WINCE_SEMA_SIMULATION)
int lastError;
// ACE_OS::event_init()
const ACE_TCHAR *eventName = ACE_TEXT ("Bug3541_Event");
ACE_Event event0(0, // int manual_reset = 0
0, // int initial_state = 0
USYNC_PROCESS, // int type = USYNC_THREAD
eventName); // const ACE_TCHAR *name = 0
lastError = ACE_OS::last_error();
ACE_event_t eventHandle = event0.handle();
if ((eventHandle == ACE_INVALID_HANDLE) ||
(lastError != 0))
{
ret = -1;
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Event(%s) failed - handle %d lastError %d\n"),
eventName, eventHandle, lastError));
}
else
{
ACE_Event event1(0, // int manual_reset = 0
0, // int initial_state = 0
USYNC_PROCESS, // int type = USYNC_THREAD
eventName); // const ACE_TCHAR *name = 0
lastError = ACE_OS::last_error();
eventHandle = event1.handle();
if ((eventHandle == ACE_INVALID_HANDLE) ||
(lastError != ERROR_ALREADY_EXISTS))
{
ret = -1;
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Event(%s) failed - handle %d lastError %d\n"),
eventName, eventHandle, lastError));
}
}
// ACE_OS::sema_init
const ACE_TCHAR *semaphoreName = ACE_TEXT ("Bug3541_Semaphore");
ACE_Semaphore semaphore0(1, // int count = 1
USYNC_PROCESS, // int type = USYNC_THREAD
semaphoreName); // const ACE_TCHAR *name = 0
lastError = ACE_OS::last_error();
const ACE_sema_t &semaphoreLock = semaphore0.lock();
if ((semaphoreLock == ACE_INVALID_HANDLE) ||
(lastError != 0))
{
ret = -1;
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Semaphore(%s) failed - lock %d lastError %d\n"),
semaphoreName, semaphoreLock, lastError));
}
else
{
ACE_Semaphore semaphore1(1, // int count = 1
USYNC_PROCESS, // int type = USYNC_THREAD
semaphoreName); // const ACE_TCHAR *name = 0
lastError = ACE_OS::last_error();
const ACE_sema_t &semaphoreLock = semaphore1.lock();
if ((semaphoreLock == ACE_INVALID_HANDLE) ||
(lastError != ERROR_ALREADY_EXISTS))
{
ret = -1;
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Semaphore(%s) failed - lock %d lastError %d\n"),
semaphoreName, semaphoreLock, lastError));
}
}
// ACE_OS::mutex_init()
const ACE_TCHAR *mutexName = ACE_TEXT ("Bug3541_Mutex");
ACE_Mutex mutex0(USYNC_PROCESS, // int type = USYNC_THREAD
mutexName); // const ACE_TCHAR *name = 0
lastError = ACE_OS::last_error();
const ACE_mutex_t &mutexLock = mutex0.lock();
if ((mutexLock.proc_mutex_ == ACE_INVALID_HANDLE) ||
(lastError != 0))
{
ret = -1;
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Mutex(%s) failed - lock %d lastError %d\n"),
mutexName, mutexLock, lastError));
}
else
{
ACE_Mutex mutex1(USYNC_PROCESS, // int type = USYNC_THREAD
mutexName); // const ACE_TCHAR *name = 0
lastError = ACE_OS::last_error();
const ACE_mutex_t &mutexLock = mutex1.lock();
if ((mutexLock.proc_mutex_ == ACE_INVALID_HANDLE) ||
(lastError != ERROR_ALREADY_EXISTS))
{
ret = -1;
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_Mutex(%s) failed - lock %d lastError %d\n"),
mutexName, mutexLock, lastError));
}
}
#endif
ACE_END_TEST;
return ret;
}
