static BT_ERROR canRead(BT_HANDLE hCan, BT_CAN_MESSAGE *pCanMessage) {
volatile LPC17xx_CAN_REGS *pRegs = hCan->pRegs;
BT_ERROR Error = BT_ERR_NONE;
switch(hCan->eMode) {
case BT_CAN_MODE_POLLED:
{
while(!(pRegs->CANGSR & LPC17xx_CAN_GSR_RBS)) {
BT_ThreadYield();
}
CanReceive(hCan, pCanMessage);
break;
}
case BT_CAN_MODE_BUFFERED:
{
// Get bytes from RX buffer very quickly.
BT_FifoRead(hCan->hRxFifo, 1, pCanMessage, &Error);
break;
}
default:
// ERR, invalid handle configuration.
break;
}
return Error;
}
void CommandController::PollCommands()
{
for (auto iterator = commanders.begin(); iterator != commanders.end(); iterator++)
{
auto connection = *iterator;
if (connection->CanReceive())
{
std::string cmd = connection->Receive();
cmd.erase(std::remove_if(cmd.begin(), cmd.end(), std::isspace), cmd.end());
Process(connection->id, cmd);
}
}
}
void isr_CAN(BT_HANDLE hCan) {
volatile LPC17xx_CAN_REGS *pRegs = hCan->pRegs;
BT_ERROR Error;
BT_CAN_MESSAGE oMessage;
BT_u32 ulICR = pRegs->CANICR;
if (ulICR & LPC17xx_CAN_ICR_RI) {
CanReceive(g_CAN_HANDLES[0], &oMessage);
BT_FifoWrite(hCan->hRxFifo, 1, &oMessage, &Error);
}
if (ulICR & LPC17xx_CAN_ICR_TI) {
while (!BT_FifoIsEmpty(hCan->hTxFifo, &Error) && (canFindFreeBuffer(hCan) != LPC17xx_CAN_NO_FREE_BUFFER)) {
BT_FifoRead(hCan->hTxFifo, 1, &oMessage, &Error);
CanTransmit(hCan, &oMessage);
}
}
if (BT_FifoIsEmpty(hCan->hTxFifo, &Error)) {
pRegs->CANIER &= ~LPC17xx_CAN_IER_TIE; // Disable the interrupt
}
}
t_sm_state CSocks4StateMachine::next_state(t_sm_event event)
{
// Default is stay in current state
t_sm_state ret = HandleEvent(event);
switch (GetState()) {
case SOCKS4_STATE_START:
if (m_isConnected && !m_isLost && CanSend()) {
ret = SOCKS4_STATE_SEND_COMMAND_REQUEST;
}
break;
case SOCKS4_STATE_SEND_COMMAND_REQUEST:
if (m_ok) {
if (CanReceive()) {
ret = SOCKS4_STATE_RECEIVE_COMMAND_REPLY;
}
} else {
ret = SOCKS4_STATE_END;
}
break;
case SOCKS4_STATE_RECEIVE_COMMAND_REPLY:
ret = SOCKS4_STATE_PROCESS_COMMAND_REPLY;
break;
case SOCKS4_STATE_PROCESS_COMMAND_REPLY:
ret = SOCKS4_STATE_END;
break;
case SOCKS4_STATE_END:
default:
break;
}
return ret;
}
/**
* Code this such that the next state is only entered when it is able to
* perform the operation (read or write). State processing will assume
* that it can read or write upon entry of the state. This is done using
* CanSend() and CanReceive(). On daemon, these functions always return
* true, because sockets are blocking.
*/
t_sm_state CSocks5StateMachine::next_state(t_sm_event event)
{
// Default is stay in current state
t_sm_state ret = HandleEvent(event);
switch (GetState()) {
case SOCKS5_STATE_START:
if (m_isConnected && !m_isLost && CanSend()) {
ret = SOCKS5_STATE_SEND_QUERY_AUTHENTICATION_METHOD;
}
break;
case SOCKS5_STATE_SEND_QUERY_AUTHENTICATION_METHOD:
if (CanReceive()) {
ret = SOCKS5_STATE_RECEIVE_AUTHENTICATION_METHOD;
}
break;
case SOCKS5_STATE_RECEIVE_AUTHENTICATION_METHOD:
ret = SOCKS5_STATE_PROCESS_AUTHENTICATION_METHOD;
break;
case SOCKS5_STATE_PROCESS_AUTHENTICATION_METHOD:
if (m_ok) {
if (CanSend()) {
switch (m_lastReply) {
case SOCKS5_AUTH_METHOD_NO_AUTH_REQUIRED:
ret = SOCKS5_STATE_SEND_COMMAND_REQUEST;
break;
case SOCKS5_AUTH_METHOD_GSSAPI:
ret = SOCKS5_STATE_SEND_AUTHENTICATION_GSSAPI;
break;
case SOCKS5_AUTH_METHOD_USERNAME_PASSWORD:
ret = SOCKS5_STATE_SEND_AUTHENTICATION_USERNAME_PASSWORD;
break;
case SOCKS5_AUTH_METHOD_NO_ACCEPTABLE_METHODS:
default:
ret = SOCKS5_STATE_END;
break;
}
} else {
AddDebugLogLineN(logProxy, wxT("Can't send"));
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_SEND_AUTHENTICATION_GSSAPI:
if (m_ok) {
if (CanReceive()) {
ret = SOCKS5_STATE_RECEIVE_AUTHENTICATION_GSSAPI;
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_SEND_AUTHENTICATION_USERNAME_PASSWORD:
if (m_ok) {
if (CanReceive()) {
ret = SOCKS5_STATE_RECEIVE_AUTHENTICATION_USERNAME_PASSWORD;
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_RECEIVE_AUTHENTICATION_GSSAPI:
ret = SOCKS5_STATE_PROCESS_AUTHENTICATION_GSSAPI;
break;
case SOCKS5_STATE_RECEIVE_AUTHENTICATION_USERNAME_PASSWORD:
ret = SOCKS5_STATE_PROCESS_AUTHENTICATION_USERNAME_PASSWORD;
break;
case SOCKS5_STATE_PROCESS_AUTHENTICATION_GSSAPI:
case SOCKS5_STATE_PROCESS_AUTHENTICATION_USERNAME_PASSWORD:
if (m_ok) {
if (CanSend()) {
ret = SOCKS5_STATE_SEND_COMMAND_REQUEST;
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_SEND_COMMAND_REQUEST:
if (m_ok) {
if (CanReceive()) {
ret = SOCKS5_STATE_RECEIVE_COMMAND_REPLY;
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_RECEIVE_COMMAND_REPLY:
ret = SOCKS5_STATE_PROCESS_COMMAND_REPLY;
break;
case SOCKS5_STATE_PROCESS_COMMAND_REPLY:
ret = SOCKS5_STATE_END;
break;
case SOCKS5_STATE_END:
default:
break;
}
return ret;
}
