static void PPPFSM_sendcoderej
(
PPPFSM_CFG_PTR fsm
/* [IN/OUT] - State Machine */
)
{ /* Body */
PPP_CFG_PTR ppp_ptr = fsm->HANDLE;
unsigned char *packet, *src, *dst;
uint16_t length = fsm->PACKET->FRAG[0].LENGTH - 2;
uint16_t size = ppp_ptr->SEND_OPTIONS->MRU - CP_HDR_LEN;
/* Truncate the packet if necessary, so as not to exceed the MTU */
if (length > size) {
length = size;
} /* Endif */
/* Make room for a Code-Reject header */
size = length;
/* Copy the received packet to the data portion of the Code-Reject */
packet = fsm->PACKET->FRAG[0].FRAGMENT + 2;
src = packet + length;
dst = src + CP_HDR_LEN;
while (length--) *--dst = *--src;
/* Build a Code-Reject header */
PPPFSM_buildheader(fsm, fsm->PACKET, CP_CODE_CODE_REJ, FALSE, size);
PPP_send_one(ppp_ptr, fsm->CALL->PROTOCOL, fsm->PACKET);
} /* Endbody */
void LCP_sendprotrej
(
PCB_PTR pcb,
/* [IN] - packet to reject */
PPPFSM_CFG_PTR fsm
/* [IN/OUT] - State Machine */
)
{ /* Body */
#if RTCSCFG_ENABLE_IP4
PPP_CFG_PTR ppp_ptr = fsm->HANDLE;
LCP_CFG_PTR lcp_ptr = fsm->PRIVATE;
unsigned char *packet, *src, *dst;
uint16_t length;
uint16_t size = ppp_ptr->SEND_OPTIONS->MRU - CP_HDR_LEN;
length = pcb->FRAG[0].LENGTH;
packet = pcb->FRAG[0].FRAGMENT;
/* Truncate the packet if necessary */
if (length > size) {
length = size;
} /* Endif */
/* Make room for a Code-Reject header */
size = length + CP_HDR_LEN;
/* Copy the received packet (including protocol field) to the */
/* data portion of the Protocol-Reject */
src = packet + length;
dst = src + 2 + CP_HDR_LEN;
while (length--) *--dst = *--src;
/* Build a Code-Reject packet */
mqx_htons(packet, PPP_PROT_LCP); packet += 2;
*packet++ = LCP_CODE_PROT_REJ;
*packet++ = fsm->CURID;
fsm->CURID = (fsm->CURID + 1) & 0xFF;
mqx_htons(packet, size); packet += 2;
pcb->FRAG[0].LENGTH = size + 2;
lcp_ptr->ST_LCP_TX_REJECT++;
PPP_send_one(ppp_ptr, PPP_PROT_LCP, pcb);
#else
PCB_free(pcb);
#endif /* RTCSCFG_ENABLE_IP4 */
} /* Endbody */
static void PPPFSM_sendconfrep
(
PPPFSM_CFG_PTR fsm,
/* [IN/OUT] - State Machine */
uint32_t code
/* [IN] - packet code for reply */
)
{ /* Body */
fsm->CODE = fsm->PACKET->FRAG[0].FRAGMENT[2] = code;
PPP_send_one(fsm->HANDLE, fsm->CALL->PROTOCOL, fsm->PACKET);
} /* Endbody */
static void PPPFSM_sendtermack
(
PPPFSM_CFG_PTR fsm,
/* [IN/OUT] - State Machine */
bool delay
/* [IN] - whether or not to Zero-Restart-Counter */
)
{ /* Body */
PPPFSM_buildheader(fsm, fsm->PACKET, CP_CODE_TERM_ACK, TRUE, 0);
if (delay) {
PPP_send_rexmit(fsm->HANDLE, fsm->CALL->PROTOCOL, fsm->PACKET,
1, PPPFSM_timeout, fsm);
} else {
PPP_send_one(fsm->HANDLE, fsm->CALL->PROTOCOL, fsm->PACKET);
} /* Endif */
} /* Endbody */
void PAP_input
(
PCB_PTR pcb,
/* [IN] - PAP packet */
_ppp_handle handle
/* [IN] - the PPP state structure */
)
{ /* Body */
PPP_CFG_PTR ppp_ptr = handle;
PAP_DATA_PTR pap_ptr = &ppp_ptr->PAP_STATE;
PPP_SECRET_PTR secret;
uchar_ptr inp = pcb->FRAG[0].FRAGMENT + 2;
uchar_ptr idp, pwp;
uchar code, id;
uchar idlen, pwlen;
uint_16 len;
boolean delay = FALSE;
/*
** Parse header (code, id and length).
** If packet too short, drop it.
*/
if (pcb->FRAG[0].LENGTH < 2 + PAP_HDR_LEN) {
pap_ptr->ST_PAP_SHORT++;
PCB_free(pcb);
return;
} /* Endif */
code = *inp++;
id = *inp++;
len = *inp++ << 8;
len += *inp++;
if ((len < PAP_HDR_LEN) || (len > pcb->FRAG[0].LENGTH - 2)) {
pap_ptr->ST_PAP_SHORT++;
PCB_free(pcb);
return;
} /* Endif */
len -= PAP_HDR_LEN;
switch (code) {
case PAP_CODE_AUTH_REQ:
switch (pap_ptr->SERVER_STATE) {
case PAP_STATE_INITIAL:
/* Parse the peer id and password */
idp = inp;
idlen = *idp++;
pwp = idp + idlen;
pwlen = *pwp++;
if (len < idlen + pwlen + 2) {
pap_ptr->ST_PAP_SHORT++;
PCB_free(pcb);
break;
} /* Endif */
/* Match id/password pair against the secrets table */
/* Start CR 2207 */
secret = PPP_SECRET(ppp_ptr,_PPP_PAP_RSECRETS);
/* End CR 2207 */
for (;;) {
if ((secret->PPP_ID_LENGTH == 0)
&& (secret->PPP_PW_LENGTH == 0)) {
pap_ptr->SERVER_STATE = PAP_STATE_AUTH_NAK;
PAP_fail(handle);
delay = TRUE;
break;
} /* Endif */
if ((secret->PPP_ID_LENGTH == idlen)
&& (secret->PPP_PW_LENGTH == pwlen)
&& (memcmp(secret->PPP_ID_PTR, idp, idlen) == 0)
&& (memcmp(secret->PPP_PW_PTR, pwp, pwlen) == 0)) {
pap_ptr->SERVER_STATE = PAP_STATE_AUTH_ACK;
PAP_up(handle);
break;
} /* Endif */
secret++;
} /* Endfor */
/* fall through */
case PAP_STATE_AUTH_ACK:
case PAP_STATE_AUTH_NAK:
/* Build an Auth-Ack or Auth-Nak reply */
inp = pcb->FRAG[0].FRAGMENT + 2;
*inp++ = pap_ptr->SERVER_STATE;
inp++; /* Keep same ID */
*inp++ = 0;
*inp++ = 5;
*inp++ = 0;
pcb->FRAG[0].LENGTH = 7;
if (delay) {
PPP_send_rexmit(ppp_ptr, PPP_PROT_PAP, pcb, 1, PAP_close, handle);
} else {
PPP_send_one(ppp_ptr, PPP_PROT_PAP, pcb);
} /* Endif */
break;
default:
pap_ptr->ST_PAP_NOAUTH++;
PCB_free(pcb);
break;
} /* Endswitch */
break;
case PAP_CODE_AUTH_ACK:
pap_ptr->CLIENT_STATE = PAP_STATE_AUTH_ACK;
PAP_up(handle);
case PAP_CODE_AUTH_NAK:
if (pap_ptr->CLIENT_STATE != PAP_STATE_AUTH_ACK) {
pap_ptr->CLIENT_STATE = PAP_STATE_AUTH_NAK;
} /* Endif */
if (pap_ptr->CLIENT_STATE != PAP_STATE_INITIAL && pap_ptr->CLIENT_STATE != PAP_STATE_AUTH_ACK) {
pap_ptr->ST_PAP_NOREQ++;
} else if (id != pap_ptr->CURID) {
pap_ptr->ST_PAP_ID++;
} else if (len < 1) {
pap_ptr->ST_PAP_SHORT++;
} else if (--len < *inp++) {
pap_ptr->ST_PAP_SHORT++;
} else {
/* All is well -- stop send Auth-Req's */
PPP_send_stop(ppp_ptr, PPP_PROT_PAP);
} /* Endif */
PCB_free(pcb);
break;
default:
pap_ptr->ST_PAP_CODE++;
PCB_free(pcb);
break;
} /* Endswitch */
} /* Endbody */
uint32_t PPP_send
(
_ppp_handle handle,
/* [IN] - the PPP state structure */
uint16_t protocol,
/* [IN] - protocol for the packet */
PCB_PTR pcb
/* [IN] - the packet to send */
)
{ /* Body */
#if RTCSCFG_ENABLE_IP4
PPP_CFG_PTR ppp_ptr = handle;
PCB_FRAGMENT_PTR frag_ptr;
uint32_t size, mru;
uint32_t error;
/* Do some error checking */
if (ppp_ptr->VALID != PPP_VALID) {
PCB_free(pcb);
return RTCSERR_PPP_INVALID_HANDLE;
} else if (!(protocol&1) || (protocol&0x100)) {
PCB_free(pcb);
return RTCSERR_PPP_INVALID_PROTOCOL;
} /* Endif */
error = PPP_OK;
PPP_mutex_lock(&ppp_ptr->MUTEX);
if (!ppp_ptr->LINK_STATE) {
error = RTCSERR_PPP_LINK_NOT_OPEN;
} else {
/* SPR P122-0371-01 */
/* PCB includes 2-byte protocol field, but negotiated MRU doesn't */
mru = ppp_ptr->SEND_OPTIONS->MRU + 2;
/* End SPR P122-0371-01 */
} /* Endif */
PPP_mutex_unlock(&ppp_ptr->MUTEX);
if (error) {
PCB_free(pcb);
return error;
} /* Endif */
/*
** Make sure the first fragment is long enough for the PPP protocol
** field. This isn't strictly necessary, but it's impractical
** to split a 2 byte field over multiple fragments.
*/
if (pcb->FRAG[0].LENGTH < 2) {
PCB_free(pcb);
return RTCSERR_PPP_PACKET_TOO_SHORT;
} /* Endif */
/*
** Make sure that no fragment exceeds a maximum packet length.
** We check every fragment because we want to prevent something
** like FRAG[0].LENGTH = 2000, FRAG[1].LENGTH = -1000. This
** situation would not be detected if we only check the total
** length.
*/
size = 0;
for (frag_ptr = pcb->FRAG; frag_ptr->LENGTH; frag_ptr++) {
if (frag_ptr->LENGTH > mru) {
PCB_free(pcb);
return RTCSERR_PPP_PACKET_TOO_LONG;
} /* Endif */
size += frag_ptr->LENGTH;
} /* Endfor */
/*
** Make sure that the total sum of the fragments doesn't exceed
** a maximum packet length.
*/
if (size > mru) {
PCB_free(pcb);
return RTCSERR_PPP_PACKET_TOO_LONG;
} /* Endif */
/*
** Everything checks out -- send the packet to the Tx task.
*/
mqx_htons(pcb->FRAG[0].FRAGMENT, protocol);
return PPP_send_one(ppp_ptr, protocol, pcb);
#else
return RTCSERR_IP_IS_DISABLED;
#endif /* RTCSCFG_ENABLE_IP4 */
} /* Endbody */
static bool LCP_recvextcode
(
PPPFSM_CFG_PTR fsm
/* [IN] - State Machine */
)
{ /* Body */
PPP_CFG_PTR ppp_ptr = fsm->HANDLE;
LCP_CFG_PTR lcp_ptr = fsm->PRIVATE;
PPP_CALL_INTERNAL_PTR call_ptr = &ppp_ptr->LCP_CALL[PPP_CALL_ECHO_REPLY];
switch (fsm->CODE) {
case LCP_CODE_PROT_REJ:
lcp_ptr->ST_LCP_RX_REJECT++;
/*
** We should notify the rejected protocol, but there
** currently isn't any way to do this. What we'll do
** instead is to send a STOP message to the Tx task on
** behalf of the protocol.
**
** This will usually be sufficient, since the rejected
** protocol isn't likely to send another packet until
** either it receives a packet (in which case it's OK to
** reply) or the retransmission timer kicks in (which
** we're about to disable).
**
** Thus, this will effectively stop the rejected protocol.
*/
if (fsm->LENGTH >= 2) {
uint16_t protocol = mqx_ntohs(fsm->DATA);
PPP_send_stop(ppp_ptr, protocol);
} /* Endif */
PCB_free(fsm->PACKET);
break;
case LCP_CODE_ECHO_REQ:
lcp_ptr->ST_LCP_RX_ECHO++;
if (fsm->STATE < PPP_STATE_OPENED) {
PCB_free(fsm->PACKET);
} else {
mqx_htonc(fsm->DATA - CP_HDR_LEN, LCP_CODE_ECHO_REP);
mqx_htonl(fsm->DATA, 0); /* Set magic field to 0 */
lcp_ptr->ST_LCP_TX_REPLY++;
PPP_send_one(ppp_ptr, PPP_PROT_LCP, fsm->PACKET);
} /* Endif */
break;
case LCP_CODE_ECHO_REP:
lcp_ptr->ST_LCP_RX_REPLY++;
if (call_ptr->CALLBACK) {
call_ptr->CALLBACK(call_ptr->PARAM, fsm->ID, fsm->PACKET);
} /* Endif */
PCB_free(fsm->PACKET);
break;
case LCP_CODE_DISC_REQ:
lcp_ptr->ST_LCP_RX_DISCARD++;
PCB_free(fsm->PACKET);
break;
default:
return FALSE;
} /* Endswitch */
return TRUE;
} /* Endbody */
static void PPPFSM_recvconfreq
(
PPPFSM_CFG_PTR fsm,
/* [IN/OUT] - State Machine */
_ppp_handle handle
/* [IN] - the PPP state structure */
)
{ /* Body */
PPP_CFG_PTR ppp_ptr = handle;
uint32_t size;
switch (fsm->STATE) {
case PPP_STATE_CLOSED:
PPPFSM_sendtermack(fsm, FALSE);
return;
case PPP_STATE_CLOSING:
case PPP_STATE_STOPPING:
PCB_free(fsm->PACKET);
return;
case PPP_STATE_OPENED:
/* Go down and restart negotiation */
if (fsm->CALL->linkdown) {
fsm->CALL->linkdown(fsm);
} /* Endif */
PPPFSM_sendconfreq(fsm, NULL);
fsm->STATE = PPP_STATE_REQ_SENT;
break;
case PPP_STATE_STOPPED:
/* Negotiation started by our peer */
PPPFSM_sendconfreq(fsm, NULL);
fsm->STATE = PPP_STATE_REQ_SENT;
break;
} /* Endswitch */
/*
** Pass the requested configuration options
** to protocol-specific code for checking.
**
** !! Packet consumed here !!
*/
if (fsm->CALL->recvreq) { /* Check CI */
size = fsm->CALL->recvreq(fsm, fsm->NAKS >= _PPP_MAX_CONF_NAKS);
PPPFSM_buildheader(fsm, fsm->PACKET, 0, TRUE, size);
PPP_send_one(ppp_ptr, fsm->CALL->PROTOCOL, fsm->PACKET);
} else if (fsm->LENGTH) {
PPPFSM_sendconfrep(fsm, CP_CODE_CONF_REJ);
} else {
PPPFSM_sendconfrep(fsm, CP_CODE_CONF_ACK);
} /* Endif */
if (fsm->CODE == CP_CODE_CONF_ACK) {
if (fsm->STATE == PPP_STATE_ACK_RCVD) {
/* Inform upper layers */
if (fsm->CALL->linkup) {
if (!fsm->CALL->linkup(fsm)) {
PPPFSM_sendtermreq(fsm, NULL);
fsm->STATE = PPP_STATE_CLOSING;
return;
} /* Endif */
} /* Endif */
fsm->STATE = PPP_STATE_OPENED;
PPP_send_stop(ppp_ptr, fsm->CALL->PROTOCOL);
} else {
fsm->STATE = PPP_STATE_ACK_SENT;
} /* Endif */
fsm->NAKS = 0;
} else { /* We sent a NAK or a REJ */
if (fsm->STATE != PPP_STATE_ACK_RCVD) {
fsm->STATE = PPP_STATE_REQ_SENT;
} /* Endif */
if (fsm->CODE == CP_CODE_CONF_NAK ) {
++fsm->NAKS;
} /* Endif */
} /* Endif */
} /* Endbody */
void CHAP_input
(
PCB_PTR pcb,
/* [IN] - CHAP packet */
_ppp_handle handle
/* [IN] - the PPP state structure */
)
{ /* Body */
PPP_CFG_PTR ppp_ptr = handle;
CHAP_DATA_PTR chap_ptr = &ppp_ptr->CHAP_STATE;
PPP_SECRET_PTR secret;
uchar_ptr inp = pcb->FRAG[0].FRAGMENT + 2;
uchar_ptr valp, idp;
uchar code, id;
uchar vallen, idlen, namelen;
uint_16 len;
boolean delay = FALSE;
/*
** Parse header (code, id and length).
** If packet too short, drop it.
*/
if (pcb->FRAG[0].LENGTH < 2 + CHAP_HDR_LEN) {
chap_ptr->ST_CHAP_SHORT++;
PCB_free(pcb);
return;
} /* Endif */
code = *inp++;
id = *inp++;
len = *inp++ << 8;
len += *inp++;
if ((len < CHAP_HDR_LEN) || (len > pcb->FRAG[0].LENGTH - 2)) {
chap_ptr->ST_CHAP_SHORT++;
PCB_free(pcb);
return;
} /* Endif */
len -= CHAP_HDR_LEN;
/*
** For Challenge and Response packets, also parse the
** value and name fields.
*/
if ((code == CHAP_CODE_CHALLENGE) || (code == CHAP_CODE_RESPONSE)) {
if (len < 1) {
chap_ptr->ST_CHAP_SHORT++;
PCB_free(pcb);
return;
} /* Endif */
valp = inp;
vallen = *valp++;
len--;
if (len < vallen) {
chap_ptr->ST_CHAP_SHORT++;
PCB_free(pcb);
return;
} /* Endif */
idp = valp + vallen;
idlen = len - vallen;
} /* Endif */
switch (code) {
case CHAP_CODE_CHALLENGE:
if (chap_ptr->CLIENT_STATE != CHAP_STATE_INITIAL) {
chap_ptr->ST_CHAP_NOAUTH++;
PCB_free(pcb);
break;
} /* Endif */
/* OK -- Generate a Response packet */
/* Start CR 2207 */
secret = PPP_SECRET(ppp_ptr,_PPP_CHAP_LSECRETS);
/* End CR 2207 */
inp = pcb->FRAG[0].FRAGMENT + 2;
*inp++ = CHAP_CODE_RESPONSE;
inp++; /* Keep same ID */
/* Start CR 2207 */
namelen = strlen(PPP_SECRET(ppp_ptr,_PPP_CHAP_LNAME));
/* End CR 2207 */
len = CHAP_HDR_LEN + 1 + 16 + namelen;
*inp++ = (len >> 8) & 0xFF;
*inp++ = len & 0xFF;
*inp++ = 16;
for (;;) {
if ((secret->PPP_ID_LENGTH == 0)
&& (secret->PPP_PW_LENGTH == 0)) {
/* Couldn't find a secret for this peer */
chap_ptr->ST_CHAP_NOPW++;
PPP_MD5(inp, (uint_32)1, &id, /* id */
(uint_32)vallen, valp, /* challenge */
(uint_32)0);
break;
} /* Endif */
if ((secret->PPP_ID_LENGTH == idlen)
&& (memcmp(secret->PPP_ID_PTR, idp, idlen) == 0)) {
/* Found a secret; send response */
PPP_MD5(inp, (uint_32)1, &id, /* id */
(uint_32)secret->PPP_PW_LENGTH, /* secret */
secret->PPP_PW_PTR,
(uint_32)vallen, valp, /* challenge */
(uint_32)0);
break;
} /* Endif */
secret++;
} /* Endfor */
inp += 16;
/* Start CR 2207 */
PPP_memcopy(PPP_SECRET(ppp_ptr,_PPP_CHAP_LNAME), inp, namelen);
/* End CR 2207 */
pcb->FRAG[0].LENGTH = len + 2;
PPP_send_one(ppp_ptr, PPP_PROT_CHAP, pcb);
break;
case CHAP_CODE_RESPONSE:
switch (chap_ptr->SERVER_STATE) {
case CHAP_STATE_INITIAL:
/* Check the ID against our last challenge */
if (id != chap_ptr->CURID) {
chap_ptr->ST_CHAP_ID++;
PCB_free(pcb);
break;
} /* Endif */
/* Stop the challenge, whether or not the response is correct */
PPP_send_stop(ppp_ptr, PPP_PROT_CHAP);
chap_ptr->SERVER_STATE = CHAP_STATE_FAILURE;
if (vallen != 16) {
delay = TRUE;
CHAP_fail(handle);
} else {
/* Search for name in the secrets table */
/* Start CR 2207 */
secret = PPP_SECRET(ppp_ptr,_PPP_CHAP_RSECRETS);
/* End CR 2207 */
for (;;) {
if ((secret->PPP_ID_LENGTH == 0)
&& (secret->PPP_PW_LENGTH == 0)) {
/* Couldn't find a secret for this peer */
delay = TRUE;
CHAP_fail(handle);
break;
} /* Endif */
if ((secret->PPP_ID_LENGTH == idlen)
&& (memcmp(secret->PPP_ID_PTR, idp, idlen) == 0)) {
/* Found a secret; compute hash */
uchar digest[16];
PPP_MD5(digest, (uint_32)1, &id, /* id */
(uint_32)secret->PPP_PW_LENGTH, /* secret */
secret->PPP_PW_PTR,
(uint_32)CHAP_CHALLENGE_LEN, /* challenge */
chap_ptr->MD5,
(uint_32)0);
if (memcmp(digest, valp, vallen) == 0) {
chap_ptr->SERVER_STATE = CHAP_STATE_SUCCESS;
CHAP_up(handle);
} else {
delay = TRUE;
CHAP_fail(handle);
} /* Endif */
break;
} /* Endif */
secret++;
} /* Endfor */
} /* Endif */
/* fall through */
case CHAP_STATE_SUCCESS:
case CHAP_STATE_FAILURE:
/* Build a Success or Failure reply */
inp = pcb->FRAG[0].FRAGMENT + 2;
*inp++ = chap_ptr->SERVER_STATE;
inp++; /* Keep same ID */
*inp++ = 0;
*inp++ = 4;
pcb->FRAG[0].LENGTH = 6;
if (delay) {
PPP_send_rexmit(ppp_ptr, PPP_PROT_CHAP, pcb, 1, CHAP_close, handle);
} else {
PPP_send_one(ppp_ptr, PPP_PROT_CHAP, pcb);
} /* Endif */
break;
default:
chap_ptr->ST_CHAP_NOCHAL++;
PCB_free(pcb);
break;
} /* Endswitch */
break;
case CHAP_CODE_SUCCESS:
/* Authentication success */
chap_ptr->CLIENT_STATE = CHAP_STATE_SUCCESS;
CHAP_up(handle);
case CHAP_CODE_FAILURE:
/* Authentication failure */
if (chap_ptr->CLIENT_STATE != CHAP_STATE_SUCCESS)
{
/* Change client state when authenticate failure */
chap_ptr->CLIENT_STATE = CHAP_STATE_FAILURE;
if (chap_ptr->CLIENT_STATE != CHAP_STATE_INITIAL)
{
chap_ptr->ST_CHAP_NOAUTH++;
}
CHAP_fail(handle);
} /* Endif */
PCB_free(pcb);
break;
default:
chap_ptr->ST_CHAP_CODE++;
PCB_free(pcb);
break;
} /* Endswitch */
} /* Endbody */
