440 lines
12 KiB
C
440 lines
12 KiB
C
/*
|
|
*---------------------------------------------------------------------------
|
|
* ppp.c - PPP Processor/Handler -
|
|
* -
|
|
*---------------------------------------------------------------------------
|
|
*
|
|
* Version -
|
|
* 0.1 Original Version Jun 3, 2000 -
|
|
* -
|
|
*---------------------------------------------------------------------------
|
|
*/
|
|
/*
|
|
* Copyright (c) 2003, Mike Johnson, Mycal Labs, www.mycal.net
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Mike Johnson/Mycal Labs
|
|
* www.mycal.net.
|
|
* 4. The name of the author may not be used to endorse or promote
|
|
* products derived from this software without specific prior
|
|
* written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
|
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* This file is part of the Mycal Modified uIP TCP/IP stack.
|
|
*
|
|
* $Id: ppp.c,v 1.1 2007/05/26 07:14:40 oliverschmidt Exp $
|
|
*
|
|
*/
|
|
|
|
/* */
|
|
/* include files */
|
|
/* */
|
|
|
|
|
|
#include "lcp.h"
|
|
#include "pap.h"
|
|
#include "ipcp.h"
|
|
/*#include "time.h"*/
|
|
/*#include "mip.h"*/
|
|
|
|
#if 0
|
|
#define DEBUG1(x)
|
|
#else
|
|
#include <stdio.h>
|
|
#define DEBUG1(x) debug_printf x
|
|
#endif
|
|
|
|
/*
|
|
Set the debug message level
|
|
*/
|
|
#define PACKET_RX_DEBUG 1
|
|
|
|
/*
|
|
Include stuff
|
|
*/
|
|
/*#include "mTypes.h"*/
|
|
#include "ppp.h"
|
|
#include "ahdlc.h"
|
|
#include "ipcp.h"
|
|
#include "lcp.h"
|
|
|
|
extern int ppp_arch_getchar(u8_t *p);
|
|
|
|
|
|
/*
|
|
Buffers that this layer needs (this can be optimized out)
|
|
*/
|
|
u8_t ppp_rx_buffer[PPP_RX_BUFFER_SIZE];
|
|
/*u8_t ppp_tx_buffer[PPP_TX_BUFFER_SIZE];*/
|
|
|
|
/*
|
|
* Other state storage (this can be placed in a struct and this could could
|
|
* support multiple PPP connections, would have to embedded the other ppp
|
|
* module state also)
|
|
*/
|
|
u8_t ppp_flags;
|
|
u8_t ppp_id;
|
|
u8_t ppp_retry;
|
|
|
|
#if PACKET_RX_DEBUG
|
|
u16_t ppp_rx_frame_count=0;
|
|
u16_t ppp_rx_tobig_error;
|
|
u8_t done; /* temporary variable */
|
|
#endif
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
static u8_t
|
|
check_ppp_errors(void)
|
|
{
|
|
u8_t ret = 0;
|
|
|
|
/* Check Errors */
|
|
if(lcp_state & LCP_TX_TIMEOUT) {
|
|
ret = 1;
|
|
}
|
|
if(lcp_state & LCP_RX_TIMEOUT) {
|
|
ret = 2;
|
|
}
|
|
|
|
if(pap_state & PAP_TX_AUTH_FAIL) {
|
|
ret = 3;
|
|
}
|
|
if(pap_state & PAP_RX_AUTH_FAIL) {
|
|
ret = 4;
|
|
}
|
|
|
|
if(pap_state & PAP_TX_TIMEOUT) {
|
|
ret = 5;
|
|
}
|
|
if(pap_state & PAP_RX_TIMEOUT) {
|
|
ret = 6;
|
|
}
|
|
|
|
if(ipcp_state & IPCP_TX_TIMEOUT) {
|
|
ret = 7;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/*
|
|
* Unknown Protocol Handler, sends reject
|
|
*/
|
|
static void
|
|
ppp_reject_protocol(u16_t protocol, u8_t *buffer, u16_t count)
|
|
{
|
|
u16_t i;
|
|
u8_t *dptr, *sptr;
|
|
LCPPKT *pkt;
|
|
|
|
/* first copy rejected packet back, start from end and work forward,
|
|
+++ Pay attention to buffer managment when updated. Assumes fixed
|
|
PPP blocks. */
|
|
DEBUG1(("Rejecting Protocol\n"));
|
|
if((count + 6) > PPP_RX_BUFFER_SIZE) {
|
|
/* This is a fatal error +++ do somthing about it. */
|
|
DEBUG1(("Cannot Reject Protocol, PKT to big\n"));
|
|
return;
|
|
}
|
|
dptr = buffer + count + 6;
|
|
sptr = buffer + count;
|
|
for(i = 0; i < count; ++i) {
|
|
*dptr-- = *sptr--;
|
|
}
|
|
|
|
pkt = (LCPPKT *)buffer;
|
|
pkt->code = PROT_REJ; /* Write Conf_rej */
|
|
/*pkt->id = tid++;*/ /* write tid */
|
|
pkt->len = htons(count + 6);
|
|
*((u16_t *)(&pkt->data[0])) = htons(protocol);
|
|
|
|
ahdlc_tx(LCP, buffer, 0, (u16_t)(count + 6), 0);
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
#if PACKET_RX_DEBUG
|
|
void
|
|
dump_ppp_packet(u8_t *buffer, u16_t len)
|
|
{
|
|
int i;
|
|
|
|
DEBUG1(("\n"));
|
|
for(i = 0;i < len; ++i) {
|
|
if((i & 0x1f) == 0x10) {
|
|
DEBUG1(("\n"));
|
|
}
|
|
DEBUG1(("0x%02x ",buffer[i]));
|
|
}
|
|
DEBUG1(("\n\n"));
|
|
}
|
|
#endif
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Initialize and start PPP engine. This just sets things up to
|
|
* starting values. This can stay a private method.
|
|
*/
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
ppp_init()
|
|
{
|
|
#if PACKET_RX_DEBUG
|
|
ppp_rx_frame_count = 0;
|
|
done = 0;
|
|
#endif
|
|
ppp_flags = 0;
|
|
pap_init();
|
|
ipcp_init();
|
|
lcp_init();
|
|
ppp_flags = 0;
|
|
|
|
ahdlc_init(ppp_rx_buffer, PPP_RX_BUFFER_SIZE);
|
|
ahdlc_rx_ready();
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/* raise_ppp() - This routine will try to bring up a PPP connection,
|
|
* It is blocking. In the future we probably want to pass a
|
|
* structure with all the options on bringing up a PPP link, like
|
|
* server/client, DSN server, username password for PAP... +++ for
|
|
* now just use config and bit defines
|
|
*/
|
|
/*---------------------------------------------------------------------------*/
|
|
#if 0
|
|
u16_t
|
|
ppp_raise(u8_t config, u8_t *username, u8_t *password)
|
|
{
|
|
u16_t status = 0;
|
|
|
|
/* Initialize PPP engine */
|
|
/* init_ppp(); */
|
|
pap_init();
|
|
ipcp_init();
|
|
lcp_init();
|
|
|
|
/* Enable PPP */
|
|
ppp_flags = PPP_RX_READY;
|
|
|
|
/* Try to bring up the layers */
|
|
while(status == 0) {
|
|
#ifdef SYSTEM_POLLER
|
|
/* If the the serial interrupt is not hooked to ahdlc_rx, or the
|
|
system needs to handle other stuff while were blocking, call
|
|
the system poller.*/
|
|
system_poller();
|
|
#endif
|
|
|
|
/* call the lcp task to bring up the LCP layer */
|
|
lcp_task(ppp_tx_buffer);
|
|
|
|
/* If LCP is up, neg next layer */
|
|
if(lcp_state & LCP_TX_UP) {
|
|
/* If LCP wants PAP, try to authenticate, else bring up IPCP */
|
|
if((lcp_state & LCP_RX_AUTH) && (!(pap_state & PAP_TX_UP))) {
|
|
pap_task(ppp_tx_buffer,username,password);
|
|
} else {
|
|
ipcp_task(ppp_tx_buffer);
|
|
}
|
|
}
|
|
|
|
|
|
/* If IPCP came up then our link should be up. */
|
|
if((ipcp_state & IPCP_TX_UP) && (ipcp_state & IPCP_RX_UP)) {
|
|
break;
|
|
}
|
|
|
|
status = check_ppp_errors();
|
|
}
|
|
|
|
return status;
|
|
}
|
|
#endif
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
ppp_connect(void)
|
|
{
|
|
/* Initialize PPP engine */
|
|
/* init_ppp(); */
|
|
pap_init();
|
|
ipcp_init();
|
|
lcp_init();
|
|
|
|
/* Enable PPP */
|
|
ppp_flags = PPP_RX_READY;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
ppp_send(void)
|
|
{
|
|
/* If IPCP came up then our link should be up. */
|
|
if((ipcp_state & IPCP_TX_UP) && (ipcp_state & IPCP_RX_UP)) {
|
|
ahdlc_tx(IPV4, &uip_buf[ UIP_LLH_LEN ], uip_appdata,
|
|
UIP_TCPIP_HLEN, uip_len - UIP_TCPIP_HLEN);
|
|
}
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
ppp_poll(void)
|
|
{
|
|
u8_t c;
|
|
|
|
uip_len = 0;
|
|
|
|
if(!(ppp_flags & PPP_RX_READY)) {
|
|
return;
|
|
}
|
|
|
|
while(uip_len == 0 && ppp_arch_getchar(&c)) {
|
|
ahdlc_rx(c);
|
|
}
|
|
|
|
/* If IPCP came up then our link should be up. */
|
|
if((ipcp_state & IPCP_TX_UP) && (ipcp_state & IPCP_RX_UP)) {
|
|
return;
|
|
}
|
|
|
|
/* call the lcp task to bring up the LCP layer */
|
|
lcp_task( &uip_buf[ UIP_LLH_LEN ]);
|
|
|
|
/* If LCP is up, neg next layer */
|
|
if((lcp_state & LCP_TX_UP) && (lcp_state & LCP_RX_UP)) {
|
|
/* If LCP wants PAP, try to authenticate, else bring up IPCP */
|
|
if((lcp_state & LCP_RX_AUTH) && (!(pap_state & PAP_TX_UP))) {
|
|
pap_task( &uip_buf[ UIP_LLH_LEN ]);
|
|
} else {
|
|
ipcp_task( &uip_buf[ UIP_LLH_LEN ]);
|
|
}
|
|
}
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/* ppp_upcall() - this is where valid PPP frames from the ahdlc layer are
|
|
* sent to be processed and demuxed.
|
|
*/
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
ppp_upcall(u16_t protocol, u8_t *buffer, u16_t len)
|
|
{
|
|
#if PACKET_RX_DEBUG
|
|
++ppp_rx_frame_count;
|
|
dump_ppp_packet(buffer, len);
|
|
if(ppp_rx_frame_count > 18) {
|
|
done = 1;
|
|
}
|
|
#endif
|
|
|
|
/* check to see if we have a packet waiting to be processed */
|
|
if(ppp_flags & PPP_RX_READY) {
|
|
/* demux on protocol field */
|
|
switch(protocol) {
|
|
case LCP: /* We must support some level of LCP */
|
|
DEBUG1(("LCP Packet - "));
|
|
lcp_rx(buffer, len);
|
|
DEBUG1(("\n"));
|
|
break;
|
|
case PAP: /* PAP should be compile in optional */
|
|
DEBUG1(("PAP Packet - "));
|
|
pap_rx(buffer, len);
|
|
DEBUG1(("\n"));
|
|
break;
|
|
case IPCP: /* IPCP should be compile in optional. */
|
|
DEBUG1(("IPCP Packet - "));
|
|
ipcp_rx(buffer, len);
|
|
DEBUG1(("\n"));
|
|
break;
|
|
case IPV4: /* We must support IPV4 */
|
|
DEBUG1(("IPV4 Packet---\n"));
|
|
memcpy( &uip_buf[ UIP_LLH_LEN ], buffer, len);
|
|
uip_len = len;
|
|
DEBUG1(("\n"));
|
|
break;
|
|
default:
|
|
DEBUG1(("Unknown PPP Packet Type 0x%04x - ",protocol));
|
|
ppp_reject_protocol(protocol, buffer, len);
|
|
DEBUG1(("\n"));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/* scan_packet(list,buffer,len)
|
|
*
|
|
* list = list of supported ID's
|
|
* *buffer pointer to the first code in the packet
|
|
* length of the codespace
|
|
*/
|
|
u16_t
|
|
scan_packet(u16_t protocol, u8_t *list, u8_t *buffer, u8_t *options, u16_t len)
|
|
{
|
|
u8_t *tlist, *bptr;
|
|
u8_t *tptr;
|
|
u8_t bad = 0;
|
|
u8_t i, j, good;
|
|
|
|
bptr = tptr = options;
|
|
/* scan through the packet and see if it has any unsupported codes */
|
|
while(bptr < options + len) {
|
|
/* get code and see if it matches somwhere in the list, if not
|
|
we don't support it */
|
|
i = *bptr++;
|
|
|
|
/* DEBUG2("%x - ",i);*/
|
|
tlist = list;
|
|
good = 0;
|
|
while(*tlist) {
|
|
/* DEBUG2("%x ",*tlist);*/
|
|
if(i == *tlist++) {
|
|
good = 1;
|
|
break;
|
|
}
|
|
}
|
|
if(!good) {
|
|
/* we don't understand it, write it back */
|
|
DEBUG1(("We don't understand option 0x%02x\n",i));
|
|
bad = 1;
|
|
*tptr++ = i;
|
|
j = *tptr++ = *bptr++;
|
|
for(i = 0; i < j - 2; ++i) {
|
|
*tptr++ = *bptr++;
|
|
}
|
|
} else {
|
|
/* advance over to next option */
|
|
bptr += *bptr - 1;
|
|
}
|
|
}
|
|
|
|
/* Bad? if we we need to send a config Reject */
|
|
if(bad) {
|
|
/* write the config Rej packet we've built above, take on the header */
|
|
bptr = buffer;
|
|
*bptr++ = CONF_REJ; /* Write Conf_rej */
|
|
bptr++; /* skip over ID */
|
|
*bptr++ = 0;
|
|
*bptr = tptr - buffer;
|
|
/* length right here? */
|
|
|
|
/* write the reject frame */
|
|
DEBUG1(("Writing Reject frame --\n"));
|
|
ahdlc_tx(protocol, buffer, 0, (u16_t)(tptr - buffer), 0);
|
|
DEBUG1(("\nEnd writing reject \n"));
|
|
|
|
}
|
|
return bad;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|