sergiotarxz/nuttx-apps
sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

apps/netutils/pppd: Refine and fix pppd code.

Browse Source 
Reviewers note:  Reviewing the changes I also see that these file did not follow the NuttX codings standard.  I ran all files through nuttx/tools/indent.sh, manually reviewed all files for coding style issues.  I also changed occurrences of non-standard types u8_t, u16_t, and u32_t to the standard uint8_t, uint16_t, and uint32_t.
This commit is contained in:
Xiang Xiao 2018-11-07 12:43:42 -06:00 committed by Gregory Nutt
parent c1f0653c85
commit cddfda99f0
18 changed files with 841 additions and 908 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
examples/pppd/Kconfig
View File

@ -5,10 +5,15 @@
config EXAMPLES_PPPD
tristate "pppd client example"
select NETUTILS_PPPD
default n
---help---
Enable the pppd client example
if EXAMPLES_PPPD
config EXAMPLES_PPPD_STACKSIZE
int "pppd example stack stack size"
default 2048
endif

2
examples/pppd/Makefile
View File

@ -48,7 +48,7 @@ PROGNAME = $(CONFIG_EXAMPLES_PPPD_PROGNAME)
APPNAME = pppd
PRIORITY = SCHED_PRIORITY_DEFAULT
STACKSIZE = 2048
STACKSIZE = CONFIG_EXAMPLES_PPPD_STACKSIZE
MODULE = CONFIG_EXAMPLES_PPPD

6
examples/pppd/pppd_main.c
View File

@ -50,7 +50,7 @@
* Private Data
****************************************************************************/
static FAR char connect_script[] =
static FAR const char connect_script[] =
"ECHO ON "
"TIMEOUT 30 "
"\"\" ATE1 "
@ -58,7 +58,7 @@ static FAR char connect_script[] =
"OK ATD*99***1# "
"CONNECT \\c";
static FAR char disconnect_script[] =
static FAR const char disconnect_script[] =
"\"\" ATZ "
"OK \\c";
@ -72,7 +72,7 @@ static FAR char disconnect_script[] =
int pppd_main(int argc, char *argv[])
{
struct pppd_settings_s pppd_settings =
const struct pppd_settings_s pppd_settings =
{
.disconnect_script = disconnect_script,
.connect_script = connect_script,

6
include/netutils/pppd.h
View File

@ -76,8 +76,8 @@ struct pppd_settings_s
/* Chat Scripts */
FAR char* connect_script;
FAR char* disconnect_script;
FAR const char* connect_script;
FAR const char* disconnect_script;
};
/****************************************************************************
@ -110,7 +110,7 @@ extern "C"
*
****************************************************************************/
int pppd(struct pppd_settings_s *ppp_settings);
int pppd(const struct pppd_settings_s *ppp_settings);
#undef EXTERN
#ifdef __cplusplus

6
netutils/pppd/Kconfig
View File

@ -4,7 +4,7 @@
#
config NETUTILS_PPPD
bool "PPP daemon"
bool "PPP server"
default n
select NETUTILS_CHAT
select NET_TUN
@ -14,10 +14,6 @@ config NETUTILS_PPPD
if NETUTILS_PPPD
config NETUTILS_PPPD_STACKSIZE
int "PPP daemon stack stack size"
default 2048
config NETUTILS_PPPD_PAP
bool "PPP PAP Authentication Support"
default n

140
netutils/pppd/ahdlc.c
View File

@ -54,23 +54,9 @@
# define PACKET_TX_DEBUG 1
#else
# define DEBUG1(x)
# undef PACKET_TX_DEBUG
# define PACKET_TX_DEBUG 0
#endif
/* ahdlc flags bit defins, for ahdlc_flags variable */
/* Escaped mode bit */
#define AHDLC_ESCAPED 0x1
/* Frame is ready bit */
#define AHDLC_RX_READY 0x2
#define AHDLC_RX_ASYNC_MAP 0x4
#define AHDLC_TX_ASYNC_MAP 0x8
#define AHDLC_PFC 0x10
#define AHDLC_ACFC 0x20
/****************************************************************************
* Private Functions
****************************************************************************/
@ -89,9 +75,9 @@
*
****************************************************************************/
static u16_t crcadd(u16_t crcvalue, u8_t c)
static uint16_t crcadd(uint16_t crcvalue, uint8_t c)
{
u16_t b;
uint16_t b;
b = (crcvalue ^ c) & 0xFF;
b = (b ^ (b << 4)) & 0xFF;
@ -112,11 +98,12 @@ static u16_t crcadd(u16_t crcvalue, u8_t c)
void ahdlc_init(struct ppp_context_s *ctx)
{
ctx->ahdlc_flags = 0 | AHDLC_RX_ASYNC_MAP;
ctx->ahdlc_rx_count = 0;
ctx->ahdlc_flags = PPP_RX_ASYNC_MAP;
ctx->ahdlc_rx_count = 0;
ctx->ahdlc_tx_offline = 0;
#ifdef PPP_STATISTICS
ctx->ahdlc_crc_error = 0;
ctx->ahdlc_rx_tobig_error = 0;
#endif
}
@ -131,7 +118,7 @@ void ahdlc_rx_ready(struct ppp_context_s *ctx)
{
ctx->ahdlc_rx_count = 0;
ctx->ahdlc_rx_crc = 0xffff;
ctx->ahdlc_flags |= AHDLC_RX_READY;
ctx->ahdlc_flags |= PPP_RX_READY;
}
/****************************************************************************
@ -144,21 +131,21 @@ void ahdlc_rx_ready(struct ppp_context_s *ctx)
*
****************************************************************************/
u8_t ahdlc_rx(struct ppp_context_s *ctx, u8_t c)
uint8_t ahdlc_rx(FAR struct ppp_context_s *ctx, uint8_t c)
{
//static u16_t protocol;
/* Check to see if PPP packet is useable, we should have hardware flow
* control set, but if host ignores it and sends us a char when the PPP
* Receive packet is in use, discard the character.
*/
/* Check to see if PPP packet is useable, we should have hardware
flow control set, but if host ignores it and sends us a char when
the PPP Receive packet is in use, discard the character. */
if (ctx->ahdlc_flags & AHDLC_RX_READY)
if ((ctx->ahdlc_flags & PPP_RX_READY) != 0)
{
/* Check to see if character is less than 0x20 hex we really
should set AHDLC_RX_ASYNC_MAP on by default and only turn it
off when it is negotiated off to handle some buggy stacks. */
/* Check to see if character is less than 0x20 hex we really should set
* AHDLC_RX_ASYNC_MAP on by default and only turn it off when it is
* negotiated off to handle some buggy stacks.
*/
if ((c < 0x20) && ((ctx->ahdlc_flags & AHDLC_RX_ASYNC_MAP) == 0))
if ((c < 0x20) && ((ctx->ahdlc_flags & PPP_RX_ASYNC_MAP) == 0))
{
/* Discard character */
@ -168,11 +155,11 @@ u8_t ahdlc_rx(struct ppp_context_s *ctx, u8_t c)
/* Are we in escaped mode? */
if (ctx->ahdlc_flags & AHDLC_ESCAPED)
if ((ctx->ahdlc_flags & PPP_ESCAPED) != 0)
{
/* Set escaped to FALSE */
ctx->ahdlc_flags &= ~AHDLC_ESCAPED;
ctx->ahdlc_flags &= ~PPP_ESCAPED;
/* If value is 0x7e then silently discard and reset receive packet */
@ -193,11 +180,13 @@ u8_t ahdlc_rx(struct ppp_context_s *ctx, u8_t c)
if (ctx->ahdlc_rx_crc == CRC_GOOD_VALUE)
{
DEBUG1(("\nReceiving packet with good crc value, len %d\n",
ctx->ahdlc_rx_count));
ctx->ahdlc_rx_count));
/* we hae a good packet, turn off CTS until we are done with
this packet */
/*CTS_OFF();*/
/* we have a good packet, turn off CTS until we are done with this
* packet
*/
/* CTS_OFF(); */
#if PPP_STATISTICS
/* Update statistics */
@ -205,35 +194,39 @@ u8_t ahdlc_rx(struct ppp_context_s *ctx, u8_t c)
++ctx->ppp_rx_frame_count;
#endif
/* Femove CRC bytes from packet */
/* Remove CRC bytes from packet */
ctx->ahdlc_rx_count -= 2;
/* Lock PPP buffer */
ctx->ahdlc_flags &= ~AHDLC_RX_READY;
ctx->ahdlc_flags &= ~PPP_RX_READY;
/*upcall routine must fully process frame before return
* as returning signifies that buffer belongs to AHDLC again.
*/
/* upcall routine must fully process frame before return as
* returning signifies that buffer belongs to AHDLC again.
*/
if ((c & 0x1) && (ctx->ahdlc_flags & PPP_PFC))
if ((ctx->ahdlc_rx_buffer[0] & 0x1) != 0 &&
(ctx->ahdlc_flags & PPP_PFC) != 0)
{
/* Send up packet */
ppp_upcall(ctx, (u16_t)ctx->ahdlc_rx_buffer[0],
(u8_t *)&ctx->ahdlc_rx_buffer[1],
(u16_t)(ctx->ahdlc_rx_count - 1));
ppp_upcall(ctx, (uint16_t) ctx->ahdlc_rx_buffer[0],
(FAR uint8_t *) & ctx->ahdlc_rx_buffer[1],
(uint16_t) (ctx->ahdlc_rx_count - 1));
}
else
{
/* Send up packet */
ppp_upcall(ctx, (u16_t)(ctx->ahdlc_rx_buffer[0] << 8 | ctx->ahdlc_rx_buffer[1]),
(u8_t *)&ctx->ahdlc_rx_buffer[2], (u16_t)(ctx->ahdlc_rx_count - 2));
ppp_upcall(ctx,
(uint16_t) (ctx->ahdlc_rx_buffer[0] << 8 | ctx->
ahdlc_rx_buffer[1]),
(FAR uint8_t *) & ctx->ahdlc_rx_buffer[2],
(uint16_t) (ctx->ahdlc_rx_count - 2));
}
ctx->ahdlc_tx_offline = 0; /* The remote side is alive */
ctx->ahdlc_tx_offline = 0; /* The remote side is alive */
ahdlc_rx_ready(ctx);
return 0;
}
@ -246,9 +239,10 @@ u8_t ahdlc_rx(struct ppp_context_s *ctx, u8_t c)
#endif
/* Shouldn't we dump the packet and not pass it up? */
/*ppp_upcall((u16_t)ahdlc_rx_buffer[0],
(u8_t *)&ahdlc_rx_buffer[0], (u16_t)(ahdlc_rx_count+2));
dump_ppp_packet(&ahdlc_rx_buffer[0],ahdlc_rx_count);*/
/* ppp_upcall((uint16_t)ahdlc_rx_buffer[0], (FAR uint8_t
* *)&ahdlc_rx_buffer[0], (uint16_t)(ahdlc_rx_count+2));
* dump_ppp_packet(&ahdlc_rx_buffer[0],ahdlc_rx_count);
*/
}
ahdlc_rx_ready(ctx);
@ -256,13 +250,13 @@ u8_t ahdlc_rx(struct ppp_context_s *ctx, u8_t c)
}
else if (c == 0x7d)
{
/* Handle escaped chars*/
/* Handle escaped chars */
ctx->ahdlc_flags |= PPP_ESCAPED;
return 0;
}
/* Rry to store char if not too big */
/* Try to store char if not too big */
if (ctx->ahdlc_rx_count >= PPP_RX_BUFFER_SIZE)
{
@ -295,6 +289,7 @@ u8_t ahdlc_rx(struct ppp_context_s *ctx, u8_t c)
else
{
/* we are busy and didn't process the character. */
DEBUG1(("Busy/not active\n"));
return 1;
}
@ -311,7 +306,7 @@ u8_t ahdlc_rx(struct ppp_context_s *ctx, u8_t c)
*
****************************************************************************/
void ahdlc_tx_char(struct ppp_context_s *ctx, u16_t protocol, u8_t c)
void ahdlc_tx_char(struct ppp_context_s *ctx, uint16_t protocol, uint8_t c)
{
/* Add in crc */
@ -324,7 +319,9 @@ void ahdlc_tx_char(struct ppp_context_s *ctx, u16_t protocol, u8_t c)
*/
if ((c == 0x7d) || (c == 0x7e) || ((c < 0x20) && ((protocol == LCP) ||
(ctx->ahdlc_flags & PPP_TX_ASYNC_MAP) == 0)))
(ctx->
ahdlc_flags &
PPP_TX_ASYNC_MAP) == 0)))
{
/* Send escape char and xor byte by 0x20 */
@ -346,14 +343,15 @@ void ahdlc_tx_char(struct ppp_context_s *ctx, u16_t protocol, u8_t c)
*
****************************************************************************/
u8_t ahdlc_tx(struct ppp_context_s *ctx, u16_t protocol, u8_t *header,
u8_t *buffer, u16_t headerlen, u16_t datalen)
uint8_t ahdlc_tx(struct ppp_context_s *ctx, uint16_t protocol,
FAR uint8_t * header, FAR uint8_t * buffer, uint16_t headerlen,
uint16_t datalen)
{
u16_t i;
u8_t c;
uint16_t i;
uint8_t c;
DEBUG1(("\nAHDLC_TX - transmit frame, protocol 0x%04x, length %d offline %d\n",
protocol, datalen + headerlen, ctx->ahdlc_tx_offline));
protocol, datalen + headerlen, ctx->ahdlc_tx_offline));
if (AHDLC_TX_OFFLINE && (ctx->ahdlc_tx_offline++ > AHDLC_TX_OFFLINE))
{
@ -378,8 +376,7 @@ u8_t ahdlc_tx(struct ppp_context_s *ctx, u16_t protocol, u8_t *header,
DEBUG1(("\n\n"));
#endif
/* Check to see that physical layer is up, we can assume is some
cases */
/* Check to see that physical layer is up, we can assume is some cases */
/* Write leading 0x7e */
@ -391,7 +388,10 @@ u8_t ahdlc_tx(struct ppp_context_s *ctx, u16_t protocol, u8_t *header,
/* send HDLC control and address if not disabled or of LCP frame type */
/*if ((0==(ahdlc_flags & PPP_ACFC)) || ((0xc0==buffer[0]) && (0x21==buffer[1]))) */
/* if ((0==(ahdlc_flags & PPP_ACFC)) || ((0xc0==buffer[0]) &&
* (0x21==buffer[1])))
*/
if ((0 == (ctx->ahdlc_flags & PPP_ACFC)) || (protocol == LCP))
{
ahdlc_tx_char(ctx, protocol, 0xff);
@ -400,8 +400,8 @@ u8_t ahdlc_tx(struct ppp_context_s *ctx, u16_t protocol, u8_t *header,
/* Write Protocol */
ahdlc_tx_char(ctx, protocol,(u8_t)(protocol >> 8));
ahdlc_tx_char(ctx, protocol,(u8_t)(protocol & 0xff));
ahdlc_tx_char(ctx, protocol, (uint8_t) (protocol >> 8));
ahdlc_tx_char(ctx, protocol, (uint8_t) (protocol & 0xff));
/* Write header if it exists */
@ -411,7 +411,7 @@ u8_t ahdlc_tx(struct ppp_context_s *ctx, u16_t protocol, u8_t *header,
c = header[i];
/* Write it...*/
/* Write it... */
ahdlc_tx_char(ctx, protocol, c);
}
@ -424,7 +424,7 @@ u8_t ahdlc_tx(struct ppp_context_s *ctx, u16_t protocol, u8_t *header,
c = buffer[i];
/* Write it...*/
/* Write it... */
ahdlc_tx_char(ctx, protocol, c);
}
@ -432,8 +432,8 @@ u8_t ahdlc_tx(struct ppp_context_s *ctx, u16_t protocol, u8_t *header,
/* Send crc, lsb then msb */
i = ctx->ahdlc_tx_crc ^ 0xffff;
ahdlc_tx_char(ctx, protocol, (u8_t)(i & 0xff));
ahdlc_tx_char(ctx, protocol, (u8_t)((i >> 8) & 0xff));
ahdlc_tx_char(ctx, protocol, (uint8_t) (i & 0xff));
ahdlc_tx_char(ctx, protocol, (uint8_t) ((i >> 8) & 0xff));
/* Write trailing 0x7e, probably not needed but it doesn't hurt */

11
netutils/pppd/ahdlc.h
View File

@ -62,13 +62,14 @@ extern "C"
#define EXTERN extern
#endif
void ahdlc_init(struct ppp_context_s *ctx);
void ahdlc_init(FAR struct ppp_context_s *ctx);
void ahdlc_rx_ready(struct ppp_context_s *ctx);
void ahdlc_rx_ready(FAR struct ppp_context_s *ctx);
u8_t ahdlc_rx(struct ppp_context_s *ctx, u8_t);
u8_t ahdlc_tx(struct ppp_context_s *ctx, u16_t protocol, u8_t *header,
u8_t *buffer, u16_t headerlen, u16_t datalen);
uint8_t ahdlc_rx(FAR struct ppp_context_s *ctx, uint8_t);
uint8_t ahdlc_tx(FAR struct ppp_context_s *ctx, uint16_t protocol,
FAR uint8_t *header, FAR uint8_t *buffer, uint16_t headerlen,
uint16_t datalen);
#undef EXTERN
#ifdef __cplusplus

513
netutils/pppd/ipcp.c
View File

@ -66,9 +66,9 @@
* only)
*/
static const u8_t ipcplist[] =
static const uint8_t ipcplist[] =
{
0x3,
IPCP_IPADDRESS,
0
};
@ -84,11 +84,11 @@ static const u8_t ipcplist[] =
* Name: printip
****************************************************************************/
#if 0
void printip(uip_ipaddr_t ip2)
#if PPP_DEBUG
void printip(struct in_addr ip2)
{
char *ip = (u8_t*)ip2;
DEBUG1((" %d.%d.%d.%d ",ip[0],ip[1],ip[2],ip[3]));
char *ip = (FAR uint8_t *) & ip2.s_addr;
DEBUG1((" %d.%d.%d.%d ", ip[0], ip[1], ip[2], ip[3]));
}
#else
# define printip(x)
@ -98,7 +98,7 @@ void printip(uip_ipaddr_t ip2)
* Name: ipcp_init
****************************************************************************/
void ipcp_init(struct ppp_context_s *ctx)
void ipcp_init(FAR struct ppp_context_s *ctx)
{
DEBUG1(("ipcp init\n"));
@ -126,317 +126,335 @@ void ipcp_init(struct ppp_context_s *ctx)
*
****************************************************************************/
void ipcp_rx(struct ppp_context_s *ctx, u8_t *buffer, u16_t count)
void ipcp_rx(FAR struct ppp_context_s *ctx, FAR uint8_t * buffer,
uint16_t count)
{
u8_t *bptr = buffer;
//IPCPPKT *pkt=(IPCPPKT *)buffer;
u16_t len;
FAR uint8_t *bptr = buffer;
uint16_t len;
DEBUG1(("IPCP len %d\n",count));
DEBUG1(("IPCP len %d\n", count));
switch (*bptr++)
{
case CONF_REQ:
/* Parse request and see if we can ACK it */
{
case CONF_REQ:
/* Parse request and see if we can ACK it */
++bptr;
len = (*bptr++ << 8);
len |= *bptr++;
/* len-=2; */
++bptr;
len = (*bptr++ << 8);
len |= *bptr++;
DEBUG1(("check lcplist\n"));
if (scan_packet(ctx, IPCP, ipcplist, buffer, bptr, (u16_t)(len - 4)))
{
DEBUG1(("option was bad\n"));
}
else
{
DEBUG1(("IPCP options are good\n"));
/* len-=2; */
/* Parse out the results */
/* lets try to implement what peer wants */
/* Reject any protocol not */
/* Error? if we we need to send a config Reject ++++ this is good for a subroutine*/
/* All we should get is the peer IP address */
DEBUG1(("check lcplist\n"));
if (scan_packet(ctx, IPCP, ipcplist, buffer, bptr, (uint16_t) (len - 4)))
{
DEBUG1(("option was bad\n"));
}
else
{
DEBUG1(("IPCP options are good\n"));
if (IPCP_IPADDRESS == *bptr++)
{
/* Dump length */
/* Parse out the results */
++bptr;
/* lets try to implement what peer wants */
/* Reject any protocol not */
/* Error? if we we need to send a config Reject ++++ this is good for
* a subroutine.
*/
/* All we should get is the peer IP address */
if (IPCP_IPADDRESS == *bptr++)
{
/* Dump length */
++bptr;
#ifdef IPCP_GET_PEER_IP
((u8_t*)&ctx->peer_ip)[0] = *bptr++;
((u8_t*)&ctx->peer_ip)[1] = *bptr++;
((u8_t*)&ctx->peer_ip)[2] = *bptr++;
((u8_t*)&ctx->peer_ip)[3] = *bptr++;
((FAR uint8_t *) & ctx->peer_ip)[0] = *bptr++;
((FAR uint8_t *) & ctx->peer_ip)[1] = *bptr++;
((FAR uint8_t *) & ctx->peer_ip)[2] = *bptr++;
((FAR uint8_t *) & ctx->peer_ip)[3] = *bptr++;
DEBUG1(("Peer IP "));
/* printip(peer_ip_addr); */
DEBUG1(("\n"));
DEBUG1(("Peer IP "));
printip(ctx->peer_ip);
DEBUG1(("\n"));
netlib_set_dripv4addr((char*)ctx->ifname, &ctx->peer_ip);
netlib_set_dripv4addr((char *)ctx->ifname, &ctx->peer_ip);
#else
bptr += 4;
bptr += 4;
#endif
}
else
{
DEBUG1(("HMMMM this shouldn't happen IPCP1\n"));
}
}
else
{
DEBUG1(("HMMMM this shouldn't happen IPCP1\n"));
}
#if 0
if (error)
{
/* Write the config NAK packet we've built above, take on the header */
if (error)
{
/* Write the config NAK packet we've built above, take on the
* header
*/
bptr = buffer;
*bptr++ = CONF_NAK; /* Write Conf_rej */
*bptr++;
/*tptr++;*/ /* skip over ID */
bptr = buffer;
*bptr++ = CONF_NAK; /* Write Conf_rej */
*bptr++;
/* Write new length */
/* tptr++; *//* skip over ID */
*bptr++ = 0;
*bptr = tptr - buffer;
/* Write new length */
/* Write the reject frame */
*bptr++ = 0;
*bptr = tptr - buffer;
DEBUG1(("Writing NAK frame \n"));
ahdlc_tx(IPCP, buffer, (u16_t)(tptr - buffer));
DEBUG1(("- End NAK Write frame\n"));
}
else
{
}
/* Write the reject frame */
DEBUG1(("Writing NAK frame \n"));
ahdlc_tx(IPCP, buffer, (uint16_t) (tptr - buffer));
DEBUG1(("- End NAK Write frame\n"));
}
else
{
}
#endif
/* If we get here then we are OK, lets send an ACK and tell the rest
* of our modules our negotiated config.
*/
/* If we get here then we are OK, lets send an ACK and tell the rest
* of our modules our negotiated config.
*/
ctx->ipcp_state |= IPCP_RX_UP;
DEBUG1(("Send IPCP ACK!\n"));
bptr = buffer;
*bptr++ = CONF_ACK; /* Write Conf_ACK */
bptr++; /* Skip ID (send same one) */
ctx->ipcp_state |= IPCP_RX_UP;
DEBUG1(("Send IPCP ACK!\n"));
bptr = buffer;
*bptr++ = CONF_ACK; /* Write Conf_ACK */
bptr++; /* Skip ID (send same one) */
/* Set stuff */
/* Set stuff */
/* ppp_flags |= tflag; */
DEBUG1(("SET- stuff -- are we up? c=%d dif=%d \n", count, (u16_t)(bptr - buffer)));
/* ppp_flags |= tflag; */
/* Write the ACK frame */
DEBUG1(("SET- stuff -- are we up? c=%d dif=%d \n",
count, (uint16_t) (bptr - buffer)));
DEBUG1(("Writing ACK frame \n"));
/* Write the ACK frame */
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
DEBUG1(("Writing ACK frame \n"));
ahdlc_tx(ctx, IPCP, 0, buffer, 0, count /*bptr-buffer*/);
DEBUG1(("- End ACK Write frame\n"));
}
break;
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
case CONF_ACK: /* config Ack */
DEBUG1(("CONF ACK\n"));
/* Parse out the results
*
* Dump the ID and get the length.
*/
/* Dump the ID */
bptr++;
/* Get the length */
len = (*bptr++ << 8);
len |= *bptr++;
#if 0
/* Parse ACK and set data */
while (bptr < buffer + len)
{
switch (*bptr++)
{
case IPCP_IPADDRESS:
/* Dump length */
bptr++;
((u8_t*)ipaddr)[0] = *bptr++;
((u8_t*)ipaddr)[1] = *bptr++;
((u8_t*)ipaddr)[2] = *bptr++;
((u8_t*)ipaddr)[3] = *bptr++;
break;
case IPCP_PRIMARY_DNS:
bptr++;
((u8_t*)pri_dns_addr)[0] = *bptr++;
((u8_t*)pri_dns_addr)[1] = *bptr++;
((u8_t*)pri_dns_addr)[2] = *bptr++;
((u8_t*)pri_dns_addr)[3] = *bptr++;
break;
case IPCP_SECONDARY_DNS:
bptr++;
((u8_t*)sec_dns_addr)[0] = *bptr++;
((u8_t*)sec_dns_addr)[1] = *bptr++;
((u8_t*)sec_dns_addr)[2] = *bptr++;
((u8_t*)sec_dns_addr)[3] = *bptr++;
break;
default:
DEBUG1(("IPCP CONFIG_ACK problem1\n"));
ahdlc_tx(ctx, IPCP, 0, buffer, 0, count /* bptr-buffer */);
DEBUG1(("- End ACK Write frame\n"));
}
break;
case CONF_ACK: /* config Ack */
DEBUG1(("CONF ACK\n"));
/* Parse out the results Dump the ID and get the length. */
/* Dump the ID */
bptr++;
/* Get the length */
len = (*bptr++ << 8);
len |= *bptr++;
#if 0
/* Parse ACK and set data */
while (bptr < buffer + len)
{
switch (*bptr++)
{
case IPCP_IPADDRESS:
/* Dump length */
bptr++;
((FAR uint8_t *) & ctx->local_ip)[0] = *bptr++;
((FAR uint8_t *) & ctx->local_ip)[1] = *bptr++;
((FAR uint8_t *) & ctx->local_ip)[2] = *bptr++;
((FAR uint8_t *) & ctx->local_ip)[3] = *bptr++;
break;
# ifdef IPCP_GET_PRI_DNS
case IPCP_PRIMARY_DNS:
bptr++;
((FAR uint8_t *) & ctx->pri_dns_addr)[0] = *bptr++;
((FAR uint8_t *) & ctx->pri_dns_addr)[1] = *bptr++;
((FAR uint8_t *) & ctx->pri_dns_addr)[2] = *bptr++;
((FAR uint8_t *) & ctx->pri_dns_addr)[3] = *bptr++;
break;
# endif
# ifdef IPCP_GET_SEC_DNS
case IPCP_SECONDARY_DNS:
bptr++;
((FAR uint8_t *) & ctx->sec_dns_addr)[0] = *bptr++;
((FAR uint8_t *) & ctx->sec_dns_addr)[1] = *bptr++;
((FAR uint8_t *) & ctx->sec_dns_addr)[2] = *bptr++;
((FAR uint8_t *) & ctx->sec_dns_addr)[3] = *bptr++;
break;
# endif
default:
DEBUG1(("IPCP CONFIG_ACK problem1\n"));
}
}
}
#endif
ctx->ipcp_state |= IPCP_TX_UP;
/*ppp_ipcp_state &= ~IPCP_RX_UP;*/
ctx->ipcp_state |= IPCP_TX_UP;
DEBUG1(("were up! \n"));
//printip(pppif.ipaddr);
/* ppp_ipcp_state &= ~IPCP_RX_UP; */
DEBUG1(("were up! \n"));
printip(ctx->local_ip);
#ifdef IPCP_GET_PRI_DNS
printip(pri_dns_addr);
printip(ctx->pri_dns_addr);
#endif
#ifdef IPCP_GET_SEC_DNS
printip(sec_dns_addr);
printip(ctx->sec_dns_addr);
#endif
DEBUG1(("\n"));
break;
DEBUG1(("\n"));
break;
case CONF_NAK: /* Config Nack */
DEBUG1(("CONF NAK\n"));
case CONF_NAK: /* Config Nack */
DEBUG1(("CONF NAK\n"));
/* Dump the ID */
/* Dump the ID */
bptr++;
bptr++;
/* Get the length */
/* Get the length */
len = (*bptr++ << 8);
len |= *bptr++;
len = (*bptr++ << 8);
len |= *bptr++;
/* Parse ACK and set data */
/* Parse ACK and set data */
while (bptr < buffer + len)
{
switch (*bptr++)
while (bptr < buffer + len)
{
case IPCP_IPADDRESS:
/* dump length */
bptr++;
switch (*bptr++)
{
case IPCP_IPADDRESS:
/* Dump length */
((u8_t*)&ctx->local_ip)[0] = (char)*bptr++;
((u8_t*)&ctx->local_ip)[1] = (char)*bptr++;
((u8_t*)&ctx->local_ip)[2] = (char)*bptr++;
((u8_t*)&ctx->local_ip)[3] = (char)*bptr++;
bptr++;
netlib_ifup((char*)ctx->ifname);
netlib_set_ipv4addr((char*)ctx->ifname, &ctx->local_ip);
//DEBUG1(("My PPP-ipno: (%d.%d.%d.%d)\n", ((u8_t*)pppif.ipaddr)[0], ((u8_t*)pppif.ipaddr)[1], ((u8_t*)pppif.ipaddr)[2], ((u8_t*)pppif.ipaddr)[3]));
break;
((FAR uint8_t *) & ctx->local_ip)[0] = (char)*bptr++;
((FAR uint8_t *) & ctx->local_ip)[1] = (char)*bptr++;
((FAR uint8_t *) & ctx->local_ip)[2] = (char)*bptr++;
((FAR uint8_t *) & ctx->local_ip)[3] = (char)*bptr++;
netlib_ifup((char *)ctx->ifname);
netlib_set_ipv4addr((char *)ctx->ifname, &ctx->local_ip);
break;
#ifdef IPCP_GET_PRI_DNS
case IPCP_PRIMARY_DNS:
bptr++;
((u8_t*)&ctx->pri_dns_addr)[0] = *bptr++;
((u8_t*)&ctx->pri_dns_addr)[1] = *bptr++;
((u8_t*)&ctx->pri_dns_addr)[2] = *bptr++;
((u8_t*)&ctx->pri_dns_addr)[3] = *bptr++;
break;
case IPCP_PRIMARY_DNS:
bptr++;
((FAR uint8_t *) & ctx->pri_dns_addr)[0] = *bptr++;
((FAR uint8_t *) & ctx->pri_dns_addr)[1] = *bptr++;
((FAR uint8_t *) & ctx->pri_dns_addr)[2] = *bptr++;
((FAR uint8_t *) & ctx->pri_dns_addr)[3] = *bptr++;
netlib_set_ipv4dnsaddr(&ctx->pri_dns_addr);
break;
#endif
#ifdef IPCP_GET_SEC_DNS
case IPCP_SECONDARY_DNS:
bptr++;
((u8_t*)&ctx->sec_dns_addr)[0] = *bptr++;
((u8_t*)&ctx->sec_dns_addr)[1] = *bptr++;
((u8_t*)&ctx->sec_dns_addr)[2] = *bptr++;
((u8_t*)&ctx->sec_dns_addr)[3] = *bptr++;
break;
case IPCP_SECONDARY_DNS:
bptr++;
((FAR uint8_t *) & ctx->sec_dns_addr)[0] = *bptr++;
((FAR uint8_t *) & ctx->sec_dns_addr)[1] = *bptr++;
((FAR uint8_t *) & ctx->sec_dns_addr)[2] = *bptr++;
((FAR uint8_t *) & ctx->sec_dns_addr)[3] = *bptr++;
netlib_set_ipv4dnsaddr(&ctx->sec_dns_addr);
break;
#endif
default:
DEBUG1(("IPCP CONFIG_ACK problem 2\n"));
default:
DEBUG1(("IPCP CONFIG_ACK problem 2\n"));
}
}
}
ctx->ppp_id++;
ctx->ppp_id++;
printip(pppif.ipaddr);
printip(ctx->local_ip);
#ifdef IPCP_GET_PRI_DNS
printip(pri_dns_addr);
printip(ctx->pri_dns_addr);
#endif
#ifdef IPCP_GET_PRI_DNS
printip(sec_dns_addr);
printip(ctx->sec_dns_addr);
#endif
DEBUG1(("\n"));
break;
DEBUG1(("\n"));
break;
case CONF_REJ: /* Config Reject */
DEBUG1(("CONF REJ\n"));
case CONF_REJ: /* Config Reject */
DEBUG1(("CONF REJ\n"));
/* Remove the offending options*/
/* Remove the offending options */
ctx->ppp_id++;
ctx->ppp_id++;
/* Dump the ID */
/* Dump the ID */
bptr++;
bptr++;
/* Get the length */
/* Get the length */
len = (*bptr++ << 8);
len |= *bptr++;
len = (*bptr++ << 8);
len |= *bptr++;
/* Parse ACK and set data */
/* Parse ACK and set data */
while (bptr < buffer + len)
{
switch (*bptr++)
while (bptr < buffer + len)
{
case IPCP_IPADDRESS:
ctx->ipcp_state |= IPCP_IP_BIT;
bptr += 5;
break;
switch (*bptr++)
{
case IPCP_IPADDRESS:
ctx->ipcp_state |= IPCP_IP_BIT;
bptr += 5;
break;
#ifdef IPCP_GET_PRI_DNS
case IPCP_PRIMARY_DNS:
ctx->ipcp_state |= IPCP_PRI_DNS_BIT;
bptr += 5;
break;
case IPCP_PRIMARY_DNS:
ctx->ipcp_state |= IPCP_PRI_DNS_BIT;
bptr += 5;
break;
#endif
#ifdef IPCP_GET_PRI_DNS
case IPCP_SECONDARY_DNS:
ctx->ipcp_state |= IPCP_SEC_DNS_BIT;
bptr += 5;
break;
case IPCP_SECONDARY_DNS:
ctx->ipcp_state |= IPCP_SEC_DNS_BIT;
bptr += 5;
break;
#endif
default:
DEBUG1(("IPCP this shoudln't happen 3\n"));
default:
DEBUG1(("IPCP this shoudln't happen 3\n"));
}
}
}
break;
break;
default:
DEBUG1(("-Unknown 4\n"));
}
default:
DEBUG1(("-Unknown 4\n"));
}
}
/****************************************************************************
* Name: ipcp_task
****************************************************************************/
void ipcp_task(struct ppp_context_s *ctx, u8_t *buffer)
void ipcp_task(FAR struct ppp_context_s *ctx, FAR uint8_t * buffer)
{
u8_t *bptr;
u16_t t;
FAR uint8_t *bptr;
uint16_t t;
IPCPPKT *pkt;
/* IPCP tx not up and hasn't timed out then lets see if we need to
send a request */
/* IPCP tx not up and hasn't timed out then lets see if we need to send a
* request
*/
if (!(ctx->ipcp_state & IPCP_TX_UP) && !(ctx->ipcp_state & IPCP_TX_TIMEOUT))
{
@ -448,7 +466,7 @@ void ipcp_task(struct ppp_context_s *ctx, u8_t *buffer)
/* No pending request, lets build one */
pkt=(IPCPPKT *)buffer;
pkt = (IPCPPKT *) buffer;
/* Configure-Request only here, write id */
@ -457,41 +475,42 @@ void ipcp_task(struct ppp_context_s *ctx, u8_t *buffer)
bptr = pkt->data;
/* Write options, we want IP address, and DNS addresses if set. */
/* Write zeros for IP address the first time */
/* Write options, we want IP address, and DNS addresses if set.
* Write zeros for IP address the first time
*/
*bptr++ = IPCP_IPADDRESS;
*bptr++ = 0x6;
*bptr++ = (u8_t)((u8_t*)&ctx->local_ip)[0];
*bptr++ = (u8_t)((u8_t*)&ctx->local_ip)[1];
*bptr++ = (u8_t)((u8_t*)&ctx->local_ip)[2];
*bptr++ = (u8_t)((u8_t*)&ctx->local_ip)[3];
*bptr++ = (uint8_t) ((FAR uint8_t *) & ctx->local_ip)[0];
*bptr++ = (uint8_t) ((FAR uint8_t *) & ctx->local_ip)[1];
*bptr++ = (uint8_t) ((FAR uint8_t *) & ctx->local_ip)[2];
*bptr++ = (uint8_t) ((FAR uint8_t *) & ctx->local_ip)[3];
#ifdef IPCP_GET_PRI_DNS
if (!(ppp_ipcp_state & IPCP_PRI_DNS_BIT))
if ((ctx->ipcp_state & IPCP_PRI_DNS_BIT) == 0)
{
/* Write zeros for IP address the first time */
*bptr++ = IPCP_PRIMARY_DNS;
*bptr++ = 0x6;
*bptr++ = ((u8_t*)&ctx->pri_dns_addr)[0];
*bptr++ = ((u8_t*)&ctx->pri_dns_addr)[1];
*bptr++ = ((u8_t*)&ctx->pri_dns_addr)[2];
*bptr++ = ((u8_t*)&ctx->pri_dns_addr)[3];
*bptr++ = ((FAR uint8_t *) & ctx->pri_dns_addr)[0];
*bptr++ = ((FAR uint8_t *) & ctx->pri_dns_addr)[1];
*bptr++ = ((FAR uint8_t *) & ctx->pri_dns_addr)[2];
*bptr++ = ((FAR uint8_t *) & ctx->pri_dns_addr)[3];
}
#endif
#ifdef IPCP_GET_SEC_DNS
if (!(ppp_ipcp_state & IPCP_SEC_DNS_BIT))
if ((ctx->ipcp_state & IPCP_SEC_DNS_BIT) == 0)
{
/* Write zeros for IP address the first time */
*bptr++ = IPCP_SECONDARY_DNS;
*bptr++ = 0x6;
*bptr++ = ((u8_t*)&ctx->sec_dns_addr)[0];
*bptr++ = ((u8_t*)&ctx->sec_dns_addr)[1];
*bptr++ = ((u8_t*)&ctx->sec_dns_addr)[2];
*bptr++ = ((u8_t*)&ctx->sec_dns_addr)[3];
*bptr++ = ((FAR uint8_t *) & ctx->sec_dns_addr)[0];
*bptr++ = ((FAR uint8_t *) & ctx->sec_dns_addr)[1];
*bptr++ = ((FAR uint8_t *) & ctx->sec_dns_addr)[2];
*bptr++ = ((FAR uint8_t *) & ctx->sec_dns_addr)[3];
}
#endif
@ -499,7 +518,7 @@ void ipcp_task(struct ppp_context_s *ctx, u8_t *buffer)
t = bptr - buffer;
/* length here - code and ID + */
/* length here - code and ID + */
pkt->len = htons(t);
@ -517,7 +536,7 @@ void ipcp_task(struct ppp_context_s *ctx, u8_t *buffer)
if (ctx->ipcp_retry > IPCP_RETRY_COUNT)
{
ctx->ipcp_state &= IPCP_TX_TIMEOUT;
ctx->ipcp_state |= IPCP_TX_TIMEOUT;
}
}
}

25
netutils/pppd/ipcp.h
View File

@ -1,5 +1,5 @@
/****************************************************************************
* netutils/pppd/ipcp.c
* netutils/pppd/ipcp.h
* Internet Protocol Control Protocol header file
*
* Version: 0.1 Original Version June 3, 2000
@ -51,11 +51,6 @@
* Pre-processor Definitions
****************************************************************************/
/* Config options (move to pppconfig)
#define IPCP_RETRY_COUNT 5
#define IPCP_TIMEOUT 5
*/
/* IPCP Option Types */
#define IPCP_IPADDRESS 0x03
@ -68,8 +63,8 @@
#define IPCP_RX_UP 0x02
#define IPCP_IP_BIT 0x04
#define IPCP_TX_TIMEOUT 0x08
#define IPCP_PRI_DNS_BIT 0x08
#define IPCP_SEC_DNS_BIT 0x10
#define IPCP_PRI_DNS_BIT 0x10
#define IPCP_SEC_DNS_BIT 0x20
/****************************************************************************
* Public Types
@ -79,10 +74,10 @@ struct ppp_context_s;
typedef struct _ipcp
{
u8_t code;
u8_t id;
u16_t len;
u8_t data[0];
uint8_t code;
uint8_t id;
uint16_t len;
uint8_t data[0];
} IPCPPKT;
/****************************************************************************
@ -98,9 +93,9 @@ extern "C"
#define EXTERN extern
#endif
void ipcp_init(struct ppp_context_s *ctx);
void ipcp_task(struct ppp_context_s *ctx, u8_t *buffer);
void ipcp_rx(struct ppp_context_s *ctx, u8_t *, u16_t);
void ipcp_init(FAR struct ppp_context_s *ctx);
void ipcp_task(FAR struct ppp_context_s *ctx, FAR uint8_t *buffer);
void ipcp_rx(FAR struct ppp_context_s *ctx, FAR uint8_t *, uint16_t);
#undef EXTERN
#ifdef __cplusplus

564
netutils/pppd/lcp.c
View File

@ -69,16 +69,18 @@
****************************************************************************/
/* We need this when we neg our direction.
u8_t lcp_tx_options; */
* uint8_t lcp_tx_options;
*/
/* Define the supported parameters for this module here. */
static const u8_t lcplist[] =
{
static const uint8_t lcplist[] = {
LPC_MAGICNUMBER,
LPC_PFC,
LPC_ACFC,
#ifdef CONFIG_NETUTILS_PPPD_PAP
LPC_AUTH,
#endif
LPC_ACCM,
LPC_MRU,
0
@ -107,318 +109,313 @@ void lcp_init(struct ppp_context_s *ctx)
*
****************************************************************************/
void lcp_rx(struct ppp_context_s *ctx, u8_t *buffer, u16_t count)
void lcp_rx(struct ppp_context_s *ctx, uint8_t * buffer, uint16_t count)
{
u8_t *bptr = buffer, *tptr;
u8_t error = 0;
u8_t id;
u16_t len, j;
struct pppd_settings_s *pppd_settings = ctx->settings;
FAR uint8_t *bptr = buffer;
FAR uint8_t *tptr;
uint8_t error = 0;
uint8_t id;
uint16_t len;
uint16_t j;
switch (*bptr++)
{
case CONF_REQ: /* config request */
/* Parse request and see if we can ACK it */
{
case CONF_REQ: /* config request */
/* Parse request and see if we can ACK it */
id = *bptr++;
len = (*bptr++ << 8);
len |= *bptr++;
/*len -= 2;*/
id = *bptr++;
UNUSED(id);
len = (*bptr++ << 8);
len |= *bptr++;
/* In case of new peer connection */
/* len -= 2; */
ipcp_init(ctx);
ctx->lcp_state &= ~LCP_TX_UP;
/* In case of new peer connection */
DEBUG1(("received [LCP Config Request id %u\n", id));
if (scan_packet(ctx, (u16_t)LCP, lcplist, buffer, bptr, (u16_t)(len-4)))
{
/* Must do the -4 here, !scan packet */
ipcp_init(ctx);
ctx->lcp_state &= ~LCP_RX_UP;
DEBUG1((" options were rejected\n"));
}
else
{
/* Lets try to implement what peer wants */
DEBUG1(("received [LCP Config Request id %u\n", id));
if (scan_packet
(ctx, (uint16_t) LCP, lcplist, buffer, bptr, (uint16_t) (len - 4)))
{
/* Must do the -4 here, !scan packet */
tptr = bptr = buffer;
bptr += 4; /* skip code, id, len */
error = 0;
DEBUG1((" options were rejected\n"));
}
else
{
/* Lets try to implement what peer wants */
/* First scan for unknown values */
tptr = bptr;
error = 0;
while(bptr < (buffer + len))
{
switch (*bptr++)
/* First scan for unknown values */
while (bptr < (buffer + len))
{
case LPC_MRU: /* mru */
j = *bptr++;
j -= 2;
switch (*bptr++)
{
case LPC_MRU: /* mru */
j = *bptr++;
j -= 2;
if (j == 2)
{
ctx->ppp_tx_mru = ((int)*bptr++) << 8;
ctx->ppp_tx_mru |= *bptr++;
DEBUG1(("<mru %d> ", ctx->ppp_tx_mru));
}
else
{
DEBUG1(("<mru ?? > "));
}
break;
if (j == 2)
{
ctx->ppp_tx_mru = ((int)*bptr++) << 8;
ctx->ppp_tx_mru |= *bptr++;
DEBUG1(("<mru %d> ", ctx->ppp_tx_mru));
}
else
{
DEBUG1(("<mru ?? > "));
}
break;
case LPC_ACCM:
bptr++; /* skip length */
j = *bptr++;
j += *bptr++;
j += *bptr++;
j += *bptr++;
case LPC_ACCM:
bptr++; /* skip length */
j = *bptr++;
j += *bptr++;
j += *bptr++;
j += *bptr++;
if (j==0)
{
// ok
DEBUG1(("<asyncmap sum=0x%04x>",j));
//ahdlc_flags |= PPP_TX_ASYNC_MAP;
}
else if (j!=0)
{
// ok
DEBUG1(("<asyncmap sum=0x%04x>, assume 0xffffffff",j));
}
else
{
/* Fail. We only support default or all zeros */
if (j == 0)
{
/* OK */
DEBUG1(("We only support default or all zeros for ACCM "));
error = 1;
*tptr++ = LPC_ACCM;
*tptr++ = 0x6;
*tptr++ = 0;
*tptr++ = 0;
*tptr++ = 0;
*tptr++ = 0;
}
break;
DEBUG1(("<asyncmap sum=0x%04x>", j));
ctx->ahdlc_flags |= PPP_TX_ASYNC_MAP;
}
else if (j == 0x3fc)
{
/* OK */
DEBUG1(("<asyncmap sum=0x%04x>, assume 0xffffffff", j));
ctx->ahdlc_flags &= ~PPP_TX_ASYNC_MAP;
}
else
{
/* Fail. We only support default or all zeros */
DEBUG1(("We only support default or all zeros for ACCM "));
error = 1;
*tptr++ = LPC_ACCM;
*tptr++ = 0x6;
*tptr++ = 0;
*tptr++ = 0;
*tptr++ = 0;
*tptr++ = 0;
}
break;
#ifdef CONFIG_NETUTILS_PPPD_PAP
case LPC_AUTH:
bptr++;
if ((*bptr++ == 0xc0) && (*bptr++ == 0x23))
{
/* Negotiate PAP */
if (strlen(pppd_settings->pap_username) > 0)
case LPC_AUTH:
bptr++;
if ((*bptr++ == 0xc0) && (*bptr++ == 0x23))
{
/* Negotiate PAP */
DEBUG1(("<auth pap> "));
ctx->lcp_state |= LCP_RX_AUTH;
}
else
{
DEBUG1(("<rej auth pap> "));
/* We only support PAP */
*tptr++ = CONF_REJ;
tptr++; // Keep ID
*tptr++ = 0;
*tptr++ = 8;
DEBUG1(("<auth ?? >"));
error = 1;
*tptr++ = LPC_AUTH;
*tptr++ = 0x4;
*tptr++ = 0xc0;
*tptr++ = 0x23;
ahdlc_tx(ctx, LCP, 0, buffer, 0, (u16_t)(tptr-buffer));
return;
}
break;
#endif /* CONFIG_NETUTILS_PPPD_PAP */
case LPC_MAGICNUMBER:
DEBUG1(("<magic > "));
/* Compare incoming number to our number (not implemented) */
bptr++; /* For now just dump */
bptr++;
bptr++;
bptr++;
bptr++;
break;
case LPC_PFC:
bptr++;
DEBUG1(("<pcomp> "));
ctx->ahdlc_flags |= PPP_PFC;
break;
case LPC_ACFC:
bptr++;
DEBUG1(("<accomp> "));
ctx->ahdlc_flags |= PPP_ACFC;
break;
}
else
{
/* We only support PAP */
DEBUG1(("<auth ?? >"));
error = 1;
*tptr++ = LPC_AUTH;
*tptr++ = 0x4;
*tptr++ = 0xc0;
*tptr++ = 0x23;
}
break;
#endif /* CONFIG_NETUTILS_PPPD_PAP */
case LPC_MAGICNUMBER:
DEBUG1(("<magic > "));
/* Compare incoming number to our number (not implemented) */
bptr++; /* For now just dump */
bptr++;
bptr++;
bptr++;
bptr++;
break;
case LPC_PFC:
bptr++;
DEBUG1(("<pcomp> "));
/*tflag|=PPP_PFC;*/
break;
case LPC_ACFC:
bptr++;
DEBUG1(("<accomp> "));
/*tflag|=PPP_ACFC;*/
break;
}
}
/* Error? if we we need to send a config Reject ++++ this is good
* for a subroutine.
*/
/* Error? if we we need to send a config Reject ++++ this is good for
* a subroutine.
*/
if (error)
{
/* Write the config NAK packet we've built above, take on the
* header
*/
if (error)
{
/* Write the config NAK packet we've built above, take on the
* header
*/
bptr = buffer;
*bptr++ = CONF_NAK; /* Write Conf_rej */
bptr++;/*tptr++;*/ /* skip over ID */
bptr = buffer;
*bptr++ = CONF_NAK; /* Write Conf_rej */
bptr++; /* tptr++; skip over ID */
/* Write new length */
/* Write new length */
*bptr++ = 0;
*bptr = tptr - buffer;
*bptr++ = 0;
*bptr = tptr - buffer;
/* Write the reject frame */
/* Write the reject frame */
DEBUG1(("\nWriting NAK frame \n"));
// Send packet ahdlc_txz(procol,header,data,headerlen,datalen);
ahdlc_tx(ctx, LCP, 0, buffer, 0, (u16_t)(tptr-buffer));
DEBUG1(("- end NAK Write frame\n"));
}
else
{
/* If we get here then we are OK, lets send an ACK and tell the rest
* of our modules our negotiated config.
*/
DEBUG1(("\nWriting NAK frame \n"));
DEBUG1(("\nSend ACK!\n"));
bptr = buffer;
*bptr++ = CONF_ACK; /* Write Conf_ACK */
bptr++; /* Skip ID (send same one) */
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
/* Set stuff */
ahdlc_tx(ctx, LCP, 0, buffer, 0, (uint16_t) (tptr - buffer));
DEBUG1(("- end NAK Write frame\n"));
}
else
{
/* If we get here then we are OK, lets send an ACK and tell the
* rest of our modules our negotiated config.
*/
/*ppp_flags|=tflag;*/
/* DEBUG2("SET- stuff -- are we up? c=%d dif=%d \n", count, (u16_t)(bptr-buffer)); */
DEBUG1(("\nSend ACK!\n"));
bptr = buffer;
*bptr++ = CONF_ACK; /* Write Conf_ACK */
bptr++; /* Skip ID (send same one) */
/* Write the ACK frame */
/* Set stuff */
DEBUG2(("Writing ACK frame \n"));
/* ppp_flags |= tflag;
* DEBUG2("SET- stuff -- are we up? c=%d dif=%d \n", count,
* (uint16_t)(bptr-buffer));
*/
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
/* Write the ACK frame */
ahdlc_tx(ctx, LCP, 0, buffer, 0, count /*bptr-buffer*/);
DEBUG2(("- end ACK Write frame\n"));
ctx->lcp_state |= LCP_RX_UP;
}
}
break;
DEBUG2(("Writing ACK frame \n"));
case CONF_ACK: /* config Ack Anytime we do an ack reset the timer to force send. */
DEBUG1(("LCP-ACK - "));
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
/* Check that ID matches one sent */
ahdlc_tx(ctx, LCP, 0, buffer, 0, count /* bptr-buffer */);
DEBUG2(("- end ACK Write frame\n"));
ctx->lcp_state |= LCP_RX_UP;
}
}
break;
if (*bptr++ == ctx->ppp_id)
{
/* Change state to PPP up. */
case CONF_ACK: /* config Ack Anytime we do an ack reset the
* timer to force send. */
DEBUG1(("LCP-ACK - "));
DEBUG1((">>>>>>>> good ACK id up! %d\n", ctx->ppp_id));
/* Check that ID matches one sent */
/* Copy negotiated values over */
if (*bptr++ == ctx->ppp_id)
{
/* Change state to PPP up. */
ctx->lcp_state |= LCP_TX_UP;
}
else
{
DEBUG1(("*************++++++++++ bad id %d\n", ctx->ppp_id));
}
break;
DEBUG1((">>>>>>>> good ACK id up! %d\n", ctx->ppp_id));
case CONF_NAK: /* Config Nack */
DEBUG1(("LCP-CONF NAK\n"));
ctx->ppp_id++;
break;
/* Copy negotiated values over */
case CONF_REJ: /* Config Reject */
DEBUG1(("LCP-CONF REJ\n"));
ctx->ppp_id++;
break;
ctx->lcp_state |= LCP_TX_UP;
}
else
{
DEBUG1(("*************++++++++++ bad id %d\n", ctx->ppp_id));
}
break;
case TERM_REQ: /* Terminate Request */
DEBUG1(("LCP-TERM-REQ -"));
bptr = buffer;
*bptr++ = TERM_ACK; /* Write TERM_ACK */
case CONF_NAK: /* Config Nack */
DEBUG1(("LCP-CONF NAK\n"));
ctx->ppp_id++;
break;
/* Write the reject frame */
case CONF_REJ: /* Config Reject */
DEBUG1(("LCP-CONF REJ\n"));
ctx->ppp_id++;
break;
DEBUG1(("Writing TERM_ACK frame \n"));
case TERM_REQ: /* Terminate Request */
DEBUG1(("LCP-TERM-REQ -"));
bptr = buffer;
*bptr++ = TERM_ACK; /* Write TERM_ACK */
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
/* Write the reject frame */
ahdlc_tx(ctx, LCP, 0, buffer, 0, count);
DEBUG1(("Writing TERM_ACK frame \n"));
ctx->lcp_state &= ~LCP_TX_UP;
ctx->lcp_state |= LCP_TERM_PEER;
break;
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
case TERM_ACK:
DEBUG1(("LCP-TERM ACK\n"));
break;
ahdlc_tx(ctx, LCP, 0, buffer, 0, count);
case ECHO_REQ:
if ((ctx->lcp_state & LCP_TX_UP) && (ctx->lcp_state & LCP_RX_UP))
{
bptr = buffer;
*bptr++ = ECHO_REP; /* Write ECHO-REPLY */
ctx->lcp_state &= ~LCP_TX_UP;
ctx->lcp_state |= LCP_TERM_PEER;
break;
bptr += 3; /* Skip id and length */
case TERM_ACK:
DEBUG1(("LCP-TERM ACK\n"));
break;
*bptr++ = 0; /* Zero Magic */
*bptr++ = 0;
*bptr++ = 0;
*bptr++ = 0;
case ECHO_REQ:
if ((ctx->lcp_state & LCP_TX_UP) && (ctx->lcp_state & LCP_RX_UP))
{
bptr = buffer;
*bptr++ = ECHO_REP; /* Write ECHO-REPLY */
/* Write the echo reply frame */
bptr += 3; /* Skip id and length */
DEBUG1(("\nWriting ECHO-REPLY frame \n"));
// Send packet ahdlc_txz(procol,header,data,headerlen,datalen);
ahdlc_tx(ctx, LCP, 0, buffer, 0, count);
DEBUG1(("- end ECHO-REPLY Write frame\n"));
}
break;
*bptr++ = 0; /* Zero Magic */
*bptr++ = 0;
*bptr++ = 0;
*bptr++ = 0;
case ECHO_REP:
DEBUG1(("LCP-ECHO REPLY\n"));
if ((ctx->lcp_state & LCP_TX_UP) && (ctx->lcp_state & LCP_RX_UP))
{
ctx->ppp_id++;
}
break;
/* Write the echo reply frame */
default:
DEBUG1(("LCP unknown packet: %02x", *(bptr-1)));
break;
}
DEBUG1(("\nWriting ECHO-REPLY frame \n"));
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
ahdlc_tx(ctx, LCP, 0, buffer, 0, count);
DEBUG1(("- end ECHO-REPLY Write frame\n"));
}
break;
case ECHO_REP:
DEBUG1(("LCP-ECHO REPLY\n"));
if ((ctx->lcp_state & LCP_TX_UP) && (ctx->lcp_state & LCP_RX_UP))
{
ctx->ppp_id++;
}
break;
default:
DEBUG1(("LCP unknown packet: %02x", *(bptr - 1)));
break;
}
}
/****************************************************************************
* Name: lcp_disconnect
****************************************************************************/
void lcp_disconnect(struct ppp_context_s *ctx, u8_t id)
void lcp_disconnect(struct ppp_context_s *ctx, uint8_t id)
{
u8_t buffer[4];
u8_t *bptr = buffer;
uint8_t buffer[4];
FAR uint8_t *bptr = buffer;
*bptr++ = TERM_REQ;
*bptr++ = id;
@ -432,47 +429,50 @@ void lcp_disconnect(struct ppp_context_s *ctx, u8_t id)
* Name: lcp_echo_request
****************************************************************************/
void lcp_echo_request(struct ppp_context_s *ctx, u8_t *buffer)
void lcp_echo_request(struct ppp_context_s *ctx)
{
u8_t *bptr;
u16_t t;
uint8_t buffer[8];
FAR uint8_t *bptr;
uint16_t t;
LCPPKT *pkt;
if ((ctx->lcp_state & LCP_TX_UP) && (ctx->lcp_state & LCP_RX_UP))
{
if ((ppp_arch_clock_seconds() - ctx->lcp_prev_seconds) > LCP_ECHO_INTERVAL)
{
ctx->lcp_prev_seconds = ppp_arch_clock_seconds();
{
if ((ppp_arch_clock_seconds() - ctx->lcp_prev_seconds) >
LCP_ECHO_INTERVAL)
{
ctx->lcp_prev_seconds = ppp_arch_clock_seconds();
pkt = (LCPPKT *)buffer;
pkt = (LCPPKT *) buffer;
/* Configure-Request only here, write id */
/* Configure-Request only here, write id */
pkt->code = ECHO_REQ;
pkt->id = ctx->ppp_id;
pkt->code = ECHO_REQ;
pkt->id = ctx->ppp_id;
bptr = pkt->data;
bptr = pkt->data;
*bptr++ = 0;
*bptr++ = 0;
*bptr++ = 0;
*bptr++ = 0;
*bptr++ = 0;
*bptr++ = 0;
*bptr++ = 0;
*bptr++ = 0;
/* Write length */
/* Write length */
t = bptr - buffer;
pkt->len = htons(t); /* length here - code and ID + */
t = bptr - buffer;
pkt->len = htons(t); /* length here - code and ID + */
DEBUG1((" len %d\n",t));
DEBUG1((" len %d\n", t));
/* Send packet */
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
/* Send packet
* Send packet ahdlc_txz(procol,header,data,headerlen,datalen);
*/
DEBUG1(("\nWriting ECHO-REQUEST frame \n"));
ahdlc_tx(ctx, LCP, 0, buffer, 0, t);
DEBUG1(("- end ECHO-REQUEST Write frame\n"));
}
}
DEBUG1(("\nWriting ECHO-REQUEST frame \n"));
ahdlc_tx(ctx, LCP, 0, buffer, 0, t);
DEBUG1(("- end ECHO-REQUEST Write frame\n"));
}
}
}
/****************************************************************************
@ -484,10 +484,10 @@ void lcp_echo_request(struct ppp_context_s *ctx, u8_t *buffer)
*
****************************************************************************/
void lcp_task(struct ppp_context_s *ctx, u8_t *buffer)
void lcp_task(FAR struct ppp_context_s *ctx, FAR uint8_t * buffer)
{
u8_t *bptr;
u16_t t;
FAR uint8_t *bptr;
uint16_t t;
LCPPKT *pkt;
/* lcp tx not up and hasn't timed out then lets see if we need to send a
@ -506,7 +506,7 @@ void lcp_task(struct ppp_context_s *ctx, u8_t *buffer)
/* No pending request, lets build one */
pkt = (LCPPKT *)buffer;
pkt = (LCPPKT *) buffer;
/* Configure-Request only here, write id */
@ -531,12 +531,11 @@ void lcp_task(struct ppp_context_s *ctx, u8_t *buffer)
*bptr++ = LPC_MAGICNUMBER;
*bptr++ = 0x6;
/*
*bptr++ = random_rand() & 0xff;
*bptr++ = random_rand() & 0xff;
*bptr++ = random_rand() & 0xff;
*bptr++ = random_rand() & 0xff;
*/
/* bptr++ = random_rand() & 0xff;
* bptr++ = random_rand() & 0xff;
* bptr++ = random_rand() & 0xff;
* bptr++ = random_rand() & 0xff;
*/
*bptr++ = 0x11;
*bptr++ = 0x11;
@ -581,12 +580,13 @@ void lcp_task(struct ppp_context_s *ctx, u8_t *buffer)
/* Write length */
t = bptr - buffer;
pkt->len = htons(t); /* length here - code and ID + */
pkt->len = htons(t); /* length here - code and ID + */
DEBUG1((" len %d\n",t));
DEBUG1((" len %d\n", t));
/* Send packet */
/* Send packet ahdlc_txz(procol,header,data,headerlen,datalen); */
/* Send packet
* Send packet ahdlc_txz(procol,header,data,headerlen,datalen);
*/
ahdlc_tx(ctx, LCP, 0, buffer, 0, t);
@ -598,7 +598,7 @@ void lcp_task(struct ppp_context_s *ctx, u8_t *buffer)
if (ctx->lcp_retry > LCP_RETRY_COUNT)
{
ctx->lcp_state &= LCP_TX_TIMEOUT;
ctx->lcp_state |= LCP_TX_TIMEOUT;
}
}
}

25
netutils/pppd/lcp.h
View File

@ -62,13 +62,6 @@
#define LPC_PFC 0x7
#define LPC_ACFC 0x8
/* LCP Negotiated options flag equates */
#define LCP_OPT_ACCM 0x1
#define LCP_OPT_AUTH 0x2
#define LCP_OPT_PFC 0x4
#define LCP_OPT_ACFC 0x4
/* LCP state machine flags */
#define LCP_TX_UP 0x1
@ -93,10 +86,10 @@ struct ppp_context_s;
typedef struct _lcppkt
{
u8_t code;
u8_t id;
u16_t len;
u8_t data[0];
uint8_t code;
uint8_t id;
uint16_t len;
uint8_t data[0];
} LCPPKT;
/****************************************************************************
@ -112,11 +105,11 @@ extern "C"
#define EXTERN extern
#endif
void lcp_init(struct ppp_context_s *ctx);
void lcp_rx(struct ppp_context_s *ctx, u8_t *, u16_t);
void lcp_task(struct ppp_context_s *ctx, u8_t *buffer);
void lcp_disconnect(struct ppp_context_s *ctx, u8_t id);
void lcp_echo_request(struct ppp_context_s *ctx, u8_t *buffer);
void lcp_init(FAR struct ppp_context_s *ctx);
void lcp_rx(FAR struct ppp_context_s *ctx, FAR uint8_t *, uint16_t);
void lcp_task(FAR struct ppp_context_s *ctx, FAR uint8_t *buffer);
void lcp_disconnect(FAR struct ppp_context_s *ctx, uint8_t id);
void lcp_echo_request(FAR struct ppp_context_s *ctx);
#undef EXTERN
#ifdef __cplusplus

76
netutils/pppd/pap.c
View File

@ -83,39 +83,41 @@ void pap_init(struct ppp_context_s *ctx)
*
****************************************************************************/
void pap_rx(struct ppp_context_s *ctx, u8_t *buffer, u16_t count)
void pap_rx(struct ppp_context_s *ctx, FAR uint8_t * buffer, uint16_t count)
{
u8_t *bptr=buffer;
u8_t len;
FAR uint8_t *bptr = buffer;
uint8_t len;
switch (*bptr++)
{
case CONF_REQ:
DEBUG1(("CONF REQ - only for server, no support\n"));
break;
{
case CONF_REQ:
DEBUG1(("CONF REQ - only for server, no support\n"));
break;
case CONF_ACK: /* config Ack */
DEBUG1(("CONF ACK - PAP good - "));
case CONF_ACK: /* config Ack */
DEBUG1(("CONF ACK - PAP good - "));
/* Display message if debug */
/* Display message if debug */
len = *bptr++;
*(bptr + len) = 0;
DEBUG1((" %s \n",bptr));
ctx->pap_state |= PAP_TX_UP;
break;
bptr += 3;
len = *bptr++;
*(bptr + len) = 0;
DEBUG1((" %s \n", bptr));
ctx->pap_state |= PAP_TX_UP;
break;
case CONF_NAK:
DEBUG1(("CONF NAK - Failed Auth - "));
ctx->pap_state |= PAP_TX_AUTH_FAIL;
case CONF_NAK:
DEBUG1(("CONF NAK - Failed Auth - "));
ctx->pap_state |= PAP_TX_AUTH_FAIL;
/* Display message if debug */
/* Display message if debug */
len = *bptr++;
*(bptr + len)=0;
DEBUG1((" %s \n",bptr));
break;
}
bptr += 3;
len = *bptr++;
*(bptr + len) = 0;
DEBUG1((" %s \n", bptr));
break;
}
}
/****************************************************************************
@ -124,18 +126,18 @@ void pap_rx(struct ppp_context_s *ctx, u8_t *buffer, u16_t count)
*
****************************************************************************/
void pap_task(struct ppp_context_s *ctx, u8_t *buffer)
void pap_task(FAR struct ppp_context_s *ctx, FAR uint8_t * buffer)
{
u8_t *bptr;
u16_t t;
FAR uint8_t *bptr;
uint16_t t;
PAPPKT *pkt;
/* If LCP is up and PAP negotiated, try to bring up PAP */
if (!(ctx->pap_state & PAP_TX_UP) && !(ctx->pap_state & PAP_TX_TIMEOUT))
{
/* Do we need to send a PAP auth packet?
Check if we have a request pending*/
/* Do we need to send a PAP auth packet? Check if we have a request
* pending */
if ((ppp_arch_clock_seconds() - ctx->pap_prev_seconds) > PAP_TIMEOUT)
{
@ -147,7 +149,7 @@ void pap_task(struct ppp_context_s *ctx, u8_t *buffer)
/* Build a PAP request packet */
pkt = (PAPPKT *)buffer;
pkt = (PAPPKT *) buffer;
/* Configure-Request only here, write id */
@ -157,26 +159,26 @@ void pap_task(struct ppp_context_s *ctx, u8_t *buffer)
/* Write options */
t = strlen((char*)ctx->settings->pap_username);
t = strlen((char *)ctx->settings->pap_username);
/* Write peer length */
*bptr++ = (u8_t)t;
*bptr++ = (uint8_t) t;
bptr = memcpy(bptr, ctx->settings->pap_username, t);
t = strlen((char*)ctx->settings->pap_password);
*bptr++ = (u8_t)t;
t = strlen((char *)ctx->settings->pap_password);
*bptr++ = (uint8_t) t;
bptr = memcpy(bptr, ctx->settings->pap_password, t);
/* Write length */
t = bptr - buffer;
/* length here - code and ID + */
/* length here - code and ID + */
pkt->len = htons(t);
DEBUG1((" Len %d\n",t));
DEBUG1((" Len %d\n", t));
/* Send packet */
@ -189,7 +191,7 @@ void pap_task(struct ppp_context_s *ctx, u8_t *buffer)
if (ctx->pap_retry > PAP_RETRY_COUNT)
{
DEBUG1(("PAP - timout\n"));
ctx->pap_state &= PAP_TX_TIMEOUT;
ctx->pap_state |= PAP_TX_TIMEOUT;
}
}
}

17
netutils/pppd/pap.h
View File

@ -66,7 +66,7 @@
#define PAP_RX_AUTH_FAIL 0x10
#define PAP_TX_AUTH_FAIL 0x20
#define PAP_RX_TIMEOUT 0x80
#define PAP_RX_TIMEOUT 0x40
#define PAP_TX_TIMEOUT 0x80
/****************************************************************************
@ -77,10 +77,10 @@ struct ppp_context_s;
typedef struct _pappkt
{
u8_t code;
u8_t id;
u16_t len;
u8_t data[0];
uint8_t code;
uint8_t id;
uint16_t len;
uint8_t data[0];
} PAPPKT;
/****************************************************************************
@ -97,9 +97,10 @@ extern "C"
#endif
/* Function prototypes */
void pap_init(struct ppp_context_s *ctx);
void pap_rx(struct ppp_context_s *ctx, u8_t *, u16_t);
void pap_task(struct ppp_context_s *ctx, u8_t *buffer);
void pap_init(FAR struct ppp_context_s *ctx);
void pap_rx(FAR struct ppp_context_s *ctx, FAR uint8_t *, uint16_t);
void pap_task(FAR struct ppp_context_s *ctx, FAR uint8_t *buffer);
#undef EXTERN
#ifdef __cplusplus

203
netutils/pppd/ppp.c
View File

@ -51,8 +51,8 @@
#include "lcp.h"
#ifdef CONFIG_NETUTILS_PPPD_PAP
#include "pap.h"
#endif /* CONFIG_NETUTILS_PPPD_PAP */
# include "pap.h"
#endif
/****************************************************************************
* Pre-processor Definitions
@ -66,7 +66,7 @@
/* Set the debug message level */
#define PACKET_RX_DEBUG 1
#define PACKET_RX_DEBUG PPP_DEBUG
/****************************************************************************
* Private Functions
@ -77,16 +77,18 @@
*
****************************************************************************/
static void ppp_reject_protocol(struct ppp_context_s *ctx, u16_t protocol,
u8_t *buffer, u16_t count)
static void ppp_reject_protocol(FAR struct ppp_context_s *ctx,
uint16_t protocol, FAR uint8_t * buffer,
uint16_t count)
{
u16_t i;
u8_t *dptr, *sptr;
LCPPKT *pkt;
uint16_t i;
FAR uint8_t *dptr;
FAR uint8_t *sptr;
FAR LCPPKT *pkt;
/* first copy rejected packet back, start from end and work forward,
+++ Pay attention to buffer management when updated. Assumes fixed
PPP blocks. */
/* First copy rejected packet back, start from end and work forward, +++ Pay
* attention to buffer management when updated. Assumes fixed PPP blocks.
*/
DEBUG1(("Rejecting Protocol\n"));
if ((count + 6) > PPP_RX_BUFFER_SIZE)
@ -101,16 +103,18 @@ static void ppp_reject_protocol(struct ppp_context_s *ctx, u16_t protocol,
sptr = buffer + count;
for (i = 0; i < count; ++i)
{
*dptr-- = *sptr--;
*--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);
pkt = (LCPPKT *) buffer;
pkt->code = PROT_REJ; /* Write Conf_rej */
ahdlc_tx(ctx, LCP, buffer, 0, (u16_t)(count + 6), 0);
/* pkt->id = tid++; write tid */
pkt->len = htons(count + 6);
*((FAR uint16_t *) (&pkt->data[0])) = htons(protocol);
ahdlc_tx(ctx, LCP, buffer, 0, (uint16_t) (count + 6), 0);
}
/****************************************************************************
@ -122,19 +126,19 @@ static void ppp_reject_protocol(struct ppp_context_s *ctx, u16_t protocol,
****************************************************************************/
#if PACKET_RX_DEBUG
void dump_ppp_packet(u8_t *buffer, u16_t len)
void dump_ppp_packet(FAR uint8_t * buffer, uint16_t len)
{
int i;
DEBUG1(("\n"));
for (i = 0;i < len; ++i)
for (i = 0; i < len; ++i)
{
if ((i & 0x1f) == 0x10)
{
DEBUG1(("\n"));
}
DEBUG1(("0x%02x ",buffer[i]));
DEBUG1(("0x%02x ", buffer[i]));
}
DEBUG1(("\n\n"));
@ -147,18 +151,20 @@ void dump_ppp_packet(u8_t *buffer, u16_t len)
*
****************************************************************************/
void ppp_init(struct ppp_context_s *ctx)
void ppp_init(FAR struct ppp_context_s *ctx)
{
#ifdef PPP_STATISTICS
ctx->ppp_rx_frame_count = 0;
ctx->ppp_tx_frame_count = 0;
#endif
ctx->ppp_flags = 0;
ctx->ppp_tx_mru = PPP_RX_BUFFER_SIZE;
ctx->ip_no_data_time = 0;
ctx->ppp_id = 0;
#ifdef CONFIG_NETUTILS_PPPD_PAP
pap_init(ctx);
#endif /* CONFIG_NETUTILS_PPPD_PAP */
#endif
ipcp_init(ctx);
lcp_init(ctx);
@ -166,82 +172,11 @@ void ppp_init(struct ppp_context_s *ctx)
ahdlc_rx_ready(ctx);
}
/****************************************************************************
* 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 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
/****************************************************************************
* Name: ppp_connect
****************************************************************************/
void ppp_connect(struct ppp_context_s *ctx)
void ppp_connect(FAR struct ppp_context_s *ctx)
{
/* Initialize PPP engine */
@ -249,7 +184,7 @@ void ppp_connect(struct ppp_context_s *ctx)
#ifdef CONFIG_NETUTILS_PPPD_PAP
pap_init(ctx);
#endif /* CONFIG_NETUTILS_PPPD_PAP */
#endif
ipcp_init(ctx);
lcp_init(ctx);
@ -262,7 +197,7 @@ void ppp_connect(struct ppp_context_s *ctx)
* Name: ppp_send
****************************************************************************/
void ppp_send(struct ppp_context_s *ctx)
void ppp_send(FAR struct ppp_context_s *ctx)
{
/* If IPCP came up then our link should be up. */
@ -276,9 +211,9 @@ void ppp_send(struct ppp_context_s *ctx)
* Name: ppp_poll
****************************************************************************/
void ppp_poll(struct ppp_context_s *ctx)
void ppp_poll(FAR struct ppp_context_s *ctx)
{
u8_t c;
uint8_t c;
ctx->ip_len = 0;
@ -303,7 +238,7 @@ void ppp_poll(struct ppp_context_s *ctx)
if ((ctx->ipcp_state & IPCP_TX_UP) && (ctx->ipcp_state & IPCP_RX_UP))
{
lcp_echo_request(ctx, ctx->ip_buf);
lcp_echo_request(ctx);
return;
}
@ -316,6 +251,7 @@ void ppp_poll(struct ppp_context_s *ctx)
if ((ctx->lcp_state & LCP_TX_UP) && (ctx->lcp_state & LCP_RX_UP))
{
/* If LCP wants PAP, try to authenticate, else bring up IPCP */
#ifdef CONFIG_NETUTILS_PPPD_PAP
if ((ctx->lcp_state & LCP_RX_AUTH) && (!(ctx->pap_state & PAP_TX_UP)))
{
@ -328,11 +264,11 @@ void ppp_poll(struct ppp_context_s *ctx)
#else
if (ctx->lcp_state & LCP_RX_AUTH)
{
/* lcp is asking for authentication but we do not support this.
* This should be communicated upstream but we do not have an
* interface for that right now, so just ignore it; nothing can be
* done. This also should not have been hit because upcall does
* not know about the pap message type.
/* lcp is asking for authentication but we do not support this. This
* should be communicated upstream but we do not have an interface
* for that right now, so just ignore it; nothing can be done. This
* also should not have been hit because upcall does not know about
* the pap message type.
*/
DEBUG1(("Asking for PAP, but we do not know PAP\n"));
@ -341,7 +277,7 @@ void ppp_poll(struct ppp_context_s *ctx)
{
ipcp_task(ctx, ctx->ip_buf);
}
#endif /* CONFIG_NETUTILS_PPPD_PAP */
#endif
}
}
@ -354,17 +290,13 @@ void ppp_poll(struct ppp_context_s *ctx)
*
****************************************************************************/
void ppp_upcall(struct ppp_context_s *ctx, u16_t protocol, u8_t *buffer, u16_t len)
void ppp_upcall(FAR struct ppp_context_s *ctx, uint16_t protocol,
FAR uint8_t * buffer, uint16_t len)
{
#ifdef PPP_STATISTICS
++ctx->ppp_rx_frame_count;
#ifdef PPP_DEBUG
#if PPP_DEBUG
dump_ppp_packet(buffer, len);
#endif
#endif /* PPP_STATISTICS */
/* Check to see if we have a packet waiting to be processed */
if (ctx->ppp_flags & PPP_RX_READY)
@ -373,27 +305,27 @@ void ppp_upcall(struct ppp_context_s *ctx, u16_t protocol, u8_t *buffer, u16_t l
switch (protocol)
{
case LCP: /* We must support some level of LCP */
case LCP: /* We must support some level of LCP */
DEBUG1(("LCP Packet - "));
lcp_rx(ctx, buffer, len);
DEBUG1(("\n"));
break;
#ifdef CONFIG_NETUTILS_PPPD_PAP
case PAP: /* PAP should be compile in optional */
case PAP: /* PAP should be compile in optional */
DEBUG1(("PAP Packet - "));
pap_rx(ctx, buffer, len);
DEBUG1(("\n"));
break;
#endif /* CONFIG_NETUTILS_PPPD_PAP */
#endif
case IPCP: /* IPCP should be compile in optional. */
case IPCP: /* IPCP should be compile in optional. */
DEBUG1(("IPCP Packet - "));
ipcp_rx(ctx, buffer, len);
DEBUG1(("\n"));
break;
case IPV4: /* We must support IPV4 */
case IPV4: /* We must support IPV4 */
DEBUG1(("IPV4 Packet---\n"));
memcpy(ctx->ip_buf, buffer, len);
ctx->ip_len = len;
@ -402,7 +334,7 @@ void ppp_upcall(struct ppp_context_s *ctx, u16_t protocol, u8_t *buffer, u16_t l
break;
default:
DEBUG1(("Unknown PPP Packet Type 0x%04x - ",protocol));
DEBUG1(("Unknown PPP Packet Type 0x%04x - ", protocol));
ppp_reject_protocol(ctx, protocol, buffer, len);
DEBUG1(("\n"));
break;
@ -419,14 +351,17 @@ void ppp_upcall(struct ppp_context_s *ctx, u16_t protocol, u8_t *buffer, u16_t l
*
****************************************************************************/
u16_t scan_packet(struct ppp_context_s *ctx, u16_t protocol, const u8_t *list,
u8_t *buffer, u8_t *options, u16_t len)
uint16_t scan_packet(FAR struct ppp_context_s *ctx, uint16_t protocol,
FAR const FAR uint8_t * list, FAR uint8_t * buffer,
FAR uint8_t * options, uint16_t len)
{
const u8_t *tlist;
u8_t *bptr;
u8_t *tptr;
u8_t bad = 0;
u8_t i, j, good;
FAR const FAR uint8_t *tlist;
FAR uint8_t *bptr;
FAR uint8_t *tptr;
uint8_t bad = 0;
uint8_t good;
uint8_t i;
uint8_t j;
bptr = tptr = options;
@ -434,8 +369,9 @@ u16_t scan_packet(struct ppp_context_s *ctx, u16_t protocol, const u8_t *list,
while (bptr < options + len)
{
/* Get code and see if it matches somwhere in the list, if not
we don't support it */
/* Get code and see if it matches somwhere in the list, if not we don't
* support it.
*/
i = *bptr++;
@ -446,6 +382,7 @@ u16_t scan_packet(struct ppp_context_s *ctx, u16_t protocol, const u8_t *list,
while (*tlist)
{
/* DEBUG2("%x ",*tlist); */
if (i == *tlist++)
{
good = 1;
@ -457,7 +394,7 @@ u16_t scan_packet(struct ppp_context_s *ctx, u16_t protocol, const u8_t *list,
{
/* We don't understand it, write it back */
DEBUG1(("We don't understand option 0x%02x\n",i));
DEBUG1(("We don't understand option 0x%02x\n", i));
bad = 1;
*tptr++ = i;
j = *tptr++ = *bptr++;
@ -472,7 +409,7 @@ u16_t scan_packet(struct ppp_context_s *ctx, u16_t protocol, const u8_t *list,
bptr += *bptr - 1;
}
}
}
/* Bad? if we we need to send a config Reject */
@ -481,8 +418,8 @@ u16_t scan_packet(struct ppp_context_s *ctx, u16_t protocol, const u8_t *list,
/* 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++ = CONF_REJ; /* Write Conf_rej */
bptr++; /* skip over ID */
*bptr++ = 0;
*bptr = tptr - buffer;
@ -491,7 +428,7 @@ u16_t scan_packet(struct ppp_context_s *ctx, u16_t protocol, const u8_t *list,
/* Write the reject frame */
DEBUG1(("Writing Reject frame --\n"));
ahdlc_tx(ctx, protocol, buffer, 0, (u16_t)(tptr - buffer), 0);
ahdlc_tx(ctx, protocol, buffer, 0, (uint16_t) (tptr - buffer), 0);
DEBUG1(("\nEnd writing reject \n"));
}

83
netutils/pppd/ppp.h
View File

@ -47,6 +47,8 @@
#include <nuttx/config.h>
#include <stdint.h>
#include "netutils/chat.h"
#include "ppp_conf.h"
@ -57,7 +59,7 @@
#ifdef CONFIG_NETUTILS_PPPD_PAP
# include "pap.h"
#endif /* CONFIG_NETUTILS_PPPD_PAP */
#endif
/****************************************************************************
* Pre-processor Definitions
@ -74,7 +76,7 @@
#define PPP_ESCAPED 0x1
#define PPP_RX_READY 0x2
#define PPP_RX_ASYNC_MAP 0x8
#define PPP_RX_ASYNC_MAP 0x4
#define PPP_TX_ASYNC_MAP 0x8
#define PPP_PFC 0x10
#define PPP_ACFC 0x20
@ -98,12 +100,6 @@
#define ECHO_REQ 0x9
#define ECHO_REP 0xa
/* Raise PPP config bits */
#define USE_PAP 0x1
#define USE_NOACCMBUG 0x2
#define USE_GETDNS 0x4
/****************************************************************************
* Public Types
****************************************************************************/
@ -114,24 +110,23 @@ struct ppp_context_s
{
/* IP Buffer */
u8_t ip_buf[PPP_RX_BUFFER_SIZE];
u16_t ip_len;
uint8_t ip_buf[PPP_RX_BUFFER_SIZE];
uint16_t ip_len;
/* Main status */
u8_t ppp_flags;
u8_t ppp_status;
u16_t ppp_tx_mru;
u8_t ppp_id;
uint8_t ppp_flags;
uint16_t ppp_tx_mru;
uint8_t ppp_id;
/* IP timeout */
u16_t ip_no_data_time;
uint16_t ip_no_data_time;
/* Interfaces */
int if_fd;
u8_t ifname[IFNAMSIZ];
uint8_t ifname[IFNAMSIZ];
/* Addresses */
@ -148,41 +143,40 @@ struct ppp_context_s
/* LCP */
u8_t lcp_state;
u16_t lcp_tx_mru;
u8_t lcp_retry;
uint8_t lcp_state;
uint8_t lcp_retry;
time_t lcp_prev_seconds;
#ifdef CONFIG_NETUTILS_PPPD_PAP
/* PAP */
u8_t pap_state;
u8_t pap_retry;
uint8_t pap_state;
uint8_t pap_retry;
time_t pap_prev_seconds;
#endif /* CONFIG_NETUTILS_PPPD_PAP */
/* IPCP */
u8_t ipcp_state;
u8_t ipcp_retry;
uint8_t ipcp_state;
uint8_t ipcp_retry;
time_t ipcp_prev_seconds;
/* AHDLC */
u8_t ahdlc_rx_buffer[PPP_RX_BUFFER_SIZE];
u16_t ahdlc_tx_crc; /* Running tx CRC */
u16_t ahdlc_rx_crc; /* Running rx CRC */
u16_t ahdlc_rx_count; /* Number of rx bytes processed, cur frame */
u8_t ahdlc_flags; /* ahdlc state flags, see above */
u8_t ahdlc_tx_offline;
uint8_t ahdlc_rx_buffer[PPP_RX_BUFFER_SIZE];
uint16_t ahdlc_tx_crc; /* Running tx CRC */
uint16_t ahdlc_rx_crc; /* Running rx CRC */
uint16_t ahdlc_rx_count; /* Number of rx bytes processed, cur frame */
uint8_t ahdlc_flags; /* ahdlc state flags, see above */
uint8_t ahdlc_tx_offline;
/* Statistics counters */
#ifdef PPP_STATISTICS
u16_t ahdlc_crc_error;
u16_t ahdlc_rx_tobig_error;
u32_t ppp_rx_frame_count;
u32_t ppp_tx_frame_count;
uint16_t ahdlc_crc_error;
uint16_t ahdlc_rx_tobig_error;
uint32_t ppp_rx_frame_count;
uint32_t ppp_tx_frame_count;
#endif
/* Chat controls */
@ -191,7 +185,7 @@ struct ppp_context_s
/* PPPD Settings */
struct pppd_settings_s *settings;
const struct pppd_settings_s *settings;
};
/****************************************************************************
@ -207,20 +201,19 @@ extern "C"
#define EXTERN extern
#endif
/*
* Function Prototypes
*/
void ppp_init(struct ppp_context_s *ctx);
void ppp_connect(struct ppp_context_s *ctx);
void ppp_init(FAR struct ppp_context_s *ctx);
void ppp_connect(FAR struct ppp_context_s *ctx);
extern void ppp_reconnect(struct ppp_context_s *ctx);
extern void ppp_reconnect(FAR struct ppp_context_s *ctx);
void ppp_send(struct ppp_context_s *ctx);
void ppp_poll(struct ppp_context_s *ctx);
void ppp_send(FAR struct ppp_context_s *ctx);
void ppp_poll(FAR struct ppp_context_s *ctx);
void ppp_upcall(struct ppp_context_s *ctx, u16_t, u8_t *, u16_t);
u16_t scan_packet(struct ppp_context_s *ctx, u16_t, const u8_t *list,
u8_t *buffer, u8_t *options, u16_t len);
void ppp_upcall(FAR struct ppp_context_s *ctx, uint16_t,
FAR uint8_t *, uint16_t);
uint16_t scan_packet(FAR struct ppp_context_s *ctx, uint16_t,
FAR const uint8_t *list, FAR uint8_t *buffer,
FAR uint8_t *options, uint16_t len);
#undef EXTERN
#ifdef __cplusplus

10
netutils/pppd/ppp_arch.h
View File

@ -1,5 +1,5 @@
/****************************************************************************
* netutils/pppd/pppd.c
* netutils/pppd/ppp_arch.h
*
* Copyright (C) 2015 Max Nekludov. All rights reserved.
* Author: Max Nekludov <macscomp@gmail.com>
@ -62,10 +62,6 @@
struct ppp_context_s;
typedef uint8_t u8_t;
typedef uint16_t u16_t;
typedef uint32_t u32_t;
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
@ -81,8 +77,8 @@ extern "C"
time_t ppp_arch_clock_seconds(void);
int ppp_arch_getchar(struct ppp_context_s *ctx, u8_t *p);
int ppp_arch_putchar(struct ppp_context_s *ctx, u8_t c);
int ppp_arch_getchar(FAR struct ppp_context_s *ctx, FAR uint8_t *p);
int ppp_arch_putchar(FAR struct ppp_context_s *ctx, uint8_t c);
#undef EXTERN
#ifdef __cplusplus

13
netutils/pppd/ppp_conf.h
View File

@ -1,5 +1,5 @@
/****************************************************************************
* netutils/pppd/ppp-conf.c
* netutils/pppd/ppp_conf.h
*
* Copyright (C) 2015 Max Nekludov. All rights reserved.
* Author: Max Nekludov <macscomp@gmail.com>
@ -53,21 +53,16 @@
#define PPP_IP_TIMEOUT (6*3600)
#define PPP_MAX_CONNECT 15
#define PAP_USERNAME_SIZE 16
#define PAP_PASSWORD_SIZE 16
#define xxdebug_printf printf
#define debug_printf printf
#define xxdebug_printf ninfo
#define debug_printf ninfo
#define PPP_RX_BUFFER_SIZE 1024 //1024 //GD 2048 for 1280 IPv6 MTU
#define PPP_TX_BUFFER_SIZE 64
#define AHDLC_TX_OFFLINE 5
//#define AHDLC_COUNTERS 1 //defined for AHDLC stats support, Guillaume Descamps, September 19th, 2011
#define IPCP_GET_PEER_IP 1
#define PPP_STATISTICS 1
#define PPP_DEBUG 1
#define PPP_DEBUG defined(CONFIG_DEBUG_NET_INFO)
#endif /* __APPS_NETUTILS_PPPD_PPP_CONF_H */

44
netutils/pppd/pppd.c
View File

@ -63,7 +63,7 @@
#include "netutils/pppd.h"
/****************************************************************************
* Extenal Functions
* External Functions
****************************************************************************/
#ifdef PPP_ARCH_HAVE_MODEM_RESET
@ -110,7 +110,7 @@ static int tun_alloc(char *dev)
return fd;
}
printf("tun fd:%i\n", fd);
debug_printf("tun fd:%i\n", fd);
if ((errcode = make_nonblock(fd)) < 0)
{
@ -140,7 +140,7 @@ static int tun_alloc(char *dev)
* Name: open_tty
****************************************************************************/
static int open_tty(char *dev)
static int open_tty(const char *dev)
{
int fd;
int errcode;
@ -156,7 +156,7 @@ static int open_tty(char *dev)
return errcode;
}
printf("tty fd:%i\n", fd);
debug_printf("tty fd:%i\n", fd);
return fd;
}
@ -165,9 +165,9 @@ static int open_tty(char *dev)
* Name: ppp_check_errors
****************************************************************************/
static u8_t ppp_check_errors(struct ppp_context_s *ctx)
static uint8_t ppp_check_errors(FAR struct ppp_context_s *ctx)
{
u8_t ret = 0;
uint8_t ret = 0;
/* Check Errors */
@ -182,7 +182,7 @@ static u8_t ppp_check_errors(struct ppp_context_s *ctx)
{
ret = 2;
}
#endif /* CONFIG_NETUTILS_PPPD_PAP */
#endif
if (ctx->ipcp_state & (IPCP_TX_TIMEOUT))
{
@ -200,12 +200,12 @@ static u8_t ppp_check_errors(struct ppp_context_s *ctx)
* Name: ppp_reconnect
****************************************************************************/
void ppp_reconnect(struct ppp_context_s *ctx)
void ppp_reconnect(FAR struct ppp_context_s *ctx)
{
int ret;
int retry = PPP_MAX_CONNECT;
struct pppd_settings_s *pppd_settings = ctx->settings;
netlib_ifdown((char*)ctx->ifname);
const struct pppd_settings_s *pppd_settings = ctx->settings;
netlib_ifdown((char *)ctx->ifname);
lcp_disconnect(ctx, ++ctx->ppp_id);
sleep(1);
@ -220,7 +220,7 @@ void ppp_reconnect(struct ppp_context_s *ctx)
ret = chat(&ctx->ctl, pppd_settings->disconnect_script);
if (ret < 0)
{
printf("ppp: disconnect script failed\n");
debug_printf("ppp: disconnect script failed\n");
}
}
@ -231,7 +231,7 @@ void ppp_reconnect(struct ppp_context_s *ctx)
ret = chat(&ctx->ctl, pppd_settings->connect_script);
if (ret < 0)
{
printf("ppp: connect script failed\n");
debug_printf("ppp: connect script failed\n");
--retry;
if (retry == 0)
{
@ -276,7 +276,7 @@ time_t ppp_arch_clock_seconds(void)
* Name: ppp_arch_getchar
****************************************************************************/
int ppp_arch_getchar(struct ppp_context_s *ctx, u8_t *c)
int ppp_arch_getchar(FAR struct ppp_context_s *ctx, FAR uint8_t * c)
{
int ret;
@ -288,7 +288,7 @@ int ppp_arch_getchar(struct ppp_context_s *ctx, u8_t *c)
* Name: ppp_arch_putchar
****************************************************************************/
int ppp_arch_putchar(struct ppp_context_s *ctx, u8_t c)
int ppp_arch_putchar(FAR struct ppp_context_s *ctx, uint8_t c)
{
int ret;
struct pollfd fds;
@ -314,18 +314,18 @@ int ppp_arch_putchar(struct ppp_context_s *ctx, u8_t c)
* Name: pppd
****************************************************************************/
int pppd(struct pppd_settings_s *pppd_settings)
int pppd(const struct pppd_settings_s *pppd_settings)
{
struct pollfd fds[2];
int ret;
struct ppp_context_s *ctx;
FAR struct ppp_context_s *ctx;
ctx = (struct ppp_context_s*)malloc(sizeof(struct ppp_context_s));
ctx = (struct ppp_context_s *)malloc(sizeof(struct ppp_context_s));
memset(ctx, 0, sizeof(struct ppp_context_s));
strcpy((char*)ctx->ifname, "ppp%d");
strcpy((char *)ctx->ifname, "ppp%d");
ctx->settings = pppd_settings;
ctx->if_fd = tun_alloc((char*)ctx->ifname);
ctx->if_fd = tun_alloc((char *)ctx->ifname);
if (ctx->if_fd < 0)
{
free(ctx);
@ -335,12 +335,12 @@ int pppd(struct pppd_settings_s *pppd_settings)
ctx->ctl.fd = open_tty(pppd_settings->ttyname);
if (ctx->ctl.fd < 0)
{
close(ctx->ctl.fd);
close(ctx->if_fd);
free(ctx);
return 2;
}
ctx->ctl.echo = true;
ctx->ctl.echo = true;
ctx->ctl.verbose = true;
ctx->ctl.timeout = 30;
@ -362,7 +362,7 @@ int pppd(struct pppd_settings_s *pppd_settings)
if (ret > 0 && fds[0].revents & POLLIN)
{
ret = read(ctx->if_fd, ctx->ip_buf, PPP_RX_BUFFER_SIZE);
printf("read from tun :%i\n", ret);
debug_printf("read from tun :%i\n", ret);
if (ret > 0)
{
ctx->ip_len = ret;