bool HTTPProxyHandler::HandleData(uint8_t *http_buff, std::size_t len)
{
assert(len); // This should always be called with a least a byte left to parse
while (len > 0)
{
//TODO: fallback to finding HOst: header if needed
switch (m_state)
{
case GET_METHOD:
switch (*http_buff)
{
case ' ': EnterState(GET_HOSTNAME); break;
default: m_method.push_back(*http_buff); break;
}
break;
case GET_HOSTNAME:
switch (*http_buff)
{
case ' ': EnterState(GET_HTTPV); break;
default: m_url.push_back(*http_buff); break;
}
break;
case GET_HTTPV:
switch (*http_buff)
{
case '\r': EnterState(GET_HTTPVNL); break;
default: m_version.push_back(*http_buff); break;
}
break;
case GET_HTTPVNL:
switch (*http_buff)
{
case '\n': EnterState(DONE); break;
default:
LogPrint(eLogError,"--- HTTP Proxy rejected invalid request ending with: ", ((int)*http_buff));
HTTPRequestFailed(); //TODO: add correct code
return false;
}
break;
default:
LogPrint(eLogError,"--- HTTP Proxy invalid state: ", m_state);
HTTPRequestFailed(); //TODO: add correct code 500
return false;
}
http_buff++;
len--;
if (m_state == DONE)
return CreateHTTPRequest(http_buff,len);
}
return true;
}
bool CStateBase::ChangeState(const string& s)
{
if(!m_CurState.empty()) LeaveState(m_CurState);
m_CurState = s;
EnterState(m_CurState);
return true;
}
DataExchangeTestState(LapdTest& fsm, int maxDuration, TestState* pNextState):
TestState(fsm, "DataExchangeTestState" , maxDuration),
m_totalCycles(fsm.GetProfile().m_DataExchangeCycle), m_currCycle(0),
m_left(*new L3(fsm, &fsm.GetL3Left(), fsm.GetL2Left().getL2() ) ),
m_right(*new L3(fsm, &fsm.GetL3Right(), fsm.GetL2Right().getL2() ) ),
//m_left (fsm, fsm.GetL3Left().GetL3Test(), fsm.GetL2Left().GetImpl() ) ,
//m_right (fsm, fsm.GetL3Right().GetL3Test(), fsm.GetL2Right().GetImpl() ) ,
m_completed(false),
m_pNextState(pNextState)
{
GetOwner().GetL3Left().SwitchTo(&m_left);
GetOwner().GetL3Right().SwitchTo(&m_right);
EnterState(SEND_I_FROM_LEFT_SAFE); // установка начального состо¤ни¤
}
void Proc()
{
if (Completed()) return;
bool leftRes = m_left.Process();
bool rightRes = m_right.Process();
if (leftRes && rightRes)
{
InnerState next = NextState(m_state);
if (next == TEST_COMPLETED)
{
ResetDrv();
m_completed = true;
return;
}
EnterState(next);
}
}
G2DTestSystemDriver::G2DTestSystemDriver (int argc, char* argv[])
{
state_sptr = 0;
EnterState (stInit);
SwitchBB = false;
object_reg = csInitializer::CreateEnvironment (argc, argv);
if (!csInitializer::SetupConfigManager (object_reg, "/config/g2dtest.cfg"))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.g2dtest",
"Unable to init app!");
exit (0);
}
if (!csInitializer::RequestPlugins (object_reg,
CS_REQUEST_VFS,
CS_REQUEST_FONTSERVER,
CS_REQUEST_LEVELLOADER,
CS_REQUEST_END))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.g2dtest",
"Unable to init app!");
exit (0);
}
csRef<iEventQueue> q (csQueryRegistry<iEventQueue> (object_reg));
if (q != 0)
{
EventOutlet = q->GetEventOutlet();
EventOutlet->IncRef();
}
}
void App_t::ITask() {
while(true) {
uint32_t EvtMsk = chEvtWaitAny(ALL_EVENTS);
// ==== Card ====
if(EvtMsk & EVTMSK_CARD_APPEARS) ProcessCardAppearance();
#if 1 // ==== Door ====
if(EvtMsk & EVTMSK_DOOR_OPEN) {
DoorState = dsOpen;
Led.StartSequence(lsqDoorOpen); // Set color
SndList.PlayRandomFileFromDir(DIRNAME_GOOD_KEY);
Uart.Printf("\rDoor is open");
chSysLock();
if(chVTIsArmedI(&IDoorTmr)) chVTResetI(&IDoorTmr);
chVTSetI(&IDoorTmr, MS2ST(DOOR_CLOSE_TIMEOUT), TmrGeneralCallback, (void*)EVTMSK_DOOR_SHUT);
chSysUnlock();
}
if(EvtMsk & EVTMSK_DOOR_SHUT) {
DoorState = dsClosed;
Led.StartSequence(lsqDoorClose); // Set color
SndList.PlayRandomFileFromDir(DIRNAME_DOOR_CLOSING);
Uart.Printf("\rDoor is closing");
}
if(EvtMsk & EVTMSK_BAD_KEY) {
Led.StartSequence(lsqDoorWrongKey);
SndList.PlayRandomFileFromDir(DIRNAME_BAD_KEY);
Uart.Printf("\rBadKey");
}
#endif
#if 1 // ==== Secret key ====
if(EvtMsk & EVTMSK_SECRET_KEY) {
Led.StartSequence(lsqDoorSecretKey);
SndList.PlayRandomFileFromDir(DIRNAME_SECRET);
Uart.Printf("\rSecretKey");
}
#endif
#if 1 // ==== Keys ====
if(EvtMsk & EVTMSK_KEYS) {
KeyEvtInfo_t EInfo;
while(Keys.EvtBuf.Get(&EInfo) == OK) {
// Uart.Printf("\rEinfo: %u, %u, %u", EInfo.Type, EInfo.KeysCnt, EInfo.KeyID[0]);
if(EInfo.Type == kePress) {
switch(EInfo.KeyID[0]) {
// Iterate AccessAdd / AccessRemove / Idle
case keyA:
switch(State) {
case asAddingAccess: EnterState(asRemovingAccess); break;
case asRemovingAccess: EnterState(asIdle); break;
default: EnterState(asAddingAccess); break;
} // switch State
break;
// Iterate AdderAdd / AdderRemove / Idle
case keyB:
switch(State) {
case asAddingAdder: EnterState(asRemovingAdder); break;
case asRemovingAdder: EnterState(asIdle); break;
default: EnterState(asAddingAdder); break;
} // switch State
break;
// Iterate RemoverAdd / RemoverRemove / Idle
case keyC:
switch(State) {
case asAddingRemover: EnterState(asRemovingRemover); break;
case asRemovingRemover: EnterState(asIdle); break;
default: EnterState(asAddingRemover); break;
} // switch State
break;
} // switch
} // if keypress
else if(EInfo.Type == keCombo and EInfo.KeyID[0] == keyA and EInfo.KeyID[1] == keyB) {
LedService.StartSequence(lsqEraseAll);
IDStore.EraseAll();
chThdSleepMilliseconds(1530); // Allow LED to complete blinking
EnterState(asIdle);
}
} // while
} // if keys
#endif
#if USB_ENABLED // ==== USB connection ====
if(EvtMsk & EVTMSK_USB_CONNECTED) {
chSysLock();
Clk.SetFreq48Mhz();
Clk.InitSysTick();
chSysUnlock();
Usb.Init();
chThdSleepMilliseconds(540);
Usb.Connect();
Uart.Printf("\rUsb connected, AHB freq=%uMHz", Clk.AHBFreqHz/1000000);
}
if(EvtMsk & EVTMSK_USB_DISCONNECTED) {
Usb.Shutdown();
MassStorage.Reset();
chSysLock();
Clk.SetFreq12Mhz();
Clk.InitSysTick();
chSysUnlock();
Uart.Printf("\rUsb disconnected, AHB freq=%uMHz", Clk.AHBFreqHz/1000000);
}
#endif
// ==== State timeout ====
if(EvtMsk & EVTMSK_STATE_TIMEOUT) EnterState(asIdle);
} // while true
}
void App_t::ProcessCardAppearance() {
// App.CurrentID.Print();
#if SAVE_LAST_ID
if(LastID != CurrentID) {
LastID = CurrentID;
if(SD.OpenRewrite(LAST_ID_FILENAME) == OK) {
for(uint32_t i=0; i<8; i++) f_printf(&SD.File, "%02X", LastID.ID8[i]);
SD.Close();
// Uart.Printf("\rID saved");
}
}
#endif
// Proceed with check
IdKind_t IdKind = IDStore.Check(CurrentID);
switch(State) {
case asIdle:
if(DoorState == dsClosed) {
switch(IdKind) {
case ikAccess: SendEvt(EVTMSK_DOOR_OPEN); break;
case ikSecret: SendEvt(EVTMSK_SECRET_KEY); break;
case ikAdder: EnterState(asAddingAccess); break;
case ikRemover: EnterState(asRemovingAccess); break;
case ikNone: SendEvt(EVTMSK_BAD_KEY); break;
}
}
return;
break;
case asAddingAccess:
switch(IdKind) {
case ikAdder: EnterState(asIdle); break;
case ikRemover: EnterState(asRemovingAccess); break;
case ikNone:
if(IDStore.Add(CurrentID, ikAccess) == OK) ShowAddRemoveResult(arrAddingOk);
else ShowAddRemoveResult(arrAddingErr);
break;
case ikAccess: ShowAddRemoveResult(arrAddingOk); break; // already in base
case ikSecret: break;
}
break;
case asRemovingAccess:
switch(IdKind) {
case ikAdder: EnterState(asAddingAccess); break;
case ikRemover: EnterState(asIdle); break;
case ikNone: ShowAddRemoveResult(arrRemovingOk); break; // already absent
case ikAccess:
IDStore.Remove(CurrentID, ikAccess);
ShowAddRemoveResult(arrRemovingOk);
break;
case ikSecret: break;
}
break;
case asAddingAdder:
Uart.Printf("\rAdding Adder");
switch(IdKind) {
case ikAdder: LedService.StartSequence(lsqAddingAdderNew); break; // already in base
case ikRemover:
IDStore.Remove(CurrentID, ikRemover);
if(IDStore.Add(CurrentID, ikAdder) == OK) LedService.StartSequence(lsqAddingAdderNew);
else LedService.StartSequence(lsqAddingAdderError);
break;
case ikNone:
if(IDStore.Add(CurrentID, ikAdder) == OK) LedService.StartSequence(lsqAddingAdderNew);
else LedService.StartSequence(lsqAddingAdderError);
break;
case ikAccess:
IDStore.Remove(CurrentID, ikAccess);
if(IDStore.Add(CurrentID, ikAdder) == OK) LedService.StartSequence(lsqAddingAdderNew);
else LedService.StartSequence(lsqAddingAdderError);
break;
case ikSecret: break;
}
break;
case asRemovingAdder:
Uart.Printf("\rRemoving Adder");
LedService.StartSequence(lsqRemovingAdderNew);
IDStore.Remove(CurrentID, ikAdder);
break;
case asAddingRemover:
Uart.Printf("\rAdding Remover");
switch(IdKind) {
case ikAdder:
IDStore.Remove(CurrentID, ikAdder);
if(IDStore.Add(CurrentID, ikRemover) == OK) LedService.StartSequence(lsqAddingRemoverNew);
else LedService.StartSequence(lsqAddingRemoverError);
break;
case ikRemover: LedService.StartSequence(lsqAddingRemoverNew); break; // already in base
case ikNone:
if(IDStore.Add(CurrentID, ikRemover) == OK) LedService.StartSequence(lsqAddingRemoverNew);
else LedService.StartSequence(lsqAddingRemoverError);
break;
case ikAccess:
IDStore.Remove(CurrentID, ikAccess);
if(IDStore.Add(CurrentID, ikRemover) == OK) LedService.StartSequence(lsqAddingRemoverNew);
else LedService.StartSequence(lsqAddingRemoverError);
break;
case ikSecret: break;
}
break;
case asRemovingRemover:
Uart.Printf("\rRemoving Remover");
LedService.StartSequence(lsqRemovingRemoverNew);
IDStore.Remove(CurrentID, ikRemover);
break;
} // switch
RestartStateTimer();
}
// ------------------------------------------------------------------------------------------------
int main(int argc, const char **argv)
{
// Common variables
NetBuf *inPkt;
TcpHeader *inHdr;
Packet *outPkt;
TcpHeader *outHdr;
TcpConn *conn;
TestSetup();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSED, "RST", "segment dropped");
inPkt = NetAllocBuf();
inHdr = (TcpHeader *)inPkt->start;
inHdr->srcPort = 100;
inHdr->dstPort = 101;
inHdr->seq = 1;
inHdr->ack = 2;
inHdr->off = 5 << 4;
inHdr->flags = TCP_RST;
inHdr->windowSize = TCP_WINDOW_SIZE;
inHdr->checksum = 0;
inHdr->urgent = 0;
TcpInput(inPkt);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSED, "ACK", "RST sent");
inPkt = NetAllocBuf();
inHdr = (TcpHeader *)inPkt->start;
inHdr->srcPort = 100;
inHdr->dstPort = 101;
inHdr->seq = 1;
inHdr->ack = 2;
inHdr->off = 5 << 4;
inHdr->flags = TCP_ACK;
inHdr->windowSize = TCP_WINDOW_SIZE;
inHdr->checksum = 0;
inHdr->urgent = 0;
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, 101);
ASSERT_EQ_UINT(outHdr->dstPort, 100);
ASSERT_EQ_UINT(outHdr->seq, 2);
ASSERT_EQ_UINT(outHdr->ack, 0);
ASSERT_EQ_HEX8(outHdr->flags, TCP_RST);
free(outPkt);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSED, "no ACK", "RST/ACK sent");
inPkt = NetAllocBuf();
inHdr = (TcpHeader *)inPkt->start;
inHdr->srcPort = 100;
inHdr->dstPort = 101;
inHdr->seq = 1;
inHdr->ack = 2;
inHdr->off = 5 << 4;
inHdr->flags = 0;
inHdr->windowSize = TCP_WINDOW_SIZE;
inHdr->checksum = 0;
inHdr->urgent = 0;
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, 101);
ASSERT_EQ_UINT(outHdr->dstPort, 100);
ASSERT_EQ_UINT(outHdr->seq, 0);
ASSERT_EQ_UINT(outHdr->ack, 1);
ASSERT_EQ_HEX8(outHdr->flags, TCP_RST | TCP_ACK);
free(outPkt);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSED, "connect", "goto SYN_SENT");
conn = CreateConn();
ASSERT_TRUE(TcpConnect(conn, &s_ipAddr, 80));
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_TRUE(outHdr->srcPort >= 49152);
ASSERT_EQ_UINT(outHdr->dstPort, 80);
ASSERT_EQ_UINT(outHdr->seq, conn->iss);
ASSERT_EQ_UINT(outHdr->ack, 0);
ASSERT_EQ_HEX8(outHdr->flags, TCP_SYN);
ASSERT_EQ_UINT(outHdr->windowSize, TCP_WINDOW_SIZE);
ASSERT_EQ_UINT(outHdr->urgent, 0);
free(outPkt);
ExitState(conn, TCP_SYN_SENT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "Bad ACK, no RST", "RST sent");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss, TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, inHdr->ack);
ASSERT_EQ_UINT(outHdr->ack, 0);
ASSERT_EQ_HEX8(outHdr->flags, TCP_RST);
free(outPkt);
ExitState(conn, TCP_SYN_SENT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "Bad ACK, RST", "segment dropped");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss, TCP_RST | TCP_ACK);
TcpInput(inPkt);
ExitState(conn, TCP_SYN_SENT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "ACK, RST", "conn locally reset");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss + 1, TCP_RST | TCP_ACK);
TcpInput(inPkt);
ExpectError(TCP_CONN_RESET);
ExitState(conn, TCP_CLOSED);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "no ACK, RST", "segment dropped");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss + 1, TCP_RST);
TcpInput(inPkt);
ExitState(conn, TCP_SYN_SENT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "SYN, ACK", "goto ESTABLISHED");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss + 1, TCP_SYN | TCP_ACK);
TcpInput(inPkt);
ASSERT_EQ_UINT(conn->irs, 1000);
ASSERT_EQ_UINT(conn->rcvNxt, 1001);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->iss + 1);
ASSERT_EQ_UINT(outHdr->ack, 1001);
ASSERT_EQ_HEX8(outHdr->flags, TCP_ACK);
free(outPkt);
ExitState(conn, TCP_ESTABLISHED);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "SYN, no ACK", "goto SYN_RECEIVED, resend SYN,ACK");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, 0, TCP_SYN);
TcpInput(inPkt);
ASSERT_EQ_UINT(conn->irs, 1000);
ASSERT_EQ_UINT(conn->rcvNxt, 1001);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->iss);
ASSERT_EQ_UINT(outHdr->ack, 1001);
ASSERT_EQ_HEX8(outHdr->flags, TCP_SYN | TCP_ACK);
free(outPkt);
ExitState(conn, TCP_SYN_RECEIVED);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
uint generalStates[] =
{
TCP_SYN_RECEIVED,
TCP_ESTABLISHED,
TCP_FIN_WAIT_1,
TCP_FIN_WAIT_2,
TCP_CLOSE_WAIT,
TCP_CLOSING,
TCP_LAST_ACK,
TCP_TIME_WAIT,
0,
};
for (uint *pState = generalStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "Bad seq, no RST", "resend ACK");
conn = CreateConn();
EnterState(conn, state);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt - 1, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->sndNxt);
ASSERT_EQ_UINT(outHdr->ack, conn->rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_ACK);
free(outPkt);
ExitState(conn, state);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
for (uint *pState = generalStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "Bad seq, RST", "segment dropped");
conn = CreateConn();
EnterState(conn, state);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt - 1, conn->sndNxt, TCP_RST | TCP_ACK);
TcpInput(inPkt);
ExitState(conn, state);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_RECEIVED, "RST, active", "conn refused");
conn = CreateConn();
EnterState(conn, TCP_SYN_RECEIVED);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, 0, TCP_RST);
TcpInput(inPkt);
ExpectError(TCP_CONN_REFUSED);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
uint rstStates1[] =
{
TCP_ESTABLISHED,
TCP_FIN_WAIT_1,
TCP_FIN_WAIT_2,
TCP_CLOSE_WAIT,
0,
};
for (uint *pState = rstStates1; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "RST", "conn reset");
conn = CreateConn();
EnterState(conn, state);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, 0, TCP_RST);
TcpInput(inPkt);
ExpectError(TCP_CONN_RESET);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
uint rstStates2[] =
{
TCP_CLOSING,
TCP_LAST_ACK,
TCP_TIME_WAIT,
0,
};
for (uint *pState = rstStates2; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "RST", "conn closed");
conn = CreateConn();
EnterState(conn, state);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, 0, TCP_RST);
TcpInput(inPkt);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
for (uint *pState = generalStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "SYN", "conn reset, RST sent");
conn = CreateConn();
EnterState(conn, state);
u16 localPort = conn->localPort;
u16 remotePort = conn->remotePort;
u32 rcvNxt = conn->rcvNxt;
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_SYN);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, localPort);
ASSERT_EQ_UINT(outHdr->dstPort, remotePort);
ASSERT_EQ_UINT(outHdr->seq, 0);
ASSERT_EQ_UINT(outHdr->ack, rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_RST | TCP_ACK);
free(outPkt);
ExpectError(TCP_CONN_RESET);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_RECEIVED, "bad ACK", "RST sent");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_RECEIVED, "ACK", "goto ESTABLISHED");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
uint ackStates[] =
{
TCP_ESTABLISHED,
TCP_FIN_WAIT_1,
TCP_FIN_WAIT_2,
TCP_CLOSE_WAIT,
TCP_CLOSING,
0
};
for (uint *pState = ackStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "ACK", "update pointers");
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
for (uint *pState = ackStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "dup ACK", "ignore");
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
for (uint *pState = ackStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "unsent ACK", "resend ACK");
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_FIN_WAIT_1, "ACK, FIN not ACK'd", "ignore");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSING, "ACK, FIN not ACK'd", "ignore");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_FIN_WAIT_1, "ACK, FIN ACK'd", "goto FIN-WAIT-2");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSING, "ACK, FIN ACK'd", "goto TIME-WAIT");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_LAST_ACK, "ACK, FIN not ACK'd", "ignore");
conn = CreateConn();
EnterState(conn, TCP_LAST_ACK);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt - 1, TCP_ACK);
TcpInput(inPkt);
ExitState(conn, TCP_LAST_ACK);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_LAST_ACK, "ACK, FIN ACK'd", "goto CLOSED");
conn = CreateConn();
EnterState(conn, TCP_LAST_ACK);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_TIME_WAIT, "ACK, no FIN", "ignore");
conn = CreateConn();
EnterState(conn, TCP_TIME_WAIT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
ExitState(conn, TCP_TIME_WAIT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_TIME_WAIT, "FIN", "reset 2MSL timer");
conn = CreateConn();
EnterState(conn, TCP_TIME_WAIT);
g_pitTicks += 1000;
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->sndNxt);
ASSERT_EQ_UINT(outHdr->ack, conn->rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_ACK);
free(outPkt);
ASSERT_EQ_UINT(conn->mslWait, g_pitTicks + 2 * TCP_MSL);
ExitState(conn, TCP_TIME_WAIT);
TestCaseEnd();
return EXIT_SUCCESS;
}
// ------------------------------------------------------------------------------------------------
static void EnterState(TcpConn *conn, uint state)
{
NetBuf *inPkt;
TcpHeader *inHdr;
Packet *outPkt;
//TcpHeader *outHdr;
switch (state)
{
case TCP_SYN_SENT:
ASSERT_TRUE(TcpConnect(conn, &s_ipAddr, 80));
outPkt = PopPacket();
free(outPkt);
break;
case TCP_SYN_RECEIVED:
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, 0, TCP_SYN);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_ESTABLISHED:
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_SYN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_FIN_WAIT_1:
EnterState(conn, TCP_ESTABLISHED);
TcpClose(conn);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_FIN_WAIT_2:
EnterState(conn, TCP_FIN_WAIT_1);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
break;
case TCP_CLOSE_WAIT:
EnterState(conn, TCP_ESTABLISHED);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_CLOSING:
EnterState(conn, TCP_FIN_WAIT_1);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt - 1, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_LAST_ACK:
EnterState(conn, TCP_CLOSE_WAIT);
TcpClose(conn);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_TIME_WAIT:
EnterState(conn, TCP_FIN_WAIT_1);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
default:
ASSERT_EQ_UINT(state, 0);
break;
}
ASSERT_EQ_UINT(conn->state, state);
ASSERT_TRUE(ListIsEmpty(&s_outPackets));
}
void G2DTestSystemDriver::SetupFrame ()
{
if (state_sptr == 0)
{
EventOutlet->Broadcast (csevQuit (object_reg));
return;
}
appState curstate = state [state_sptr - 1];
switch (curstate)
{
case stInit:
case stStartup:
case stContextInfo:
case stWindowFixed:
case stWindowResize:
case stCustomCursor:
case stCustomIcon:
case stAlphaTest:
case stTestUnicode1:
case stTestUnicode2:
case stTestFreetype:
case stTestLineDraw:
case stTestLinePerf:
case stTestTextDraw:
case stTestTextDraw2:
case stPixelClipTest:
case stLineClipTest:
case stBoxClipTest:
case stFontClipTest:
case stBlitTest:
{
if (!myG3D->BeginDraw (CSDRAW_2DGRAPHICS))
break;
myG2D->Clear (black);
LeaveState ();
switch (curstate)
{
case stInit:
fontLarge = GetFont (CSFONT_LARGE);
fontItalic = GetFont (CSFONT_ITALIC);
fontCourier = GetFont (CSFONT_COURIER);
fontSmall = GetFont (CSFONT_SMALL);
{
csRef<iVFS> vfs = csQueryRegistry<iVFS> (object_reg);
csRef<iImageIO> iio =
csQueryRegistry<iImageIO> (object_reg);
if (vfs.IsValid () && iio.IsValid ())
{
csRef<iFile> testFile = vfs->Open ("/lib/g2dtest/up.png",
VFS_FILE_READ);
if (testFile.IsValid ())
{
csRef<iDataBuffer> fileData = testFile->GetAllData ();
blitTestImage = iio->Load (fileData, CS_IMGFMT_TRUECOLOR
| CS_IMGFMT_ALPHA);
}
testFile = vfs->Open ("/lib/std/cslogo2.png", VFS_FILE_READ);
if (testFile.IsValid ())
{
csRef<iDataBuffer> fileData = testFile->GetAllData ();
alphaBlitImage = iio->Load (fileData, CS_IMGFMT_TRUECOLOR |
CS_IMGFMT_ALPHA);
}
}
}
EnterState (stStartup);
break;
case stStartup:
DrawStartupScreen ();
EnterState (stContextInfo);
EnterState (stPause, 5000);
break;
case stContextInfo:
DrawContextInfoScreen ();
EnterState (stWindowFixed);
EnterState (stWaitKey);
break;
case stWindowFixed:
DrawWindowScreen ();
EnterState (stWindowResize);
EnterState (stWaitKey);
break;
case stWindowResize:
DrawWindowResizeScreen ();
EnterState (stCustomCursor);
EnterState (stWaitKey);
break;
case stCustomCursor:
DrawCustomCursorScreen ();
SetCustomCursor ();
if (lastkey9)
EnterState (stCustomIcon);
else
EnterState (stCustomCursor);
break;
case stCustomIcon:
SetNormalCursor ();
SetCustomIcon ();
DrawCustomIconScreen ();
EnterState (stAlphaTest);
EnterState (stWaitKey);
break;
case stAlphaTest:
DrawAlphaTestScreen ();
EnterState (stTestUnicode1);
EnterState (stWaitKey);
break;
case stTestUnicode1:
DrawUnicodeTest1 ();
EnterState (stTestUnicode2);
EnterState (stWaitKey);
break;
case stTestUnicode2:
DrawUnicodeTest2 ();
EnterState (stTestFreetype);
EnterState (stWaitKey);
break;
case stTestFreetype:
DrawFreetypeTest ();
EnterState (stTestLineDraw);
EnterState (stWaitKey);
break;
case stTestLineDraw:
DrawLineTest ();
EnterState (stTestLinePerf);
EnterState (stWaitKey);
break;
case stTestLinePerf:
DrawLinePerf ();
if (lastkey2)
EnterState (stTestTextDraw);
else
EnterState (stTestLinePerf);
break;
case stTestTextDraw:
DrawTextTest ();
if (lastkey3)
EnterState (stTestTextDraw2);
else
EnterState (stTestTextDraw);
break;
case stTestTextDraw2:
DrawTextTest2 ();
if (lastkey4)
EnterState (stPixelClipTest);
else
EnterState (stTestTextDraw2);
break;
case stPixelClipTest:
PixelClipTest ();
if (lastkey5)
{
myG2D->SetClipRect(0,0,myG2D->GetWidth(), myG2D->GetHeight());
EnterState (stLineClipTest);
}
else
EnterState (stPixelClipTest);
break;
case stLineClipTest:
LineClipTest ();
if (lastkey6)
{
myG2D->SetClipRect(0,0,myG2D->GetWidth(), myG2D->GetHeight());
EnterState (stBoxClipTest);
}
else
EnterState (stLineClipTest);
break;
case stBoxClipTest:
BoxClipTest ();
if (lastkey7)
{
myG2D->SetClipRect(0,0,myG2D->GetWidth(), myG2D->GetHeight());
EnterState (stFontClipTest);
}
else
EnterState (stBoxClipTest);
break;
case stFontClipTest:
FontClipTest ();
if (lastkey8)
EnterState (stBlitTest);
else
EnterState (stFontClipTest);
break;
case stBlitTest:
BlitTest ();
EnterState (stWaitKey);
break;
default:
break;
}
break;
}
case stPause:
if (int (csGetTicks () - timer) > 0)
LeaveState ();
else
csSleep (1);
break;
case stWaitKey:
if (lastkey)
{
LeaveState ();
SwitchBB = false;
}
else
{
if (SwitchBB)
{
myG2D->Print (0);
csSleep (200);
}
else
csSleep (1);
}
break;
}
}
void CollisionManager::Update(bool ShootingState, bool IntakeState, bool DefensiveState, bool TowerShotState)//, bool EndGameState)
{
//int safezone = 4000;
ShooterState_Prev = ShooterState_Cur;
ShooterState_Cur = ShootingState;
IntakeState_Prev = IntakeState_Cur;
IntakeState_Cur = IntakeState;
DefensiveState_Prev = DefensiveState_Cur;
DefensiveState_Cur = DefensiveState;
TowerShotState_Prev = TowerShotState_Cur;
TowerShotState_Cur = TowerShotState;
//EndGameState_Prev = EndGameState_Cur;
//EndGameState_Cur = EndGameState;
if(!ShooterState_Prev && ShooterState_Cur)
{
EnterState(RobotMode::Shooting);
}
if(!IntakeState_Prev && IntakeState_Cur)
{
EnterState(RobotMode::Intake);
}
if(!DefensiveState_Prev && DefensiveState_Cur)
{
EnterState(RobotMode::Defensive);
}
if(!TowerShotState_Prev && TowerShotState_Cur)
{
EnterState(RobotMode::TowerShot);
}
//if(!EndGameState_Prev && EndGameState_Cur)
//{
//EnterState(RobotMode::EndGame);
//}
if(transitioning == true)
{
if(currentMode == RobotMode::Intake)
{
switch(state)
{
case 0 :
//Reset Intske
IntakeRef->LiftPIDController->Enable();
IntakeRef->GotoIntake();
state = 1;
counter = 0;
break;
case 1 :
//Reset Turret and wait Intake
if(fabs(IntakeRef->GetLiftEncoder()-Preset_Intake_Intake) <= 20)
{
counter++;
}
else
{
counter = 0;
}
if (counter > 100)
{
ArmRef->TurretPIDController->Enable();
state = 2;
ArmRef->ResetTurret();
}
break;
case 2 :
if(fabs(ArmRef->GetTurretEncoder()) <= 10)
{
ArmRef->ArmPIDController->Enable();
ArmRef->ResetArm();
state = 3;
}
break;
case 3:
if(fabs(ArmRef->GetLifterEncoder() - Preset_Arm_Floor <= 10))
{
ArmRef->ArmPIDController->Disable();
ArmRef->TurretPIDController->Disable();
IntakeRef->GotoIntake();
Wait(.25f);
ArmRef->GoToArm();
state = 4;
transitioning = false;
}
}
}
else if(currentMode == RobotMode::Shooting)
{
PresetTimer->Reset();
PresetTimer->Start();
switch(state)
{
case 0 :
state = 1;
IntakeRef->LiftPIDController->Enable();
//Reset Intake
ArmRef->ArmPIDController->Enable();
ArmRef->TurretPIDController->Enable();
IntakeRef->GotoIntake();
break;
case 1 :
//Reset Turret and wait Intake
if(fabs(IntakeRef->GetLiftEncoder()-Preset_Intake_Intake) <= 20)
{
state = 2;
ArmRef->ResetTurret();
}
break;
case 2 :
if(fabs(ArmRef->GetTurretEncoder()) <= 5)
{
state = 3;
ArmRef->GotoShooting();
}
break;
case 3 :
if(fabs(ArmRef->GetLifterEncoder() - Preset_Arm_Far_Shot) <= 20)
{
PresetTimer->Reset();
PresetTimer->Start();
state = 4;
}
break;
case 4 :
if(PresetTimer->Get() > 10)
{
state = 5;
ArmRef->ArmPIDController->Disable();
// IntakeRef->LiftPIDController->Disable();
ArmRef->TurretPIDController->Disable();
transitioning = false;
}
break;
}
}
else if(currentMode == RobotMode::Defensive)
{
switch(state)
{
case 0 :
IntakeRef->LiftPIDController->Enable();
//Reset Intske
ArmRef->ArmPIDController->Reset();
ArmRef->ArmPIDController->Enable();
IntakeRef->GotoIntake();
state = 1;
break;
case 1 :
//Reset Turret and wait Intake
if(fabs(IntakeRef->GetLiftEncoder() - Preset_Intake_Intake) <= 20)
{
state = 2;
ArmRef->SetArm(Preset_Arm_Defense);
}
break;
case 2 :
if(fabs(ArmRef->GetLifterEncoder()-Preset_Arm_Defense) <= 200)
{
IntakeRef->GotoDefense();
ArmRef->ArmPIDController->Disable();
state = 3;
}
break;
case 3:
if(fabs(IntakeRef->GetLiftEncoder() - Preset_Intake_Defense) <= 20)
{
IntakeRef->LiftPIDController->Disable();
state = 4;
transitioning = false;
}
break;
}
}
else if(currentMode == RobotMode::TowerShot)
{
switch(state)
{
case 0 :
IntakeRef->LiftPIDController->Enable();
ArmRef->ArmPIDController->Enable();
//Move Intake to Intake position
IntakeRef->GotoIntake();
state = 1;
break;
case 1 :
//Reset Turret
if(fabs(IntakeRef->GetLiftEncoder()-Preset_Intake_Intake) <= 20)
{
state = 2;
ArmRef->ResetTurret();
transitioning = 2;
}
break;
case 2 :
//Move Arm to Tower Shot
if(fabs(IntakeRef->GetLiftEncoder()-Preset_Intake_Intake) <= 20)
{
state = 3;
ArmRef->GotoTowerShot();
transitioning = 3;
}
break;
case 3 :
//Reset PID Controllers
if(fabs(ArmRef->GetLifterEncoder() - Preset_Arm_Tower_Shot) <= -1870)
{
state = 4;
IntakeRef->LiftPIDController->Disable();
ArmRef->ArmPIDController->Disable();
transitioning = false;
}
break;
}
}
/*else if(currentMode == RobotMode::EndGame)
{
switch(state)
{
case 0 :
//Reset Intske
IntakeRef->GotoFloor();
state = 1;
break;
case 1 :
//Reset Turret and wait Intake
if(fabs(IntakeRef->GetLiftEncoder()) <= 20)
{
state = 2;
ArmRef->SetArm(5000);
}
break;
case 2 :
if(fabs(ArmRef->GetLifterEncoder()-5000) <= 200)
{
IntakeRef->GotoDefense();
state = 3;
transitioning = false;
}
}
}
*/
}
}
HTTPProxyHandler(HTTPProxyServer * parent, std::shared_ptr<boost::asio::ip::tcp::socket> sock) :
I2PServiceHandler(parent), m_sock(sock)
{ EnterState(GET_METHOD); }
