ProjetoBB - ProjetoBB

Users » arlindonm » Code » ProjetoBB

Arlindo Montagnoli / Mbed 2 deprecated ProjetoBB

ProjetoBB

Dependencies: F7_Ethernet WebSocketClient mbed mcp3008

Fork of Nucleo_F746ZG_Ethernet by Dieter Graef

F7_Ethernet/lwip/netif/ppp/lcp.c@0:f9b6112278fe, 2016-06-18 (annotated)

Committer:: DieterGraef
Date:: Sat Jun 18 10:49:12 2016 +0000
Revision:: 0:f9b6112278fe

Ethernet for the NUCLEO STM32F746 Board Testprogram uses DHCP and NTP to set the clock

Who changed what in which revision?

User	Revision	Line number	New contents of line
DieterGraef	0:f9b6112278fe	1	/*****************************************************************************
DieterGraef	0:f9b6112278fe	2	* lcp.c - Network Link Control Protocol program file.
DieterGraef	0:f9b6112278fe	3	*
DieterGraef	0:f9b6112278fe	4	* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.
DieterGraef	0:f9b6112278fe	5	* portions Copyright (c) 1997 by Global Election Systems Inc.
DieterGraef	0:f9b6112278fe	6	*
DieterGraef	0:f9b6112278fe	7	* The authors hereby grant permission to use, copy, modify, distribute,
DieterGraef	0:f9b6112278fe	8	* and license this software and its documentation for any purpose, provided
DieterGraef	0:f9b6112278fe	9	* that existing copyright notices are retained in all copies and that this
DieterGraef	0:f9b6112278fe	10	* notice and the following disclaimer are included verbatim in any
DieterGraef	0:f9b6112278fe	11	* distributions. No written agreement, license, or royalty fee is required
DieterGraef	0:f9b6112278fe	12	* for any of the authorized uses.
DieterGraef	0:f9b6112278fe	13	*
DieterGraef	0:f9b6112278fe	14	* THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS AS IS AND ANY EXPRESS OR
DieterGraef	0:f9b6112278fe	15	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
DieterGraef	0:f9b6112278fe	16	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
DieterGraef	0:f9b6112278fe	17	* IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
DieterGraef	0:f9b6112278fe	18	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
DieterGraef	0:f9b6112278fe	19	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DieterGraef	0:f9b6112278fe	20	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
DieterGraef	0:f9b6112278fe	21	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
DieterGraef	0:f9b6112278fe	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
DieterGraef	0:f9b6112278fe	23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
DieterGraef	0:f9b6112278fe	24	*
DieterGraef	0:f9b6112278fe	25	******************************************************************************
DieterGraef	0:f9b6112278fe	26	* REVISION HISTORY
DieterGraef	0:f9b6112278fe	27	*
DieterGraef	0:f9b6112278fe	28	* 03-01-01 Marc Boucher <marc@mbsi.ca>
DieterGraef	0:f9b6112278fe	29	* Ported to lwIP.
DieterGraef	0:f9b6112278fe	30	* 97-12-01 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
DieterGraef	0:f9b6112278fe	31	* Original.
DieterGraef	0:f9b6112278fe	32	*****************************************************************************/
DieterGraef	0:f9b6112278fe	33
DieterGraef	0:f9b6112278fe	34	/*
DieterGraef	0:f9b6112278fe	35	* lcp.c - PPP Link Control Protocol.
DieterGraef	0:f9b6112278fe	36	*
DieterGraef	0:f9b6112278fe	37	* Copyright (c) 1989 Carnegie Mellon University.
DieterGraef	0:f9b6112278fe	38	* All rights reserved.
DieterGraef	0:f9b6112278fe	39	*
DieterGraef	0:f9b6112278fe	40	* Redistribution and use in source and binary forms are permitted
DieterGraef	0:f9b6112278fe	41	* provided that the above copyright notice and this paragraph are
DieterGraef	0:f9b6112278fe	42	* duplicated in all such forms and that any documentation,
DieterGraef	0:f9b6112278fe	43	* advertising materials, and other materials related to such
DieterGraef	0:f9b6112278fe	44	* distribution and use acknowledge that the software was developed
DieterGraef	0:f9b6112278fe	45	* by Carnegie Mellon University. The name of the
DieterGraef	0:f9b6112278fe	46	* University may not be used to endorse or promote products derived
DieterGraef	0:f9b6112278fe	47	* from this software without specific prior written permission.
DieterGraef	0:f9b6112278fe	48	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
DieterGraef	0:f9b6112278fe	49	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
DieterGraef	0:f9b6112278fe	50	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
DieterGraef	0:f9b6112278fe	51	*/
DieterGraef	0:f9b6112278fe	52
DieterGraef	0:f9b6112278fe	53
DieterGraef	0:f9b6112278fe	54	#include "lwip/opt.h"
DieterGraef	0:f9b6112278fe	55
DieterGraef	0:f9b6112278fe	56	#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */
DieterGraef	0:f9b6112278fe	57
DieterGraef	0:f9b6112278fe	58	#include "ppp_impl.h"
DieterGraef	0:f9b6112278fe	59	#include "pppdebug.h"
DieterGraef	0:f9b6112278fe	60
DieterGraef	0:f9b6112278fe	61	#include "fsm.h"
DieterGraef	0:f9b6112278fe	62	#include "chap.h"
DieterGraef	0:f9b6112278fe	63	#include "magic.h"
DieterGraef	0:f9b6112278fe	64	#include "auth.h"
DieterGraef	0:f9b6112278fe	65	#include "lcp.h"
DieterGraef	0:f9b6112278fe	66
DieterGraef	0:f9b6112278fe	67	#include <string.h>
DieterGraef	0:f9b6112278fe	68
DieterGraef	0:f9b6112278fe	69	#if PPPOE_SUPPORT
DieterGraef	0:f9b6112278fe	70	#include "netif/ppp_oe.h"
DieterGraef	0:f9b6112278fe	71	#else
DieterGraef	0:f9b6112278fe	72	#define PPPOE_MAXMTU PPP_MAXMRU
DieterGraef	0:f9b6112278fe	73	#endif
DieterGraef	0:f9b6112278fe	74
DieterGraef	0:f9b6112278fe	75	#if 0 /* UNUSED */
DieterGraef	0:f9b6112278fe	76	/*
DieterGraef	0:f9b6112278fe	77	* LCP-related command-line options.
DieterGraef	0:f9b6112278fe	78	*/
DieterGraef	0:f9b6112278fe	79	int lcp_echo_interval = 0; /* Interval between LCP echo-requests */
DieterGraef	0:f9b6112278fe	80	int lcp_echo_fails = 0; /* Tolerance to unanswered echo-requests */
DieterGraef	0:f9b6112278fe	81	bool lax_recv = 0; /* accept control chars in asyncmap */
DieterGraef	0:f9b6112278fe	82
DieterGraef	0:f9b6112278fe	83	static int setescape (char **);
DieterGraef	0:f9b6112278fe	84
DieterGraef	0:f9b6112278fe	85	static option_t lcp_option_list[] = {
DieterGraef	0:f9b6112278fe	86	/* LCP options */
DieterGraef	0:f9b6112278fe	87	/* list stripped for simplicity */
DieterGraef	0:f9b6112278fe	88	{NULL}
DieterGraef	0:f9b6112278fe	89	};
DieterGraef	0:f9b6112278fe	90	#endif /* UNUSED */
DieterGraef	0:f9b6112278fe	91
DieterGraef	0:f9b6112278fe	92	/* options */
DieterGraef	0:f9b6112278fe	93	LinkPhase lcp_phase[NUM_PPP]; /* Phase of link session (RFC 1661) */
DieterGraef	0:f9b6112278fe	94	static u_int lcp_echo_interval = LCP_ECHOINTERVAL; /* Interval between LCP echo-requests */
DieterGraef	0:f9b6112278fe	95	static u_int lcp_echo_fails = LCP_MAXECHOFAILS; /* Tolerance to unanswered echo-requests */
DieterGraef	0:f9b6112278fe	96
DieterGraef	0:f9b6112278fe	97	/* global vars */
DieterGraef	0:f9b6112278fe	98	static fsm lcp_fsm[NUM_PPP]; /* LCP fsm structure (global)*/
DieterGraef	0:f9b6112278fe	99	lcp_options lcp_wantoptions[NUM_PPP]; /* Options that we want to request */
DieterGraef	0:f9b6112278fe	100	lcp_options lcp_gotoptions[NUM_PPP]; /* Options that peer ack'd */
DieterGraef	0:f9b6112278fe	101	lcp_options lcp_allowoptions[NUM_PPP]; /* Options we allow peer to request */
DieterGraef	0:f9b6112278fe	102	lcp_options lcp_hisoptions[NUM_PPP]; /* Options that we ack'd */
DieterGraef	0:f9b6112278fe	103	ext_accm xmit_accm[NUM_PPP]; /* extended transmit ACCM */
DieterGraef	0:f9b6112278fe	104
DieterGraef	0:f9b6112278fe	105	static u32_t lcp_echos_pending = 0; /* Number of outstanding echo msgs */
DieterGraef	0:f9b6112278fe	106	static u32_t lcp_echo_number = 0; /* ID number of next echo frame */
DieterGraef	0:f9b6112278fe	107	static u32_t lcp_echo_timer_running = 0; /* TRUE if a timer is running */
DieterGraef	0:f9b6112278fe	108
DieterGraef	0:f9b6112278fe	109	/* @todo: do we really need such a large buffer? The typical 1500 bytes seem too much. */
DieterGraef	0:f9b6112278fe	110	static u_char nak_buffer[PPP_MRU]; /* where we construct a nak packet */
DieterGraef	0:f9b6112278fe	111
DieterGraef	0:f9b6112278fe	112	/*
DieterGraef	0:f9b6112278fe	113	* Callbacks for fsm code. (CI = Configuration Information)
DieterGraef	0:f9b6112278fe	114	*/
DieterGraef	0:f9b6112278fe	115	static void lcp_resetci (fsm); / Reset our CI */
DieterGraef	0:f9b6112278fe	116	static int lcp_cilen (fsm); / Return length of our CI */
DieterGraef	0:f9b6112278fe	117	static void lcp_addci (fsm, u_char, int); / Add our CI to pkt */
DieterGraef	0:f9b6112278fe	118	static int lcp_ackci (fsm, u_char, int); /* Peer ack'd our CI */
DieterGraef	0:f9b6112278fe	119	static int lcp_nakci (fsm, u_char, int); /* Peer nak'd our CI */
DieterGraef	0:f9b6112278fe	120	static int lcp_rejci (fsm, u_char, int); /* Peer rej'd our CI */
DieterGraef	0:f9b6112278fe	121	static int lcp_reqci (fsm, u_char, int, int); / Rcv peer CI */
DieterGraef	0:f9b6112278fe	122	static void lcp_up (fsm); / We're UP */
DieterGraef	0:f9b6112278fe	123	static void lcp_down (fsm); / We're DOWN */
DieterGraef	0:f9b6112278fe	124	static void lcp_starting (fsm); / We need lower layer up */
DieterGraef	0:f9b6112278fe	125	static void lcp_finished (fsm); / We need lower layer down */
DieterGraef	0:f9b6112278fe	126	static int lcp_extcode (fsm, int, u_char, u_char, int);
DieterGraef	0:f9b6112278fe	127	static void lcp_rprotrej (fsm, u_char, int);
DieterGraef	0:f9b6112278fe	128
DieterGraef	0:f9b6112278fe	129	/*
DieterGraef	0:f9b6112278fe	130	* routines to send LCP echos to peer
DieterGraef	0:f9b6112278fe	131	*/
DieterGraef	0:f9b6112278fe	132
DieterGraef	0:f9b6112278fe	133	static void lcp_echo_lowerup (int);
DieterGraef	0:f9b6112278fe	134	static void lcp_echo_lowerdown (int);
DieterGraef	0:f9b6112278fe	135	static void LcpEchoTimeout (void*);
DieterGraef	0:f9b6112278fe	136	static void lcp_received_echo_reply (fsm, int, u_char, int);
DieterGraef	0:f9b6112278fe	137	static void LcpSendEchoRequest (fsm*);
DieterGraef	0:f9b6112278fe	138	static void LcpLinkFailure (fsm*);
DieterGraef	0:f9b6112278fe	139	static void LcpEchoCheck (fsm*);
DieterGraef	0:f9b6112278fe	140
DieterGraef	0:f9b6112278fe	141	static fsm_callbacks lcp_callbacks = { /* LCP callback routines */
DieterGraef	0:f9b6112278fe	142	lcp_resetci, /* Reset our Configuration Information */
DieterGraef	0:f9b6112278fe	143	lcp_cilen, /* Length of our Configuration Information */
DieterGraef	0:f9b6112278fe	144	lcp_addci, /* Add our Configuration Information */
DieterGraef	0:f9b6112278fe	145	lcp_ackci, /* ACK our Configuration Information */
DieterGraef	0:f9b6112278fe	146	lcp_nakci, /* NAK our Configuration Information */
DieterGraef	0:f9b6112278fe	147	lcp_rejci, /* Reject our Configuration Information */
DieterGraef	0:f9b6112278fe	148	lcp_reqci, /* Request peer's Configuration Information */
DieterGraef	0:f9b6112278fe	149	lcp_up, /* Called when fsm reaches LS_OPENED state */
DieterGraef	0:f9b6112278fe	150	lcp_down, /* Called when fsm leaves LS_OPENED state */
DieterGraef	0:f9b6112278fe	151	lcp_starting, /* Called when we want the lower layer up */
DieterGraef	0:f9b6112278fe	152	lcp_finished, /* Called when we want the lower layer down */
DieterGraef	0:f9b6112278fe	153	NULL, /* Called when Protocol-Reject received */
DieterGraef	0:f9b6112278fe	154	NULL, /* Retransmission is necessary */
DieterGraef	0:f9b6112278fe	155	lcp_extcode, /* Called to handle LCP-specific codes */
DieterGraef	0:f9b6112278fe	156	"LCP" /* String name of protocol */
DieterGraef	0:f9b6112278fe	157	};
DieterGraef	0:f9b6112278fe	158
DieterGraef	0:f9b6112278fe	159	/*
DieterGraef	0:f9b6112278fe	160	* Protocol entry points.
DieterGraef	0:f9b6112278fe	161	* Some of these are called directly.
DieterGraef	0:f9b6112278fe	162	*/
DieterGraef	0:f9b6112278fe	163
DieterGraef	0:f9b6112278fe	164	static void lcp_input (int, u_char *, int);
DieterGraef	0:f9b6112278fe	165	static void lcp_protrej (int);
DieterGraef	0:f9b6112278fe	166
DieterGraef	0:f9b6112278fe	167	struct protent lcp_protent = {
DieterGraef	0:f9b6112278fe	168	PPP_LCP,
DieterGraef	0:f9b6112278fe	169	lcp_init,
DieterGraef	0:f9b6112278fe	170	lcp_input,
DieterGraef	0:f9b6112278fe	171	lcp_protrej,
DieterGraef	0:f9b6112278fe	172	lcp_lowerup,
DieterGraef	0:f9b6112278fe	173	lcp_lowerdown,
DieterGraef	0:f9b6112278fe	174	lcp_open,
DieterGraef	0:f9b6112278fe	175	lcp_close,
DieterGraef	0:f9b6112278fe	176	#if PPP_ADDITIONAL_CALLBACKS
DieterGraef	0:f9b6112278fe	177	lcp_printpkt,
DieterGraef	0:f9b6112278fe	178	NULL,
DieterGraef	0:f9b6112278fe	179	#endif /* PPP_ADDITIONAL_CALLBACKS */
DieterGraef	0:f9b6112278fe	180	1,
DieterGraef	0:f9b6112278fe	181	"LCP",
DieterGraef	0:f9b6112278fe	182	#if PPP_ADDITIONAL_CALLBACKS
DieterGraef	0:f9b6112278fe	183	NULL,
DieterGraef	0:f9b6112278fe	184	NULL,
DieterGraef	0:f9b6112278fe	185	NULL
DieterGraef	0:f9b6112278fe	186	#endif /* PPP_ADDITIONAL_CALLBACKS */
DieterGraef	0:f9b6112278fe	187	};
DieterGraef	0:f9b6112278fe	188
DieterGraef	0:f9b6112278fe	189	int lcp_loopbackfail = DEFLOOPBACKFAIL;
DieterGraef	0:f9b6112278fe	190
DieterGraef	0:f9b6112278fe	191	/*
DieterGraef	0:f9b6112278fe	192	* Length of each type of configuration option (in octets)
DieterGraef	0:f9b6112278fe	193	*/
DieterGraef	0:f9b6112278fe	194	#define CILEN_VOID 2
DieterGraef	0:f9b6112278fe	195	#define CILEN_CHAR 3
DieterGraef	0:f9b6112278fe	196	#define CILEN_SHORT 4 /* CILEN_VOID + sizeof(short) */
DieterGraef	0:f9b6112278fe	197	#define CILEN_CHAP 5 /* CILEN_VOID + sizeof(short) + 1 */
DieterGraef	0:f9b6112278fe	198	#define CILEN_LONG 6 /* CILEN_VOID + sizeof(long) */
DieterGraef	0:f9b6112278fe	199	#define CILEN_LQR 8 /* CILEN_VOID + sizeof(short) + sizeof(long) */
DieterGraef	0:f9b6112278fe	200	#define CILEN_CBCP 3
DieterGraef	0:f9b6112278fe	201
DieterGraef	0:f9b6112278fe	202	#define CODENAME(x) ((x) == CONFACK ? "ACK" : (x) == CONFNAK ? "NAK" : "REJ")
DieterGraef	0:f9b6112278fe	203
DieterGraef	0:f9b6112278fe	204	#if 0 /* UNUSED */
DieterGraef	0:f9b6112278fe	205	/*
DieterGraef	0:f9b6112278fe	206	* setescape - add chars to the set we escape on transmission.
DieterGraef	0:f9b6112278fe	207	*/
DieterGraef	0:f9b6112278fe	208	static int
DieterGraef	0:f9b6112278fe	209	setescape(argv)
DieterGraef	0:f9b6112278fe	210	char **argv;
DieterGraef	0:f9b6112278fe	211	{
DieterGraef	0:f9b6112278fe	212	int n, ret;
DieterGraef	0:f9b6112278fe	213	char p, endp;
DieterGraef	0:f9b6112278fe	214
DieterGraef	0:f9b6112278fe	215	p = *argv;
DieterGraef	0:f9b6112278fe	216	ret = 1;
DieterGraef	0:f9b6112278fe	217	while (*p) {
DieterGraef	0:f9b6112278fe	218	n = strtol(p, &endp, 16);
DieterGraef	0:f9b6112278fe	219	if (p == endp) {
DieterGraef	0:f9b6112278fe	220	option_error("escape parameter contains invalid hex number '%s'", p);
DieterGraef	0:f9b6112278fe	221	return 0;
DieterGraef	0:f9b6112278fe	222	}
DieterGraef	0:f9b6112278fe	223	p = endp;
DieterGraef	0:f9b6112278fe	224	if (n < 0 \|\| n == 0x5E \|\| n > 0xFF) {
DieterGraef	0:f9b6112278fe	225	option_error("can't escape character 0x%x", n);
DieterGraef	0:f9b6112278fe	226	ret = 0;
DieterGraef	0:f9b6112278fe	227	} else
DieterGraef	0:f9b6112278fe	228	xmit_accm[0][n >> 5] \|= 1 << (n & 0x1F);
DieterGraef	0:f9b6112278fe	229	while (p == ',' \|\| p == ' ')
DieterGraef	0:f9b6112278fe	230	++p;
DieterGraef	0:f9b6112278fe	231	}
DieterGraef	0:f9b6112278fe	232	return ret;
DieterGraef	0:f9b6112278fe	233	}
DieterGraef	0:f9b6112278fe	234	#endif /* UNUSED */
DieterGraef	0:f9b6112278fe	235
DieterGraef	0:f9b6112278fe	236	/*
DieterGraef	0:f9b6112278fe	237	* lcp_init - Initialize LCP.
DieterGraef	0:f9b6112278fe	238	*/
DieterGraef	0:f9b6112278fe	239	void
DieterGraef	0:f9b6112278fe	240	lcp_init(int unit)
DieterGraef	0:f9b6112278fe	241	{
DieterGraef	0:f9b6112278fe	242	fsm *f = &lcp_fsm[unit];
DieterGraef	0:f9b6112278fe	243	lcp_options *wo = &lcp_wantoptions[unit];
DieterGraef	0:f9b6112278fe	244	lcp_options *ao = &lcp_allowoptions[unit];
DieterGraef	0:f9b6112278fe	245
DieterGraef	0:f9b6112278fe	246	f->unit = unit;
DieterGraef	0:f9b6112278fe	247	f->protocol = PPP_LCP;
DieterGraef	0:f9b6112278fe	248	f->callbacks = &lcp_callbacks;
DieterGraef	0:f9b6112278fe	249
DieterGraef	0:f9b6112278fe	250	fsm_init(f);
DieterGraef	0:f9b6112278fe	251
DieterGraef	0:f9b6112278fe	252	wo->passive = 0;
DieterGraef	0:f9b6112278fe	253	wo->silent = 0;
DieterGraef	0:f9b6112278fe	254	wo->restart = 0; /* Set to 1 in kernels or multi-line implementations */
DieterGraef	0:f9b6112278fe	255	wo->neg_mru = 1;
DieterGraef	0:f9b6112278fe	256	wo->mru = PPP_DEFMRU;
DieterGraef	0:f9b6112278fe	257	wo->neg_asyncmap = 1;
DieterGraef	0:f9b6112278fe	258	wo->asyncmap = 0x00000000l; /* Assume don't need to escape any ctl chars. */
DieterGraef	0:f9b6112278fe	259	wo->neg_chap = 0; /* Set to 1 on server */
DieterGraef	0:f9b6112278fe	260	wo->neg_upap = 0; /* Set to 1 on server */
DieterGraef	0:f9b6112278fe	261	wo->chap_mdtype = CHAP_DIGEST_MD5;
DieterGraef	0:f9b6112278fe	262	wo->neg_magicnumber = 1;
DieterGraef	0:f9b6112278fe	263	wo->neg_pcompression = 1;
DieterGraef	0:f9b6112278fe	264	wo->neg_accompression = 1;
DieterGraef	0:f9b6112278fe	265	wo->neg_lqr = 0; /* no LQR implementation yet */
DieterGraef	0:f9b6112278fe	266	wo->neg_cbcp = 0;
DieterGraef	0:f9b6112278fe	267
DieterGraef	0:f9b6112278fe	268	ao->neg_mru = 1;
DieterGraef	0:f9b6112278fe	269	ao->mru = PPP_MAXMRU;
DieterGraef	0:f9b6112278fe	270	ao->neg_asyncmap = 1;
DieterGraef	0:f9b6112278fe	271	ao->asyncmap = 0x00000000l; /* Assume don't need to escape any ctl chars. */
DieterGraef	0:f9b6112278fe	272	ao->neg_chap = (CHAP_SUPPORT != 0);
DieterGraef	0:f9b6112278fe	273	ao->chap_mdtype = CHAP_DIGEST_MD5;
DieterGraef	0:f9b6112278fe	274	ao->neg_upap = (PAP_SUPPORT != 0);
DieterGraef	0:f9b6112278fe	275	ao->neg_magicnumber = 1;
DieterGraef	0:f9b6112278fe	276	ao->neg_pcompression = 1;
DieterGraef	0:f9b6112278fe	277	ao->neg_accompression = 1;
DieterGraef	0:f9b6112278fe	278	ao->neg_lqr = 0; /* no LQR implementation yet */
DieterGraef	0:f9b6112278fe	279	ao->neg_cbcp = (CBCP_SUPPORT != 0);
DieterGraef	0:f9b6112278fe	280
DieterGraef	0:f9b6112278fe	281	/*
DieterGraef	0:f9b6112278fe	282	* Set transmit escape for the flag and escape characters plus anything
DieterGraef	0:f9b6112278fe	283	* set for the allowable options.
DieterGraef	0:f9b6112278fe	284	*/
DieterGraef	0:f9b6112278fe	285	memset(xmit_accm[unit], 0, sizeof(xmit_accm[0]));
DieterGraef	0:f9b6112278fe	286	xmit_accm[unit][15] = 0x60;
DieterGraef	0:f9b6112278fe	287	xmit_accm[unit][0] = (u_char)((ao->asyncmap & 0xFF));
DieterGraef	0:f9b6112278fe	288	xmit_accm[unit][1] = (u_char)((ao->asyncmap >> 8) & 0xFF);
DieterGraef	0:f9b6112278fe	289	xmit_accm[unit][2] = (u_char)((ao->asyncmap >> 16) & 0xFF);
DieterGraef	0:f9b6112278fe	290	xmit_accm[unit][3] = (u_char)((ao->asyncmap >> 24) & 0xFF);
DieterGraef	0:f9b6112278fe	291	LCPDEBUG(LOG_INFO, ("lcp_init: xmit_accm=%X %X %X %X\n",
DieterGraef	0:f9b6112278fe	292	xmit_accm[unit][0],
DieterGraef	0:f9b6112278fe	293	xmit_accm[unit][1],
DieterGraef	0:f9b6112278fe	294	xmit_accm[unit][2],
DieterGraef	0:f9b6112278fe	295	xmit_accm[unit][3]));
DieterGraef	0:f9b6112278fe	296
DieterGraef	0:f9b6112278fe	297	lcp_phase[unit] = PHASE_INITIALIZE;
DieterGraef	0:f9b6112278fe	298	}
DieterGraef	0:f9b6112278fe	299
DieterGraef	0:f9b6112278fe	300
DieterGraef	0:f9b6112278fe	301	/*
DieterGraef	0:f9b6112278fe	302	* lcp_open - LCP is allowed to come up.
DieterGraef	0:f9b6112278fe	303	*/
DieterGraef	0:f9b6112278fe	304	void
DieterGraef	0:f9b6112278fe	305	lcp_open(int unit)
DieterGraef	0:f9b6112278fe	306	{
DieterGraef	0:f9b6112278fe	307	fsm *f = &lcp_fsm[unit];
DieterGraef	0:f9b6112278fe	308	lcp_options *wo = &lcp_wantoptions[unit];
DieterGraef	0:f9b6112278fe	309
DieterGraef	0:f9b6112278fe	310	f->flags = 0;
DieterGraef	0:f9b6112278fe	311	if (wo->passive) {
DieterGraef	0:f9b6112278fe	312	f->flags \|= OPT_PASSIVE;
DieterGraef	0:f9b6112278fe	313	}
DieterGraef	0:f9b6112278fe	314	if (wo->silent) {
DieterGraef	0:f9b6112278fe	315	f->flags \|= OPT_SILENT;
DieterGraef	0:f9b6112278fe	316	}
DieterGraef	0:f9b6112278fe	317	fsm_open(f);
DieterGraef	0:f9b6112278fe	318
DieterGraef	0:f9b6112278fe	319	lcp_phase[unit] = PHASE_ESTABLISH;
DieterGraef	0:f9b6112278fe	320	}
DieterGraef	0:f9b6112278fe	321
DieterGraef	0:f9b6112278fe	322
DieterGraef	0:f9b6112278fe	323	/*
DieterGraef	0:f9b6112278fe	324	* lcp_close - Take LCP down.
DieterGraef	0:f9b6112278fe	325	*/
DieterGraef	0:f9b6112278fe	326	void
DieterGraef	0:f9b6112278fe	327	lcp_close(int unit, char *reason)
DieterGraef	0:f9b6112278fe	328	{
DieterGraef	0:f9b6112278fe	329	fsm *f = &lcp_fsm[unit];
DieterGraef	0:f9b6112278fe	330
DieterGraef	0:f9b6112278fe	331	if (lcp_phase[unit] != PHASE_DEAD) {
DieterGraef	0:f9b6112278fe	332	lcp_phase[unit] = PHASE_TERMINATE;
DieterGraef	0:f9b6112278fe	333	}
DieterGraef	0:f9b6112278fe	334	if (f->state == LS_STOPPED && f->flags & (OPT_PASSIVE\|OPT_SILENT)) {
DieterGraef	0:f9b6112278fe	335	/*
DieterGraef	0:f9b6112278fe	336	* This action is not strictly according to the FSM in RFC1548,
DieterGraef	0:f9b6112278fe	337	* but it does mean that the program terminates if you do an
DieterGraef	0:f9b6112278fe	338	* lcp_close() in passive/silent mode when a connection hasn't
DieterGraef	0:f9b6112278fe	339	* been established.
DieterGraef	0:f9b6112278fe	340	*/
DieterGraef	0:f9b6112278fe	341	f->state = LS_CLOSED;
DieterGraef	0:f9b6112278fe	342	lcp_finished(f);
DieterGraef	0:f9b6112278fe	343	} else {
DieterGraef	0:f9b6112278fe	344	fsm_close(f, reason);
DieterGraef	0:f9b6112278fe	345	}
DieterGraef	0:f9b6112278fe	346	}
DieterGraef	0:f9b6112278fe	347
DieterGraef	0:f9b6112278fe	348
DieterGraef	0:f9b6112278fe	349	/*
DieterGraef	0:f9b6112278fe	350	* lcp_lowerup - The lower layer is up.
DieterGraef	0:f9b6112278fe	351	*/
DieterGraef	0:f9b6112278fe	352	void
DieterGraef	0:f9b6112278fe	353	lcp_lowerup(int unit)
DieterGraef	0:f9b6112278fe	354	{
DieterGraef	0:f9b6112278fe	355	lcp_options *wo = &lcp_wantoptions[unit];
DieterGraef	0:f9b6112278fe	356
DieterGraef	0:f9b6112278fe	357	/*
DieterGraef	0:f9b6112278fe	358	* Don't use A/C or protocol compression on transmission,
DieterGraef	0:f9b6112278fe	359	* but accept A/C and protocol compressed packets
DieterGraef	0:f9b6112278fe	360	* if we are going to ask for A/C and protocol compression.
DieterGraef	0:f9b6112278fe	361	*/
DieterGraef	0:f9b6112278fe	362	ppp_set_xaccm(unit, &xmit_accm[unit]);
DieterGraef	0:f9b6112278fe	363	ppp_send_config(unit, PPP_MRU, 0xffffffffl, 0, 0);
DieterGraef	0:f9b6112278fe	364	ppp_recv_config(unit, PPP_MRU, 0x00000000l,
DieterGraef	0:f9b6112278fe	365	wo->neg_pcompression, wo->neg_accompression);
DieterGraef	0:f9b6112278fe	366	peer_mru[unit] = PPP_MRU;
DieterGraef	0:f9b6112278fe	367	lcp_allowoptions[unit].asyncmap = (u_long)xmit_accm[unit][0]
DieterGraef	0:f9b6112278fe	368	\| ((u_long)xmit_accm[unit][1] << 8)
DieterGraef	0:f9b6112278fe	369	\| ((u_long)xmit_accm[unit][2] << 16)
DieterGraef	0:f9b6112278fe	370	\| ((u_long)xmit_accm[unit][3] << 24);
DieterGraef	0:f9b6112278fe	371	LCPDEBUG(LOG_INFO, ("lcp_lowerup: asyncmap=%X %X %X %X\n",
DieterGraef	0:f9b6112278fe	372	xmit_accm[unit][3],
DieterGraef	0:f9b6112278fe	373	xmit_accm[unit][2],
DieterGraef	0:f9b6112278fe	374	xmit_accm[unit][1],
DieterGraef	0:f9b6112278fe	375	xmit_accm[unit][0]));
DieterGraef	0:f9b6112278fe	376
DieterGraef	0:f9b6112278fe	377	fsm_lowerup(&lcp_fsm[unit]);
DieterGraef	0:f9b6112278fe	378	}
DieterGraef	0:f9b6112278fe	379
DieterGraef	0:f9b6112278fe	380
DieterGraef	0:f9b6112278fe	381	/*
DieterGraef	0:f9b6112278fe	382	* lcp_lowerdown - The lower layer is down.
DieterGraef	0:f9b6112278fe	383	*/
DieterGraef	0:f9b6112278fe	384	void
DieterGraef	0:f9b6112278fe	385	lcp_lowerdown(int unit)
DieterGraef	0:f9b6112278fe	386	{
DieterGraef	0:f9b6112278fe	387	fsm_lowerdown(&lcp_fsm[unit]);
DieterGraef	0:f9b6112278fe	388	}
DieterGraef	0:f9b6112278fe	389
DieterGraef	0:f9b6112278fe	390
DieterGraef	0:f9b6112278fe	391	/*
DieterGraef	0:f9b6112278fe	392	* lcp_input - Input LCP packet.
DieterGraef	0:f9b6112278fe	393	*/
DieterGraef	0:f9b6112278fe	394	static void
DieterGraef	0:f9b6112278fe	395	lcp_input(int unit, u_char *p, int len)
DieterGraef	0:f9b6112278fe	396	{
DieterGraef	0:f9b6112278fe	397	fsm *f = &lcp_fsm[unit];
DieterGraef	0:f9b6112278fe	398
DieterGraef	0:f9b6112278fe	399	fsm_input(f, p, len);
DieterGraef	0:f9b6112278fe	400	}
DieterGraef	0:f9b6112278fe	401
DieterGraef	0:f9b6112278fe	402
DieterGraef	0:f9b6112278fe	403	/*
DieterGraef	0:f9b6112278fe	404	* lcp_extcode - Handle a LCP-specific code.
DieterGraef	0:f9b6112278fe	405	*/
DieterGraef	0:f9b6112278fe	406	static int
DieterGraef	0:f9b6112278fe	407	lcp_extcode(fsm f, int code, u_char id, u_char inp, int len)
DieterGraef	0:f9b6112278fe	408	{
DieterGraef	0:f9b6112278fe	409	u_char *magp;
DieterGraef	0:f9b6112278fe	410
DieterGraef	0:f9b6112278fe	411	switch( code ){
DieterGraef	0:f9b6112278fe	412	case PROTREJ:
DieterGraef	0:f9b6112278fe	413	lcp_rprotrej(f, inp, len);
DieterGraef	0:f9b6112278fe	414	break;
DieterGraef	0:f9b6112278fe	415
DieterGraef	0:f9b6112278fe	416	case ECHOREQ:
DieterGraef	0:f9b6112278fe	417	if (f->state != LS_OPENED) {
DieterGraef	0:f9b6112278fe	418	break;
DieterGraef	0:f9b6112278fe	419	}
DieterGraef	0:f9b6112278fe	420	LCPDEBUG(LOG_INFO, ("lcp: Echo-Request, Rcvd id %d\n", id));
DieterGraef	0:f9b6112278fe	421	magp = inp;
DieterGraef	0:f9b6112278fe	422	PUTLONG(lcp_gotoptions[f->unit].magicnumber, magp);
DieterGraef	0:f9b6112278fe	423	fsm_sdata(f, ECHOREP, id, inp, len);
DieterGraef	0:f9b6112278fe	424	break;
DieterGraef	0:f9b6112278fe	425
DieterGraef	0:f9b6112278fe	426	case ECHOREP:
DieterGraef	0:f9b6112278fe	427	lcp_received_echo_reply(f, id, inp, len);
DieterGraef	0:f9b6112278fe	428	break;
DieterGraef	0:f9b6112278fe	429
DieterGraef	0:f9b6112278fe	430	case DISCREQ:
DieterGraef	0:f9b6112278fe	431	break;
DieterGraef	0:f9b6112278fe	432
DieterGraef	0:f9b6112278fe	433	default:
DieterGraef	0:f9b6112278fe	434	return 0;
DieterGraef	0:f9b6112278fe	435	}
DieterGraef	0:f9b6112278fe	436	return 1;
DieterGraef	0:f9b6112278fe	437	}
DieterGraef	0:f9b6112278fe	438
DieterGraef	0:f9b6112278fe	439
DieterGraef	0:f9b6112278fe	440	/*
DieterGraef	0:f9b6112278fe	441	* lcp_rprotrej - Receive an Protocol-Reject.
DieterGraef	0:f9b6112278fe	442	*
DieterGraef	0:f9b6112278fe	443	* Figure out which protocol is rejected and inform it.
DieterGraef	0:f9b6112278fe	444	*/
DieterGraef	0:f9b6112278fe	445	static void
DieterGraef	0:f9b6112278fe	446	lcp_rprotrej(fsm f, u_char inp, int len)
DieterGraef	0:f9b6112278fe	447	{
DieterGraef	0:f9b6112278fe	448	int i;
DieterGraef	0:f9b6112278fe	449	struct protent *protp;
DieterGraef	0:f9b6112278fe	450	u_short prot;
DieterGraef	0:f9b6112278fe	451
DieterGraef	0:f9b6112278fe	452	if (len < (int)sizeof (u_short)) {
DieterGraef	0:f9b6112278fe	453	LCPDEBUG(LOG_INFO, ("lcp_rprotrej: Rcvd short Protocol-Reject packet!\n"));
DieterGraef	0:f9b6112278fe	454	return;
DieterGraef	0:f9b6112278fe	455	}
DieterGraef	0:f9b6112278fe	456
DieterGraef	0:f9b6112278fe	457	GETSHORT(prot, inp);
DieterGraef	0:f9b6112278fe	458
DieterGraef	0:f9b6112278fe	459	LCPDEBUG(LOG_INFO, ("lcp_rprotrej: Rcvd Protocol-Reject packet for %x!\n", prot));
DieterGraef	0:f9b6112278fe	460
DieterGraef	0:f9b6112278fe	461	/*
DieterGraef	0:f9b6112278fe	462	* Protocol-Reject packets received in any state other than the LCP
DieterGraef	0:f9b6112278fe	463	* LS_OPENED state SHOULD be silently discarded.
DieterGraef	0:f9b6112278fe	464	*/
DieterGraef	0:f9b6112278fe	465	if( f->state != LS_OPENED ) {
DieterGraef	0:f9b6112278fe	466	LCPDEBUG(LOG_INFO, ("Protocol-Reject discarded: LCP in state %d\n", f->state));
DieterGraef	0:f9b6112278fe	467	return;
DieterGraef	0:f9b6112278fe	468	}
DieterGraef	0:f9b6112278fe	469
DieterGraef	0:f9b6112278fe	470	/*
DieterGraef	0:f9b6112278fe	471	* Upcall the proper Protocol-Reject routine.
DieterGraef	0:f9b6112278fe	472	*/
DieterGraef	0:f9b6112278fe	473	for (i = 0; (protp = ppp_protocols[i]) != NULL; ++i) {
DieterGraef	0:f9b6112278fe	474	if (protp->protocol == prot && protp->enabled_flag) {
DieterGraef	0:f9b6112278fe	475	(*protp->protrej)(f->unit);
DieterGraef	0:f9b6112278fe	476	return;
DieterGraef	0:f9b6112278fe	477	}
DieterGraef	0:f9b6112278fe	478	}
DieterGraef	0:f9b6112278fe	479
DieterGraef	0:f9b6112278fe	480	LCPDEBUG(LOG_WARNING, ("Protocol-Reject for unsupported protocol 0x%x\n", prot));
DieterGraef	0:f9b6112278fe	481	}
DieterGraef	0:f9b6112278fe	482
DieterGraef	0:f9b6112278fe	483
DieterGraef	0:f9b6112278fe	484	/*
DieterGraef	0:f9b6112278fe	485	* lcp_protrej - A Protocol-Reject was received.
DieterGraef	0:f9b6112278fe	486	*/
DieterGraef	0:f9b6112278fe	487	static void
DieterGraef	0:f9b6112278fe	488	lcp_protrej(int unit)
DieterGraef	0:f9b6112278fe	489	{
DieterGraef	0:f9b6112278fe	490	LWIP_UNUSED_ARG(unit);
DieterGraef	0:f9b6112278fe	491	/*
DieterGraef	0:f9b6112278fe	492	* Can't reject LCP!
DieterGraef	0:f9b6112278fe	493	*/
DieterGraef	0:f9b6112278fe	494	LCPDEBUG(LOG_WARNING, ("lcp_protrej: Received Protocol-Reject for LCP!\n"));
DieterGraef	0:f9b6112278fe	495	fsm_protreject(&lcp_fsm[unit]);
DieterGraef	0:f9b6112278fe	496	}
DieterGraef	0:f9b6112278fe	497
DieterGraef	0:f9b6112278fe	498
DieterGraef	0:f9b6112278fe	499	/*
DieterGraef	0:f9b6112278fe	500	* lcp_sprotrej - Send a Protocol-Reject for some protocol.
DieterGraef	0:f9b6112278fe	501	*/
DieterGraef	0:f9b6112278fe	502	void
DieterGraef	0:f9b6112278fe	503	lcp_sprotrej(int unit, u_char *p, int len)
DieterGraef	0:f9b6112278fe	504	{
DieterGraef	0:f9b6112278fe	505	/*
DieterGraef	0:f9b6112278fe	506	* Send back the protocol and the information field of the
DieterGraef	0:f9b6112278fe	507	* rejected packet. We only get here if LCP is in the LS_OPENED state.
DieterGraef	0:f9b6112278fe	508	*/
DieterGraef	0:f9b6112278fe	509
DieterGraef	0:f9b6112278fe	510	fsm_sdata(&lcp_fsm[unit], PROTREJ, ++lcp_fsm[unit].id, p, len);
DieterGraef	0:f9b6112278fe	511	}
DieterGraef	0:f9b6112278fe	512
DieterGraef	0:f9b6112278fe	513
DieterGraef	0:f9b6112278fe	514	/*
DieterGraef	0:f9b6112278fe	515	* lcp_resetci - Reset our CI.
DieterGraef	0:f9b6112278fe	516	*/
DieterGraef	0:f9b6112278fe	517	static void
DieterGraef	0:f9b6112278fe	518	lcp_resetci(fsm *f)
DieterGraef	0:f9b6112278fe	519	{
DieterGraef	0:f9b6112278fe	520	lcp_wantoptions[f->unit].magicnumber = magic();
DieterGraef	0:f9b6112278fe	521	lcp_wantoptions[f->unit].numloops = 0;
DieterGraef	0:f9b6112278fe	522	lcp_gotoptions[f->unit] = lcp_wantoptions[f->unit];
DieterGraef	0:f9b6112278fe	523	peer_mru[f->unit] = PPP_MRU;
DieterGraef	0:f9b6112278fe	524	auth_reset(f->unit);
DieterGraef	0:f9b6112278fe	525	}
DieterGraef	0:f9b6112278fe	526
DieterGraef	0:f9b6112278fe	527
DieterGraef	0:f9b6112278fe	528	/*
DieterGraef	0:f9b6112278fe	529	* lcp_cilen - Return length of our CI.
DieterGraef	0:f9b6112278fe	530	*/
DieterGraef	0:f9b6112278fe	531	static int
DieterGraef	0:f9b6112278fe	532	lcp_cilen(fsm *f)
DieterGraef	0:f9b6112278fe	533	{
DieterGraef	0:f9b6112278fe	534	lcp_options *go = &lcp_gotoptions[f->unit];
DieterGraef	0:f9b6112278fe	535
DieterGraef	0:f9b6112278fe	536	#define LENCIVOID(neg) ((neg) ? CILEN_VOID : 0)
DieterGraef	0:f9b6112278fe	537	#define LENCICHAP(neg) ((neg) ? CILEN_CHAP : 0)
DieterGraef	0:f9b6112278fe	538	#define LENCISHORT(neg) ((neg) ? CILEN_SHORT : 0)
DieterGraef	0:f9b6112278fe	539	#define LENCILONG(neg) ((neg) ? CILEN_LONG : 0)
DieterGraef	0:f9b6112278fe	540	#define LENCILQR(neg) ((neg) ? CILEN_LQR: 0)
DieterGraef	0:f9b6112278fe	541	#define LENCICBCP(neg) ((neg) ? CILEN_CBCP: 0)
DieterGraef	0:f9b6112278fe	542	/*
DieterGraef	0:f9b6112278fe	543	* NB: we only ask for one of CHAP and UPAP, even if we will
DieterGraef	0:f9b6112278fe	544	* accept either.
DieterGraef	0:f9b6112278fe	545	*/
DieterGraef	0:f9b6112278fe	546	return (LENCISHORT(go->neg_mru && go->mru != PPP_DEFMRU) +
DieterGraef	0:f9b6112278fe	547	LENCILONG(go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl) +
DieterGraef	0:f9b6112278fe	548	LENCICHAP(go->neg_chap) +
DieterGraef	0:f9b6112278fe	549	LENCISHORT(!go->neg_chap && go->neg_upap) +
DieterGraef	0:f9b6112278fe	550	LENCILQR(go->neg_lqr) +
DieterGraef	0:f9b6112278fe	551	LENCICBCP(go->neg_cbcp) +
DieterGraef	0:f9b6112278fe	552	LENCILONG(go->neg_magicnumber) +
DieterGraef	0:f9b6112278fe	553	LENCIVOID(go->neg_pcompression) +
DieterGraef	0:f9b6112278fe	554	LENCIVOID(go->neg_accompression));
DieterGraef	0:f9b6112278fe	555	}
DieterGraef	0:f9b6112278fe	556
DieterGraef	0:f9b6112278fe	557
DieterGraef	0:f9b6112278fe	558	/*
DieterGraef	0:f9b6112278fe	559	* lcp_addci - Add our desired CIs to a packet.
DieterGraef	0:f9b6112278fe	560	*/
DieterGraef	0:f9b6112278fe	561	static void
DieterGraef	0:f9b6112278fe	562	lcp_addci(fsm f, u_char ucp, int *lenp)
DieterGraef	0:f9b6112278fe	563	{
DieterGraef	0:f9b6112278fe	564	lcp_options *go = &lcp_gotoptions[f->unit];
DieterGraef	0:f9b6112278fe	565	u_char *start_ucp = ucp;
DieterGraef	0:f9b6112278fe	566
DieterGraef	0:f9b6112278fe	567	#define ADDCIVOID(opt, neg) \
DieterGraef	0:f9b6112278fe	568	if (neg) { \
DieterGraef	0:f9b6112278fe	569	LCPDEBUG(LOG_INFO, ("lcp_addci: opt=%d\n", opt)); \
DieterGraef	0:f9b6112278fe	570	PUTCHAR(opt, ucp); \
DieterGraef	0:f9b6112278fe	571	PUTCHAR(CILEN_VOID, ucp); \
DieterGraef	0:f9b6112278fe	572	}
DieterGraef	0:f9b6112278fe	573	#define ADDCISHORT(opt, neg, val) \
DieterGraef	0:f9b6112278fe	574	if (neg) { \
DieterGraef	0:f9b6112278fe	575	LCPDEBUG(LOG_INFO, ("lcp_addci: INT opt=%d %X\n", opt, val)); \
DieterGraef	0:f9b6112278fe	576	PUTCHAR(opt, ucp); \
DieterGraef	0:f9b6112278fe	577	PUTCHAR(CILEN_SHORT, ucp); \
DieterGraef	0:f9b6112278fe	578	PUTSHORT(val, ucp); \
DieterGraef	0:f9b6112278fe	579	}
DieterGraef	0:f9b6112278fe	580	#define ADDCICHAP(opt, neg, val, digest) \
DieterGraef	0:f9b6112278fe	581	if (neg) { \
DieterGraef	0:f9b6112278fe	582	LCPDEBUG(LOG_INFO, ("lcp_addci: CHAP opt=%d %X\n", opt, val)); \
DieterGraef	0:f9b6112278fe	583	PUTCHAR(opt, ucp); \
DieterGraef	0:f9b6112278fe	584	PUTCHAR(CILEN_CHAP, ucp); \
DieterGraef	0:f9b6112278fe	585	PUTSHORT(val, ucp); \
DieterGraef	0:f9b6112278fe	586	PUTCHAR(digest, ucp); \
DieterGraef	0:f9b6112278fe	587	}
DieterGraef	0:f9b6112278fe	588	#define ADDCILONG(opt, neg, val) \
DieterGraef	0:f9b6112278fe	589	if (neg) { \
DieterGraef	0:f9b6112278fe	590	LCPDEBUG(LOG_INFO, ("lcp_addci: L opt=%d %lX\n", opt, val)); \
DieterGraef	0:f9b6112278fe	591	PUTCHAR(opt, ucp); \
DieterGraef	0:f9b6112278fe	592	PUTCHAR(CILEN_LONG, ucp); \
DieterGraef	0:f9b6112278fe	593	PUTLONG(val, ucp); \
DieterGraef	0:f9b6112278fe	594	}
DieterGraef	0:f9b6112278fe	595	#define ADDCILQR(opt, neg, val) \
DieterGraef	0:f9b6112278fe	596	if (neg) { \
DieterGraef	0:f9b6112278fe	597	LCPDEBUG(LOG_INFO, ("lcp_addci: LQR opt=%d %lX\n", opt, val)); \
DieterGraef	0:f9b6112278fe	598	PUTCHAR(opt, ucp); \
DieterGraef	0:f9b6112278fe	599	PUTCHAR(CILEN_LQR, ucp); \
DieterGraef	0:f9b6112278fe	600	PUTSHORT(PPP_LQR, ucp); \
DieterGraef	0:f9b6112278fe	601	PUTLONG(val, ucp); \
DieterGraef	0:f9b6112278fe	602	}
DieterGraef	0:f9b6112278fe	603	#define ADDCICHAR(opt, neg, val) \
DieterGraef	0:f9b6112278fe	604	if (neg) { \
DieterGraef	0:f9b6112278fe	605	LCPDEBUG(LOG_INFO, ("lcp_addci: CHAR opt=%d %X '%z'\n", opt, val, val)); \
DieterGraef	0:f9b6112278fe	606	PUTCHAR(opt, ucp); \
DieterGraef	0:f9b6112278fe	607	PUTCHAR(CILEN_CHAR, ucp); \
DieterGraef	0:f9b6112278fe	608	PUTCHAR(val, ucp); \
DieterGraef	0:f9b6112278fe	609	}
DieterGraef	0:f9b6112278fe	610
DieterGraef	0:f9b6112278fe	611	ADDCISHORT(CI_MRU, go->neg_mru && go->mru != PPP_DEFMRU, go->mru);
DieterGraef	0:f9b6112278fe	612	ADDCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl, go->asyncmap);
DieterGraef	0:f9b6112278fe	613	ADDCICHAP(CI_AUTHTYPE, go->neg_chap, PPP_CHAP, go->chap_mdtype);
DieterGraef	0:f9b6112278fe	614	ADDCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP);
DieterGraef	0:f9b6112278fe	615	ADDCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period);
DieterGraef	0:f9b6112278fe	616	ADDCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT);
DieterGraef	0:f9b6112278fe	617	ADDCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber);
DieterGraef	0:f9b6112278fe	618	ADDCIVOID(CI_PCOMPRESSION, go->neg_pcompression);
DieterGraef	0:f9b6112278fe	619	ADDCIVOID(CI_ACCOMPRESSION, go->neg_accompression);
DieterGraef	0:f9b6112278fe	620
DieterGraef	0:f9b6112278fe	621	if (ucp - start_ucp != *lenp) {
DieterGraef	0:f9b6112278fe	622	/* this should never happen, because peer_mtu should be 1500 */
DieterGraef	0:f9b6112278fe	623	LCPDEBUG(LOG_ERR, ("Bug in lcp_addci: wrong length\n"));
DieterGraef	0:f9b6112278fe	624	}
DieterGraef	0:f9b6112278fe	625	}
DieterGraef	0:f9b6112278fe	626
DieterGraef	0:f9b6112278fe	627
DieterGraef	0:f9b6112278fe	628	/*
DieterGraef	0:f9b6112278fe	629	* lcp_ackci - Ack our CIs.
DieterGraef	0:f9b6112278fe	630	* This should not modify any state if the Ack is bad.
DieterGraef	0:f9b6112278fe	631	*
DieterGraef	0:f9b6112278fe	632	* Returns:
DieterGraef	0:f9b6112278fe	633	* 0 - Ack was bad.
DieterGraef	0:f9b6112278fe	634	* 1 - Ack was good.
DieterGraef	0:f9b6112278fe	635	*/
DieterGraef	0:f9b6112278fe	636	static int
DieterGraef	0:f9b6112278fe	637	lcp_ackci(fsm f, u_char p, int len)
DieterGraef	0:f9b6112278fe	638	{
DieterGraef	0:f9b6112278fe	639	lcp_options *go = &lcp_gotoptions[f->unit];
DieterGraef	0:f9b6112278fe	640	u_char cilen, citype, cichar;
DieterGraef	0:f9b6112278fe	641	u_short cishort;
DieterGraef	0:f9b6112278fe	642	u32_t cilong;
DieterGraef	0:f9b6112278fe	643
DieterGraef	0:f9b6112278fe	644	/*
DieterGraef	0:f9b6112278fe	645	* CIs must be in exactly the same order that we sent.
DieterGraef	0:f9b6112278fe	646	* Check packet length and CI length at each step.
DieterGraef	0:f9b6112278fe	647	* If we find any deviations, then this packet is bad.
DieterGraef	0:f9b6112278fe	648	*/
DieterGraef	0:f9b6112278fe	649	#define ACKCIVOID(opt, neg) \
DieterGraef	0:f9b6112278fe	650	if (neg) { \
DieterGraef	0:f9b6112278fe	651	if ((len -= CILEN_VOID) < 0) \
DieterGraef	0:f9b6112278fe	652	goto bad; \
DieterGraef	0:f9b6112278fe	653	GETCHAR(citype, p); \
DieterGraef	0:f9b6112278fe	654	GETCHAR(cilen, p); \
DieterGraef	0:f9b6112278fe	655	if (cilen != CILEN_VOID \|\| citype != opt) \
DieterGraef	0:f9b6112278fe	656	goto bad; \
DieterGraef	0:f9b6112278fe	657	}
DieterGraef	0:f9b6112278fe	658	#define ACKCISHORT(opt, neg, val) \
DieterGraef	0:f9b6112278fe	659	if (neg) { \
DieterGraef	0:f9b6112278fe	660	if ((len -= CILEN_SHORT) < 0) \
DieterGraef	0:f9b6112278fe	661	goto bad; \
DieterGraef	0:f9b6112278fe	662	GETCHAR(citype, p); \
DieterGraef	0:f9b6112278fe	663	GETCHAR(cilen, p); \
DieterGraef	0:f9b6112278fe	664	if (cilen != CILEN_SHORT \|\| citype != opt) \
DieterGraef	0:f9b6112278fe	665	goto bad; \
DieterGraef	0:f9b6112278fe	666	GETSHORT(cishort, p); \
DieterGraef	0:f9b6112278fe	667	if (cishort != val) \
DieterGraef	0:f9b6112278fe	668	goto bad; \
DieterGraef	0:f9b6112278fe	669	}
DieterGraef	0:f9b6112278fe	670	#define ACKCICHAR(opt, neg, val) \
DieterGraef	0:f9b6112278fe	671	if (neg) { \
DieterGraef	0:f9b6112278fe	672	if ((len -= CILEN_CHAR) < 0) \
DieterGraef	0:f9b6112278fe	673	goto bad; \
DieterGraef	0:f9b6112278fe	674	GETCHAR(citype, p); \
DieterGraef	0:f9b6112278fe	675	GETCHAR(cilen, p); \
DieterGraef	0:f9b6112278fe	676	if (cilen != CILEN_CHAR \|\| citype != opt) \
DieterGraef	0:f9b6112278fe	677	goto bad; \
DieterGraef	0:f9b6112278fe	678	GETCHAR(cichar, p); \
DieterGraef	0:f9b6112278fe	679	if (cichar != val) \
DieterGraef	0:f9b6112278fe	680	goto bad; \
DieterGraef	0:f9b6112278fe	681	}
DieterGraef	0:f9b6112278fe	682	#define ACKCICHAP(opt, neg, val, digest) \
DieterGraef	0:f9b6112278fe	683	if (neg) { \
DieterGraef	0:f9b6112278fe	684	if ((len -= CILEN_CHAP) < 0) \
DieterGraef	0:f9b6112278fe	685	goto bad; \
DieterGraef	0:f9b6112278fe	686	GETCHAR(citype, p); \
DieterGraef	0:f9b6112278fe	687	GETCHAR(cilen, p); \
DieterGraef	0:f9b6112278fe	688	if (cilen != CILEN_CHAP \|\| citype != opt) \
DieterGraef	0:f9b6112278fe	689	goto bad; \
DieterGraef	0:f9b6112278fe	690	GETSHORT(cishort, p); \
DieterGraef	0:f9b6112278fe	691	if (cishort != val) \
DieterGraef	0:f9b6112278fe	692	goto bad; \
DieterGraef	0:f9b6112278fe	693	GETCHAR(cichar, p); \
DieterGraef	0:f9b6112278fe	694	if (cichar != digest) \
DieterGraef	0:f9b6112278fe	695	goto bad; \
DieterGraef	0:f9b6112278fe	696	}
DieterGraef	0:f9b6112278fe	697	#define ACKCILONG(opt, neg, val) \
DieterGraef	0:f9b6112278fe	698	if (neg) { \
DieterGraef	0:f9b6112278fe	699	if ((len -= CILEN_LONG) < 0) \
DieterGraef	0:f9b6112278fe	700	goto bad; \
DieterGraef	0:f9b6112278fe	701	GETCHAR(citype, p); \
DieterGraef	0:f9b6112278fe	702	GETCHAR(cilen, p); \
DieterGraef	0:f9b6112278fe	703	if (cilen != CILEN_LONG \|\| citype != opt) \
DieterGraef	0:f9b6112278fe	704	goto bad; \
DieterGraef	0:f9b6112278fe	705	GETLONG(cilong, p); \
DieterGraef	0:f9b6112278fe	706	if (cilong != val) \
DieterGraef	0:f9b6112278fe	707	goto bad; \
DieterGraef	0:f9b6112278fe	708	}
DieterGraef	0:f9b6112278fe	709	#define ACKCILQR(opt, neg, val) \
DieterGraef	0:f9b6112278fe	710	if (neg) { \
DieterGraef	0:f9b6112278fe	711	if ((len -= CILEN_LQR) < 0) \
DieterGraef	0:f9b6112278fe	712	goto bad; \
DieterGraef	0:f9b6112278fe	713	GETCHAR(citype, p); \
DieterGraef	0:f9b6112278fe	714	GETCHAR(cilen, p); \
DieterGraef	0:f9b6112278fe	715	if (cilen != CILEN_LQR \|\| citype != opt) \
DieterGraef	0:f9b6112278fe	716	goto bad; \
DieterGraef	0:f9b6112278fe	717	GETSHORT(cishort, p); \
DieterGraef	0:f9b6112278fe	718	if (cishort != PPP_LQR) \
DieterGraef	0:f9b6112278fe	719	goto bad; \
DieterGraef	0:f9b6112278fe	720	GETLONG(cilong, p); \
DieterGraef	0:f9b6112278fe	721	if (cilong != val) \
DieterGraef	0:f9b6112278fe	722	goto bad; \
DieterGraef	0:f9b6112278fe	723	}
DieterGraef	0:f9b6112278fe	724
DieterGraef	0:f9b6112278fe	725	ACKCISHORT(CI_MRU, go->neg_mru && go->mru != PPP_DEFMRU, go->mru);
DieterGraef	0:f9b6112278fe	726	ACKCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl, go->asyncmap);
DieterGraef	0:f9b6112278fe	727	ACKCICHAP(CI_AUTHTYPE, go->neg_chap, PPP_CHAP, go->chap_mdtype);
DieterGraef	0:f9b6112278fe	728	ACKCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP);
DieterGraef	0:f9b6112278fe	729	ACKCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period);
DieterGraef	0:f9b6112278fe	730	ACKCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT);
DieterGraef	0:f9b6112278fe	731	ACKCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber);
DieterGraef	0:f9b6112278fe	732	ACKCIVOID(CI_PCOMPRESSION, go->neg_pcompression);
DieterGraef	0:f9b6112278fe	733	ACKCIVOID(CI_ACCOMPRESSION, go->neg_accompression);
DieterGraef	0:f9b6112278fe	734
DieterGraef	0:f9b6112278fe	735	/*
DieterGraef	0:f9b6112278fe	736	* If there are any remaining CIs, then this packet is bad.
DieterGraef	0:f9b6112278fe	737	*/
DieterGraef	0:f9b6112278fe	738	if (len != 0) {
DieterGraef	0:f9b6112278fe	739	goto bad;
DieterGraef	0:f9b6112278fe	740	}
DieterGraef	0:f9b6112278fe	741	LCPDEBUG(LOG_INFO, ("lcp_acki: Ack\n"));
DieterGraef	0:f9b6112278fe	742	return (1);
DieterGraef	0:f9b6112278fe	743	bad:
DieterGraef	0:f9b6112278fe	744	LCPDEBUG(LOG_WARNING, ("lcp_acki: received bad Ack!\n"));
DieterGraef	0:f9b6112278fe	745	return (0);
DieterGraef	0:f9b6112278fe	746	}
DieterGraef	0:f9b6112278fe	747
DieterGraef	0:f9b6112278fe	748
DieterGraef	0:f9b6112278fe	749	/*
DieterGraef	0:f9b6112278fe	750	* lcp_nakci - Peer has sent a NAK for some of our CIs.
DieterGraef	0:f9b6112278fe	751	* This should not modify any state if the Nak is bad
DieterGraef	0:f9b6112278fe	752	* or if LCP is in the LS_OPENED state.
DieterGraef	0:f9b6112278fe	753	*
DieterGraef	0:f9b6112278fe	754	* Returns:
DieterGraef	0:f9b6112278fe	755	* 0 - Nak was bad.
DieterGraef	0:f9b6112278fe	756	* 1 - Nak was good.
DieterGraef	0:f9b6112278fe	757	*/
DieterGraef	0:f9b6112278fe	758	static int
DieterGraef	0:f9b6112278fe	759	lcp_nakci(fsm f, u_char p, int len)
DieterGraef	0:f9b6112278fe	760	{
DieterGraef	0:f9b6112278fe	761	lcp_options *go = &lcp_gotoptions[f->unit];
DieterGraef	0:f9b6112278fe	762	lcp_options *wo = &lcp_wantoptions[f->unit];
DieterGraef	0:f9b6112278fe	763	u_char citype, cichar, *next;
DieterGraef	0:f9b6112278fe	764	u_short cishort;
DieterGraef	0:f9b6112278fe	765	u32_t cilong;
DieterGraef	0:f9b6112278fe	766	lcp_options no; /* options we've seen Naks for */
DieterGraef	0:f9b6112278fe	767	lcp_options try; /* options to request next time */
DieterGraef	0:f9b6112278fe	768	int looped_back = 0;
DieterGraef	0:f9b6112278fe	769	int cilen;
DieterGraef	0:f9b6112278fe	770
DieterGraef	0:f9b6112278fe	771	BZERO(&no, sizeof(no));
DieterGraef	0:f9b6112278fe	772	try = *go;
DieterGraef	0:f9b6112278fe	773
DieterGraef	0:f9b6112278fe	774	/*
DieterGraef	0:f9b6112278fe	775	* Any Nak'd CIs must be in exactly the same order that we sent.
DieterGraef	0:f9b6112278fe	776	* Check packet length and CI length at each step.
DieterGraef	0:f9b6112278fe	777	* If we find any deviations, then this packet is bad.
DieterGraef	0:f9b6112278fe	778	*/
DieterGraef	0:f9b6112278fe	779	#define NAKCIVOID(opt, neg, code) \
DieterGraef	0:f9b6112278fe	780	if (go->neg && \
DieterGraef	0:f9b6112278fe	781	len >= CILEN_VOID && \
DieterGraef	0:f9b6112278fe	782	p[1] == CILEN_VOID && \
DieterGraef	0:f9b6112278fe	783	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	784	len -= CILEN_VOID; \
DieterGraef	0:f9b6112278fe	785	INCPTR(CILEN_VOID, p); \
DieterGraef	0:f9b6112278fe	786	no.neg = 1; \
DieterGraef	0:f9b6112278fe	787	code \
DieterGraef	0:f9b6112278fe	788	}
DieterGraef	0:f9b6112278fe	789	#define NAKCICHAP(opt, neg, code) \
DieterGraef	0:f9b6112278fe	790	if (go->neg && \
DieterGraef	0:f9b6112278fe	791	len >= CILEN_CHAP && \
DieterGraef	0:f9b6112278fe	792	p[1] == CILEN_CHAP && \
DieterGraef	0:f9b6112278fe	793	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	794	len -= CILEN_CHAP; \
DieterGraef	0:f9b6112278fe	795	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	796	GETSHORT(cishort, p); \
DieterGraef	0:f9b6112278fe	797	GETCHAR(cichar, p); \
DieterGraef	0:f9b6112278fe	798	no.neg = 1; \
DieterGraef	0:f9b6112278fe	799	code \
DieterGraef	0:f9b6112278fe	800	}
DieterGraef	0:f9b6112278fe	801	#define NAKCICHAR(opt, neg, code) \
DieterGraef	0:f9b6112278fe	802	if (go->neg && \
DieterGraef	0:f9b6112278fe	803	len >= CILEN_CHAR && \
DieterGraef	0:f9b6112278fe	804	p[1] == CILEN_CHAR && \
DieterGraef	0:f9b6112278fe	805	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	806	len -= CILEN_CHAR; \
DieterGraef	0:f9b6112278fe	807	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	808	GETCHAR(cichar, p); \
DieterGraef	0:f9b6112278fe	809	no.neg = 1; \
DieterGraef	0:f9b6112278fe	810	code \
DieterGraef	0:f9b6112278fe	811	}
DieterGraef	0:f9b6112278fe	812	#define NAKCISHORT(opt, neg, code) \
DieterGraef	0:f9b6112278fe	813	if (go->neg && \
DieterGraef	0:f9b6112278fe	814	len >= CILEN_SHORT && \
DieterGraef	0:f9b6112278fe	815	p[1] == CILEN_SHORT && \
DieterGraef	0:f9b6112278fe	816	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	817	len -= CILEN_SHORT; \
DieterGraef	0:f9b6112278fe	818	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	819	GETSHORT(cishort, p); \
DieterGraef	0:f9b6112278fe	820	no.neg = 1; \
DieterGraef	0:f9b6112278fe	821	code \
DieterGraef	0:f9b6112278fe	822	}
DieterGraef	0:f9b6112278fe	823	#define NAKCILONG(opt, neg, code) \
DieterGraef	0:f9b6112278fe	824	if (go->neg && \
DieterGraef	0:f9b6112278fe	825	len >= CILEN_LONG && \
DieterGraef	0:f9b6112278fe	826	p[1] == CILEN_LONG && \
DieterGraef	0:f9b6112278fe	827	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	828	len -= CILEN_LONG; \
DieterGraef	0:f9b6112278fe	829	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	830	GETLONG(cilong, p); \
DieterGraef	0:f9b6112278fe	831	no.neg = 1; \
DieterGraef	0:f9b6112278fe	832	code \
DieterGraef	0:f9b6112278fe	833	}
DieterGraef	0:f9b6112278fe	834	#define NAKCILQR(opt, neg, code) \
DieterGraef	0:f9b6112278fe	835	if (go->neg && \
DieterGraef	0:f9b6112278fe	836	len >= CILEN_LQR && \
DieterGraef	0:f9b6112278fe	837	p[1] == CILEN_LQR && \
DieterGraef	0:f9b6112278fe	838	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	839	len -= CILEN_LQR; \
DieterGraef	0:f9b6112278fe	840	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	841	GETSHORT(cishort, p); \
DieterGraef	0:f9b6112278fe	842	GETLONG(cilong, p); \
DieterGraef	0:f9b6112278fe	843	no.neg = 1; \
DieterGraef	0:f9b6112278fe	844	code \
DieterGraef	0:f9b6112278fe	845	}
DieterGraef	0:f9b6112278fe	846
DieterGraef	0:f9b6112278fe	847	/*
DieterGraef	0:f9b6112278fe	848	* We don't care if they want to send us smaller packets than
DieterGraef	0:f9b6112278fe	849	* we want. Therefore, accept any MRU less than what we asked for,
DieterGraef	0:f9b6112278fe	850	* but then ignore the new value when setting the MRU in the kernel.
DieterGraef	0:f9b6112278fe	851	* If they send us a bigger MRU than what we asked, accept it, up to
DieterGraef	0:f9b6112278fe	852	* the limit of the default MRU we'd get if we didn't negotiate.
DieterGraef	0:f9b6112278fe	853	*/
DieterGraef	0:f9b6112278fe	854	if (go->neg_mru && go->mru != PPP_DEFMRU) {
DieterGraef	0:f9b6112278fe	855	NAKCISHORT(CI_MRU, neg_mru,
DieterGraef	0:f9b6112278fe	856	if (cishort <= wo->mru \|\| cishort < PPP_DEFMRU) {
DieterGraef	0:f9b6112278fe	857	try.mru = cishort;
DieterGraef	0:f9b6112278fe	858	}
DieterGraef	0:f9b6112278fe	859	);
DieterGraef	0:f9b6112278fe	860	}
DieterGraef	0:f9b6112278fe	861
DieterGraef	0:f9b6112278fe	862	/*
DieterGraef	0:f9b6112278fe	863	* Add any characters they want to our (receive-side) asyncmap.
DieterGraef	0:f9b6112278fe	864	*/
DieterGraef	0:f9b6112278fe	865	if (go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl) {
DieterGraef	0:f9b6112278fe	866	NAKCILONG(CI_ASYNCMAP, neg_asyncmap,
DieterGraef	0:f9b6112278fe	867	try.asyncmap = go->asyncmap \| cilong;
DieterGraef	0:f9b6112278fe	868	);
DieterGraef	0:f9b6112278fe	869	}
DieterGraef	0:f9b6112278fe	870
DieterGraef	0:f9b6112278fe	871	/*
DieterGraef	0:f9b6112278fe	872	* If they've nak'd our authentication-protocol, check whether
DieterGraef	0:f9b6112278fe	873	* they are proposing a different protocol, or a different
DieterGraef	0:f9b6112278fe	874	* hash algorithm for CHAP.
DieterGraef	0:f9b6112278fe	875	*/
DieterGraef	0:f9b6112278fe	876	if ((go->neg_chap \|\| go->neg_upap)
DieterGraef	0:f9b6112278fe	877	&& len >= CILEN_SHORT
DieterGraef	0:f9b6112278fe	878	&& p[0] == CI_AUTHTYPE && p[1] >= CILEN_SHORT && p[1] <= len) {
DieterGraef	0:f9b6112278fe	879	cilen = p[1];
DieterGraef	0:f9b6112278fe	880	len -= cilen;
DieterGraef	0:f9b6112278fe	881	no.neg_chap = go->neg_chap;
DieterGraef	0:f9b6112278fe	882	no.neg_upap = go->neg_upap;
DieterGraef	0:f9b6112278fe	883	INCPTR(2, p);
DieterGraef	0:f9b6112278fe	884	GETSHORT(cishort, p);
DieterGraef	0:f9b6112278fe	885	if (cishort == PPP_PAP && cilen == CILEN_SHORT) {
DieterGraef	0:f9b6112278fe	886	/*
DieterGraef	0:f9b6112278fe	887	* If we were asking for CHAP, they obviously don't want to do it.
DieterGraef	0:f9b6112278fe	888	* If we weren't asking for CHAP, then we were asking for PAP,
DieterGraef	0:f9b6112278fe	889	* in which case this Nak is bad.
DieterGraef	0:f9b6112278fe	890	*/
DieterGraef	0:f9b6112278fe	891	if (!go->neg_chap) {
DieterGraef	0:f9b6112278fe	892	goto bad;
DieterGraef	0:f9b6112278fe	893	}
DieterGraef	0:f9b6112278fe	894	try.neg_chap = 0;
DieterGraef	0:f9b6112278fe	895
DieterGraef	0:f9b6112278fe	896	} else if (cishort == PPP_CHAP && cilen == CILEN_CHAP) {
DieterGraef	0:f9b6112278fe	897	GETCHAR(cichar, p);
DieterGraef	0:f9b6112278fe	898	if (go->neg_chap) {
DieterGraef	0:f9b6112278fe	899	/*
DieterGraef	0:f9b6112278fe	900	* We were asking for CHAP/MD5; they must want a different
DieterGraef	0:f9b6112278fe	901	* algorithm. If they can't do MD5, we'll have to stop
DieterGraef	0:f9b6112278fe	902	* asking for CHAP.
DieterGraef	0:f9b6112278fe	903	*/
DieterGraef	0:f9b6112278fe	904	if (cichar != go->chap_mdtype) {
DieterGraef	0:f9b6112278fe	905	try.neg_chap = 0;
DieterGraef	0:f9b6112278fe	906	}
DieterGraef	0:f9b6112278fe	907	} else {
DieterGraef	0:f9b6112278fe	908	/*
DieterGraef	0:f9b6112278fe	909	* Stop asking for PAP if we were asking for it.
DieterGraef	0:f9b6112278fe	910	*/
DieterGraef	0:f9b6112278fe	911	try.neg_upap = 0;
DieterGraef	0:f9b6112278fe	912	}
DieterGraef	0:f9b6112278fe	913
DieterGraef	0:f9b6112278fe	914	} else {
DieterGraef	0:f9b6112278fe	915	/*
DieterGraef	0:f9b6112278fe	916	* We don't recognize what they're suggesting.
DieterGraef	0:f9b6112278fe	917	* Stop asking for what we were asking for.
DieterGraef	0:f9b6112278fe	918	*/
DieterGraef	0:f9b6112278fe	919	if (go->neg_chap) {
DieterGraef	0:f9b6112278fe	920	try.neg_chap = 0;
DieterGraef	0:f9b6112278fe	921	} else {
DieterGraef	0:f9b6112278fe	922	try.neg_upap = 0;
DieterGraef	0:f9b6112278fe	923	}
DieterGraef	0:f9b6112278fe	924	p += cilen - CILEN_SHORT;
DieterGraef	0:f9b6112278fe	925	}
DieterGraef	0:f9b6112278fe	926	}
DieterGraef	0:f9b6112278fe	927
DieterGraef	0:f9b6112278fe	928	/*
DieterGraef	0:f9b6112278fe	929	* If they can't cope with our link quality protocol, we'll have
DieterGraef	0:f9b6112278fe	930	* to stop asking for LQR. We haven't got any other protocol.
DieterGraef	0:f9b6112278fe	931	* If they Nak the reporting period, take their value XXX ?
DieterGraef	0:f9b6112278fe	932	*/
DieterGraef	0:f9b6112278fe	933	NAKCILQR(CI_QUALITY, neg_lqr,
DieterGraef	0:f9b6112278fe	934	if (cishort != PPP_LQR) {
DieterGraef	0:f9b6112278fe	935	try.neg_lqr = 0;
DieterGraef	0:f9b6112278fe	936	} else {
DieterGraef	0:f9b6112278fe	937	try.lqr_period = cilong;
DieterGraef	0:f9b6112278fe	938	}
DieterGraef	0:f9b6112278fe	939	);
DieterGraef	0:f9b6112278fe	940
DieterGraef	0:f9b6112278fe	941	/*
DieterGraef	0:f9b6112278fe	942	* Only implementing CBCP...not the rest of the callback options
DieterGraef	0:f9b6112278fe	943	*/
DieterGraef	0:f9b6112278fe	944	NAKCICHAR(CI_CALLBACK, neg_cbcp,
DieterGraef	0:f9b6112278fe	945	try.neg_cbcp = 0;
DieterGraef	0:f9b6112278fe	946	);
DieterGraef	0:f9b6112278fe	947
DieterGraef	0:f9b6112278fe	948	/*
DieterGraef	0:f9b6112278fe	949	* Check for a looped-back line.
DieterGraef	0:f9b6112278fe	950	*/
DieterGraef	0:f9b6112278fe	951	NAKCILONG(CI_MAGICNUMBER, neg_magicnumber,
DieterGraef	0:f9b6112278fe	952	try.magicnumber = magic();
DieterGraef	0:f9b6112278fe	953	looped_back = 1;
DieterGraef	0:f9b6112278fe	954	);
DieterGraef	0:f9b6112278fe	955
DieterGraef	0:f9b6112278fe	956	/*
DieterGraef	0:f9b6112278fe	957	* Peer shouldn't send Nak for protocol compression or
DieterGraef	0:f9b6112278fe	958	* address/control compression requests; they should send
DieterGraef	0:f9b6112278fe	959	* a Reject instead. If they send a Nak, treat it as a Reject.
DieterGraef	0:f9b6112278fe	960	*/
DieterGraef	0:f9b6112278fe	961	NAKCIVOID(CI_PCOMPRESSION, neg_pcompression,
DieterGraef	0:f9b6112278fe	962	try.neg_pcompression = 0;
DieterGraef	0:f9b6112278fe	963	);
DieterGraef	0:f9b6112278fe	964	NAKCIVOID(CI_ACCOMPRESSION, neg_accompression,
DieterGraef	0:f9b6112278fe	965	try.neg_accompression = 0;
DieterGraef	0:f9b6112278fe	966	);
DieterGraef	0:f9b6112278fe	967
DieterGraef	0:f9b6112278fe	968	/*
DieterGraef	0:f9b6112278fe	969	* There may be remaining CIs, if the peer is requesting negotiation
DieterGraef	0:f9b6112278fe	970	* on an option that we didn't include in our request packet.
DieterGraef	0:f9b6112278fe	971	* If we see an option that we requested, or one we've already seen
DieterGraef	0:f9b6112278fe	972	* in this packet, then this packet is bad.
DieterGraef	0:f9b6112278fe	973	* If we wanted to respond by starting to negotiate on the requested
DieterGraef	0:f9b6112278fe	974	* option(s), we could, but we don't, because except for the
DieterGraef	0:f9b6112278fe	975	* authentication type and quality protocol, if we are not negotiating
DieterGraef	0:f9b6112278fe	976	* an option, it is because we were told not to.
DieterGraef	0:f9b6112278fe	977	* For the authentication type, the Nak from the peer means
DieterGraef	0:f9b6112278fe	978	* `let me authenticate myself with you' which is a bit pointless.
DieterGraef	0:f9b6112278fe	979	* For the quality protocol, the Nak means `ask me to send you quality
DieterGraef	0:f9b6112278fe	980	* reports', but if we didn't ask for them, we don't want them.
DieterGraef	0:f9b6112278fe	981	* An option we don't recognize represents the peer asking to
DieterGraef	0:f9b6112278fe	982	* negotiate some option we don't support, so ignore it.
DieterGraef	0:f9b6112278fe	983	*/
DieterGraef	0:f9b6112278fe	984	while (len > CILEN_VOID) {
DieterGraef	0:f9b6112278fe	985	GETCHAR(citype, p);
DieterGraef	0:f9b6112278fe	986	GETCHAR(cilen, p);
DieterGraef	0:f9b6112278fe	987	if (cilen < CILEN_VOID \|\| (len -= cilen) < 0) {
DieterGraef	0:f9b6112278fe	988	goto bad;
DieterGraef	0:f9b6112278fe	989	}
DieterGraef	0:f9b6112278fe	990	next = p + cilen - 2;
DieterGraef	0:f9b6112278fe	991
DieterGraef	0:f9b6112278fe	992	switch (citype) {
DieterGraef	0:f9b6112278fe	993	case CI_MRU:
DieterGraef	0:f9b6112278fe	994	if ((go->neg_mru && go->mru != PPP_DEFMRU)
DieterGraef	0:f9b6112278fe	995	\|\| no.neg_mru \|\| cilen != CILEN_SHORT) {
DieterGraef	0:f9b6112278fe	996	goto bad;
DieterGraef	0:f9b6112278fe	997	}
DieterGraef	0:f9b6112278fe	998	GETSHORT(cishort, p);
DieterGraef	0:f9b6112278fe	999	if (cishort < PPP_DEFMRU) {
DieterGraef	0:f9b6112278fe	1000	try.mru = cishort;
DieterGraef	0:f9b6112278fe	1001	}
DieterGraef	0:f9b6112278fe	1002	break;
DieterGraef	0:f9b6112278fe	1003	case CI_ASYNCMAP:
DieterGraef	0:f9b6112278fe	1004	if ((go->neg_asyncmap && go->asyncmap != 0xFFFFFFFFl)
DieterGraef	0:f9b6112278fe	1005	\|\| no.neg_asyncmap \|\| cilen != CILEN_LONG) {
DieterGraef	0:f9b6112278fe	1006	goto bad;
DieterGraef	0:f9b6112278fe	1007	}
DieterGraef	0:f9b6112278fe	1008	break;
DieterGraef	0:f9b6112278fe	1009	case CI_AUTHTYPE:
DieterGraef	0:f9b6112278fe	1010	if (go->neg_chap \|\| no.neg_chap \|\| go->neg_upap \|\| no.neg_upap) {
DieterGraef	0:f9b6112278fe	1011	goto bad;
DieterGraef	0:f9b6112278fe	1012	}
DieterGraef	0:f9b6112278fe	1013	break;
DieterGraef	0:f9b6112278fe	1014	case CI_MAGICNUMBER:
DieterGraef	0:f9b6112278fe	1015	if (go->neg_magicnumber \|\| no.neg_magicnumber \|\|
DieterGraef	0:f9b6112278fe	1016	cilen != CILEN_LONG) {
DieterGraef	0:f9b6112278fe	1017	goto bad;
DieterGraef	0:f9b6112278fe	1018	}
DieterGraef	0:f9b6112278fe	1019	break;
DieterGraef	0:f9b6112278fe	1020	case CI_PCOMPRESSION:
DieterGraef	0:f9b6112278fe	1021	if (go->neg_pcompression \|\| no.neg_pcompression
DieterGraef	0:f9b6112278fe	1022	\|\| cilen != CILEN_VOID) {
DieterGraef	0:f9b6112278fe	1023	goto bad;
DieterGraef	0:f9b6112278fe	1024	}
DieterGraef	0:f9b6112278fe	1025	break;
DieterGraef	0:f9b6112278fe	1026	case CI_ACCOMPRESSION:
DieterGraef	0:f9b6112278fe	1027	if (go->neg_accompression \|\| no.neg_accompression
DieterGraef	0:f9b6112278fe	1028	\|\| cilen != CILEN_VOID) {
DieterGraef	0:f9b6112278fe	1029	goto bad;
DieterGraef	0:f9b6112278fe	1030	}
DieterGraef	0:f9b6112278fe	1031	break;
DieterGraef	0:f9b6112278fe	1032	case CI_QUALITY:
DieterGraef	0:f9b6112278fe	1033	if (go->neg_lqr \|\| no.neg_lqr \|\| cilen != CILEN_LQR) {
DieterGraef	0:f9b6112278fe	1034	goto bad;
DieterGraef	0:f9b6112278fe	1035	}
DieterGraef	0:f9b6112278fe	1036	break;
DieterGraef	0:f9b6112278fe	1037	}
DieterGraef	0:f9b6112278fe	1038	p = next;
DieterGraef	0:f9b6112278fe	1039	}
DieterGraef	0:f9b6112278fe	1040
DieterGraef	0:f9b6112278fe	1041	/* If there is still anything left, this packet is bad. */
DieterGraef	0:f9b6112278fe	1042	if (len != 0) {
DieterGraef	0:f9b6112278fe	1043	goto bad;
DieterGraef	0:f9b6112278fe	1044	}
DieterGraef	0:f9b6112278fe	1045
DieterGraef	0:f9b6112278fe	1046	/*
DieterGraef	0:f9b6112278fe	1047	* OK, the Nak is good. Now we can update state.
DieterGraef	0:f9b6112278fe	1048	*/
DieterGraef	0:f9b6112278fe	1049	if (f->state != LS_OPENED) {
DieterGraef	0:f9b6112278fe	1050	if (looped_back) {
DieterGraef	0:f9b6112278fe	1051	if (++try.numloops >= lcp_loopbackfail) {
DieterGraef	0:f9b6112278fe	1052	LCPDEBUG(LOG_NOTICE, ("Serial line is looped back.\n"));
DieterGraef	0:f9b6112278fe	1053	lcp_close(f->unit, "Loopback detected");
DieterGraef	0:f9b6112278fe	1054	}
DieterGraef	0:f9b6112278fe	1055	} else {
DieterGraef	0:f9b6112278fe	1056	try.numloops = 0;
DieterGraef	0:f9b6112278fe	1057	}
DieterGraef	0:f9b6112278fe	1058	*go = try;
DieterGraef	0:f9b6112278fe	1059	}
DieterGraef	0:f9b6112278fe	1060
DieterGraef	0:f9b6112278fe	1061	return 1;
DieterGraef	0:f9b6112278fe	1062
DieterGraef	0:f9b6112278fe	1063	bad:
DieterGraef	0:f9b6112278fe	1064	LCPDEBUG(LOG_WARNING, ("lcp_nakci: received bad Nak!\n"));
DieterGraef	0:f9b6112278fe	1065	return 0;
DieterGraef	0:f9b6112278fe	1066	}
DieterGraef	0:f9b6112278fe	1067
DieterGraef	0:f9b6112278fe	1068
DieterGraef	0:f9b6112278fe	1069	/*
DieterGraef	0:f9b6112278fe	1070	* lcp_rejci - Peer has Rejected some of our CIs.
DieterGraef	0:f9b6112278fe	1071	* This should not modify any state if the Reject is bad
DieterGraef	0:f9b6112278fe	1072	* or if LCP is in the LS_OPENED state.
DieterGraef	0:f9b6112278fe	1073	*
DieterGraef	0:f9b6112278fe	1074	* Returns:
DieterGraef	0:f9b6112278fe	1075	* 0 - Reject was bad.
DieterGraef	0:f9b6112278fe	1076	* 1 - Reject was good.
DieterGraef	0:f9b6112278fe	1077	*/
DieterGraef	0:f9b6112278fe	1078	static int
DieterGraef	0:f9b6112278fe	1079	lcp_rejci(fsm f, u_char p, int len)
DieterGraef	0:f9b6112278fe	1080	{
DieterGraef	0:f9b6112278fe	1081	lcp_options *go = &lcp_gotoptions[f->unit];
DieterGraef	0:f9b6112278fe	1082	u_char cichar;
DieterGraef	0:f9b6112278fe	1083	u_short cishort;
DieterGraef	0:f9b6112278fe	1084	u32_t cilong;
DieterGraef	0:f9b6112278fe	1085	lcp_options try; /* options to request next time */
DieterGraef	0:f9b6112278fe	1086
DieterGraef	0:f9b6112278fe	1087	try = *go;
DieterGraef	0:f9b6112278fe	1088
DieterGraef	0:f9b6112278fe	1089	/*
DieterGraef	0:f9b6112278fe	1090	* Any Rejected CIs must be in exactly the same order that we sent.
DieterGraef	0:f9b6112278fe	1091	* Check packet length and CI length at each step.
DieterGraef	0:f9b6112278fe	1092	* If we find any deviations, then this packet is bad.
DieterGraef	0:f9b6112278fe	1093	*/
DieterGraef	0:f9b6112278fe	1094	#define REJCIVOID(opt, neg) \
DieterGraef	0:f9b6112278fe	1095	if (go->neg && \
DieterGraef	0:f9b6112278fe	1096	len >= CILEN_VOID && \
DieterGraef	0:f9b6112278fe	1097	p[1] == CILEN_VOID && \
DieterGraef	0:f9b6112278fe	1098	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	1099	len -= CILEN_VOID; \
DieterGraef	0:f9b6112278fe	1100	INCPTR(CILEN_VOID, p); \
DieterGraef	0:f9b6112278fe	1101	try.neg = 0; \
DieterGraef	0:f9b6112278fe	1102	LCPDEBUG(LOG_INFO, ("lcp_rejci: void opt %d rejected\n", opt)); \
DieterGraef	0:f9b6112278fe	1103	}
DieterGraef	0:f9b6112278fe	1104	#define REJCISHORT(opt, neg, val) \
DieterGraef	0:f9b6112278fe	1105	if (go->neg && \
DieterGraef	0:f9b6112278fe	1106	len >= CILEN_SHORT && \
DieterGraef	0:f9b6112278fe	1107	p[1] == CILEN_SHORT && \
DieterGraef	0:f9b6112278fe	1108	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	1109	len -= CILEN_SHORT; \
DieterGraef	0:f9b6112278fe	1110	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	1111	GETSHORT(cishort, p); \
DieterGraef	0:f9b6112278fe	1112	/* Check rejected value. */ \
DieterGraef	0:f9b6112278fe	1113	if (cishort != val) { \
DieterGraef	0:f9b6112278fe	1114	goto bad; \
DieterGraef	0:f9b6112278fe	1115	} \
DieterGraef	0:f9b6112278fe	1116	try.neg = 0; \
DieterGraef	0:f9b6112278fe	1117	LCPDEBUG(LOG_INFO, ("lcp_rejci: short opt %d rejected\n", opt)); \
DieterGraef	0:f9b6112278fe	1118	}
DieterGraef	0:f9b6112278fe	1119	#define REJCICHAP(opt, neg, val, digest) \
DieterGraef	0:f9b6112278fe	1120	if (go->neg && \
DieterGraef	0:f9b6112278fe	1121	len >= CILEN_CHAP && \
DieterGraef	0:f9b6112278fe	1122	p[1] == CILEN_CHAP && \
DieterGraef	0:f9b6112278fe	1123	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	1124	len -= CILEN_CHAP; \
DieterGraef	0:f9b6112278fe	1125	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	1126	GETSHORT(cishort, p); \
DieterGraef	0:f9b6112278fe	1127	GETCHAR(cichar, p); \
DieterGraef	0:f9b6112278fe	1128	/* Check rejected value. */ \
DieterGraef	0:f9b6112278fe	1129	if (cishort != val \|\| cichar != digest) { \
DieterGraef	0:f9b6112278fe	1130	goto bad; \
DieterGraef	0:f9b6112278fe	1131	} \
DieterGraef	0:f9b6112278fe	1132	try.neg = 0; \
DieterGraef	0:f9b6112278fe	1133	try.neg_upap = 0; \
DieterGraef	0:f9b6112278fe	1134	LCPDEBUG(LOG_INFO, ("lcp_rejci: chap opt %d rejected\n", opt)); \
DieterGraef	0:f9b6112278fe	1135	}
DieterGraef	0:f9b6112278fe	1136	#define REJCILONG(opt, neg, val) \
DieterGraef	0:f9b6112278fe	1137	if (go->neg && \
DieterGraef	0:f9b6112278fe	1138	len >= CILEN_LONG && \
DieterGraef	0:f9b6112278fe	1139	p[1] == CILEN_LONG && \
DieterGraef	0:f9b6112278fe	1140	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	1141	len -= CILEN_LONG; \
DieterGraef	0:f9b6112278fe	1142	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	1143	GETLONG(cilong, p); \
DieterGraef	0:f9b6112278fe	1144	/* Check rejected value. */ \
DieterGraef	0:f9b6112278fe	1145	if (cilong != val) { \
DieterGraef	0:f9b6112278fe	1146	goto bad; \
DieterGraef	0:f9b6112278fe	1147	} \
DieterGraef	0:f9b6112278fe	1148	try.neg = 0; \
DieterGraef	0:f9b6112278fe	1149	LCPDEBUG(LOG_INFO, ("lcp_rejci: long opt %d rejected\n", opt)); \
DieterGraef	0:f9b6112278fe	1150	}
DieterGraef	0:f9b6112278fe	1151	#define REJCILQR(opt, neg, val) \
DieterGraef	0:f9b6112278fe	1152	if (go->neg && \
DieterGraef	0:f9b6112278fe	1153	len >= CILEN_LQR && \
DieterGraef	0:f9b6112278fe	1154	p[1] == CILEN_LQR && \
DieterGraef	0:f9b6112278fe	1155	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	1156	len -= CILEN_LQR; \
DieterGraef	0:f9b6112278fe	1157	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	1158	GETSHORT(cishort, p); \
DieterGraef	0:f9b6112278fe	1159	GETLONG(cilong, p); \
DieterGraef	0:f9b6112278fe	1160	/* Check rejected value. */ \
DieterGraef	0:f9b6112278fe	1161	if (cishort != PPP_LQR \|\| cilong != val) { \
DieterGraef	0:f9b6112278fe	1162	goto bad; \
DieterGraef	0:f9b6112278fe	1163	} \
DieterGraef	0:f9b6112278fe	1164	try.neg = 0; \
DieterGraef	0:f9b6112278fe	1165	LCPDEBUG(LOG_INFO, ("lcp_rejci: LQR opt %d rejected\n", opt)); \
DieterGraef	0:f9b6112278fe	1166	}
DieterGraef	0:f9b6112278fe	1167	#define REJCICBCP(opt, neg, val) \
DieterGraef	0:f9b6112278fe	1168	if (go->neg && \
DieterGraef	0:f9b6112278fe	1169	len >= CILEN_CBCP && \
DieterGraef	0:f9b6112278fe	1170	p[1] == CILEN_CBCP && \
DieterGraef	0:f9b6112278fe	1171	p[0] == opt) { \
DieterGraef	0:f9b6112278fe	1172	len -= CILEN_CBCP; \
DieterGraef	0:f9b6112278fe	1173	INCPTR(2, p); \
DieterGraef	0:f9b6112278fe	1174	GETCHAR(cichar, p); \
DieterGraef	0:f9b6112278fe	1175	/* Check rejected value. */ \
DieterGraef	0:f9b6112278fe	1176	if (cichar != val) { \
DieterGraef	0:f9b6112278fe	1177	goto bad; \
DieterGraef	0:f9b6112278fe	1178	} \
DieterGraef	0:f9b6112278fe	1179	try.neg = 0; \
DieterGraef	0:f9b6112278fe	1180	LCPDEBUG(LOG_INFO, ("lcp_rejci: Callback opt %d rejected\n", opt)); \
DieterGraef	0:f9b6112278fe	1181	}
DieterGraef	0:f9b6112278fe	1182
DieterGraef	0:f9b6112278fe	1183	REJCISHORT(CI_MRU, neg_mru, go->mru);
DieterGraef	0:f9b6112278fe	1184	REJCILONG(CI_ASYNCMAP, neg_asyncmap, go->asyncmap);
DieterGraef	0:f9b6112278fe	1185	REJCICHAP(CI_AUTHTYPE, neg_chap, PPP_CHAP, go->chap_mdtype);
DieterGraef	0:f9b6112278fe	1186	if (!go->neg_chap) {
DieterGraef	0:f9b6112278fe	1187	REJCISHORT(CI_AUTHTYPE, neg_upap, PPP_PAP);
DieterGraef	0:f9b6112278fe	1188	}
DieterGraef	0:f9b6112278fe	1189	REJCILQR(CI_QUALITY, neg_lqr, go->lqr_period);
DieterGraef	0:f9b6112278fe	1190	REJCICBCP(CI_CALLBACK, neg_cbcp, CBCP_OPT);
DieterGraef	0:f9b6112278fe	1191	REJCILONG(CI_MAGICNUMBER, neg_magicnumber, go->magicnumber);
DieterGraef	0:f9b6112278fe	1192	REJCIVOID(CI_PCOMPRESSION, neg_pcompression);
DieterGraef	0:f9b6112278fe	1193	REJCIVOID(CI_ACCOMPRESSION, neg_accompression);
DieterGraef	0:f9b6112278fe	1194
DieterGraef	0:f9b6112278fe	1195	/*
DieterGraef	0:f9b6112278fe	1196	* If there are any remaining CIs, then this packet is bad.
DieterGraef	0:f9b6112278fe	1197	*/
DieterGraef	0:f9b6112278fe	1198	if (len != 0) {
DieterGraef	0:f9b6112278fe	1199	goto bad;
DieterGraef	0:f9b6112278fe	1200	}
DieterGraef	0:f9b6112278fe	1201	/*
DieterGraef	0:f9b6112278fe	1202	* Now we can update state.
DieterGraef	0:f9b6112278fe	1203	*/
DieterGraef	0:f9b6112278fe	1204	if (f->state != LS_OPENED) {
DieterGraef	0:f9b6112278fe	1205	*go = try;
DieterGraef	0:f9b6112278fe	1206	}
DieterGraef	0:f9b6112278fe	1207	return 1;
DieterGraef	0:f9b6112278fe	1208
DieterGraef	0:f9b6112278fe	1209	bad:
DieterGraef	0:f9b6112278fe	1210	LCPDEBUG(LOG_WARNING, ("lcp_rejci: received bad Reject!\n"));
DieterGraef	0:f9b6112278fe	1211	return 0;
DieterGraef	0:f9b6112278fe	1212	}
DieterGraef	0:f9b6112278fe	1213
DieterGraef	0:f9b6112278fe	1214
DieterGraef	0:f9b6112278fe	1215	/*
DieterGraef	0:f9b6112278fe	1216	* lcp_reqci - Check the peer's requested CIs and send appropriate response.
DieterGraef	0:f9b6112278fe	1217	*
DieterGraef	0:f9b6112278fe	1218	* Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
DieterGraef	0:f9b6112278fe	1219	* appropriately. If reject_if_disagree is non-zero, doesn't return
DieterGraef	0:f9b6112278fe	1220	* CONFNAK; returns CONFREJ if it can't return CONFACK.
DieterGraef	0:f9b6112278fe	1221	*/
DieterGraef	0:f9b6112278fe	1222	static int
DieterGraef	0:f9b6112278fe	1223	lcp_reqci(fsm *f,
DieterGraef	0:f9b6112278fe	1224	u_char inp, / Requested CIs */
DieterGraef	0:f9b6112278fe	1225	int lenp, / Length of requested CIs */
DieterGraef	0:f9b6112278fe	1226	int reject_if_disagree)
DieterGraef	0:f9b6112278fe	1227	{
DieterGraef	0:f9b6112278fe	1228	lcp_options *go = &lcp_gotoptions[f->unit];
DieterGraef	0:f9b6112278fe	1229	lcp_options *ho = &lcp_hisoptions[f->unit];
DieterGraef	0:f9b6112278fe	1230	lcp_options *ao = &lcp_allowoptions[f->unit];
DieterGraef	0:f9b6112278fe	1231	u_char cip, next; /* Pointer to current and next CIs */
DieterGraef	0:f9b6112278fe	1232	int cilen, citype; /* Parsed len, type */
DieterGraef	0:f9b6112278fe	1233	u_char cichar; /* Parsed char value */
DieterGraef	0:f9b6112278fe	1234	u_short cishort; /* Parsed short value */
DieterGraef	0:f9b6112278fe	1235	u32_t cilong; /* Parse long value */
DieterGraef	0:f9b6112278fe	1236	int rc = CONFACK; /* Final packet return code */
DieterGraef	0:f9b6112278fe	1237	int orc; /* Individual option return code */
DieterGraef	0:f9b6112278fe	1238	u_char p; / Pointer to next char to parse */
DieterGraef	0:f9b6112278fe	1239	u_char rejp; / Pointer to next char in reject frame */
DieterGraef	0:f9b6112278fe	1240	u_char nakp; / Pointer to next char in Nak frame */
DieterGraef	0:f9b6112278fe	1241	int l = lenp; / Length left */
DieterGraef	0:f9b6112278fe	1242	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1243	char traceBuf[80];
DieterGraef	0:f9b6112278fe	1244	size_t traceNdx = 0;
DieterGraef	0:f9b6112278fe	1245	#endif
DieterGraef	0:f9b6112278fe	1246
DieterGraef	0:f9b6112278fe	1247	/*
DieterGraef	0:f9b6112278fe	1248	* Reset all his options.
DieterGraef	0:f9b6112278fe	1249	*/
DieterGraef	0:f9b6112278fe	1250	BZERO(ho, sizeof(*ho));
DieterGraef	0:f9b6112278fe	1251
DieterGraef	0:f9b6112278fe	1252	/*
DieterGraef	0:f9b6112278fe	1253	* Process all his options.
DieterGraef	0:f9b6112278fe	1254	*/
DieterGraef	0:f9b6112278fe	1255	next = inp;
DieterGraef	0:f9b6112278fe	1256	nakp = nak_buffer;
DieterGraef	0:f9b6112278fe	1257	rejp = inp;
DieterGraef	0:f9b6112278fe	1258	while (l) {
DieterGraef	0:f9b6112278fe	1259	orc = CONFACK; /* Assume success */
DieterGraef	0:f9b6112278fe	1260	cip = p = next; /* Remember begining of CI */
DieterGraef	0:f9b6112278fe	1261	if (l < 2 \|\| /* Not enough data for CI header or */
DieterGraef	0:f9b6112278fe	1262	p[1] < 2 \|\| /* CI length too small or */
DieterGraef	0:f9b6112278fe	1263	p[1] > l) { /* CI length too big? */
DieterGraef	0:f9b6112278fe	1264	LCPDEBUG(LOG_WARNING, ("lcp_reqci: bad CI length!\n"));
DieterGraef	0:f9b6112278fe	1265	orc = CONFREJ; /* Reject bad CI */
DieterGraef	0:f9b6112278fe	1266	cilen = l; /* Reject till end of packet */
DieterGraef	0:f9b6112278fe	1267	l = 0; /* Don't loop again */
DieterGraef	0:f9b6112278fe	1268	citype = 0;
DieterGraef	0:f9b6112278fe	1269	goto endswitch;
DieterGraef	0:f9b6112278fe	1270	}
DieterGraef	0:f9b6112278fe	1271	GETCHAR(citype, p); /* Parse CI type */
DieterGraef	0:f9b6112278fe	1272	GETCHAR(cilen, p); /* Parse CI length */
DieterGraef	0:f9b6112278fe	1273	l -= cilen; /* Adjust remaining length */
DieterGraef	0:f9b6112278fe	1274	next += cilen; /* Step to next CI */
DieterGraef	0:f9b6112278fe	1275
DieterGraef	0:f9b6112278fe	1276	switch (citype) { /* Check CI type */
DieterGraef	0:f9b6112278fe	1277	case CI_MRU:
DieterGraef	0:f9b6112278fe	1278	if (!ao->neg_mru) { /* Allow option? */
DieterGraef	0:f9b6112278fe	1279	LCPDEBUG(LOG_INFO, ("lcp_reqci: Reject MRU - not allowed\n"));
DieterGraef	0:f9b6112278fe	1280	orc = CONFREJ; /* Reject CI */
DieterGraef	0:f9b6112278fe	1281	break;
DieterGraef	0:f9b6112278fe	1282	} else if (cilen != CILEN_SHORT) { /* Check CI length */
DieterGraef	0:f9b6112278fe	1283	LCPDEBUG(LOG_INFO, ("lcp_reqci: Reject MRU - bad length\n"));
DieterGraef	0:f9b6112278fe	1284	orc = CONFREJ; /* Reject CI */
DieterGraef	0:f9b6112278fe	1285	break;
DieterGraef	0:f9b6112278fe	1286	}
DieterGraef	0:f9b6112278fe	1287	GETSHORT(cishort, p); /* Parse MRU */
DieterGraef	0:f9b6112278fe	1288
DieterGraef	0:f9b6112278fe	1289	/*
DieterGraef	0:f9b6112278fe	1290	* He must be able to receive at least our minimum.
DieterGraef	0:f9b6112278fe	1291	* No need to check a maximum. If he sends a large number,
DieterGraef	0:f9b6112278fe	1292	* we'll just ignore it.
DieterGraef	0:f9b6112278fe	1293	*/
DieterGraef	0:f9b6112278fe	1294	if (cishort < PPP_MINMRU) {
DieterGraef	0:f9b6112278fe	1295	LCPDEBUG(LOG_INFO, ("lcp_reqci: Nak - MRU too small\n"));
DieterGraef	0:f9b6112278fe	1296	orc = CONFNAK; /* Nak CI */
DieterGraef	0:f9b6112278fe	1297	PUTCHAR(CI_MRU, nakp);
DieterGraef	0:f9b6112278fe	1298	PUTCHAR(CILEN_SHORT, nakp);
DieterGraef	0:f9b6112278fe	1299	PUTSHORT(PPP_MINMRU, nakp); /* Give him a hint */
DieterGraef	0:f9b6112278fe	1300	break;
DieterGraef	0:f9b6112278fe	1301	}
DieterGraef	0:f9b6112278fe	1302	ho->neg_mru = 1; /* Remember he sent MRU */
DieterGraef	0:f9b6112278fe	1303	ho->mru = cishort; /* And remember value */
DieterGraef	0:f9b6112278fe	1304	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1305	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " MRU %d", cishort);
DieterGraef	0:f9b6112278fe	1306	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1307	#endif
DieterGraef	0:f9b6112278fe	1308	break;
DieterGraef	0:f9b6112278fe	1309
DieterGraef	0:f9b6112278fe	1310	case CI_ASYNCMAP:
DieterGraef	0:f9b6112278fe	1311	if (!ao->neg_asyncmap) {
DieterGraef	0:f9b6112278fe	1312	LCPDEBUG(LOG_INFO, ("lcp_reqci: Reject ASYNCMAP not allowed\n"));
DieterGraef	0:f9b6112278fe	1313	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1314	break;
DieterGraef	0:f9b6112278fe	1315	} else if (cilen != CILEN_LONG) {
DieterGraef	0:f9b6112278fe	1316	LCPDEBUG(LOG_INFO, ("lcp_reqci: Reject ASYNCMAP bad length\n"));
DieterGraef	0:f9b6112278fe	1317	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1318	break;
DieterGraef	0:f9b6112278fe	1319	}
DieterGraef	0:f9b6112278fe	1320	GETLONG(cilong, p);
DieterGraef	0:f9b6112278fe	1321
DieterGraef	0:f9b6112278fe	1322	/*
DieterGraef	0:f9b6112278fe	1323	* Asyncmap must have set at least the bits
DieterGraef	0:f9b6112278fe	1324	* which are set in lcp_allowoptions[unit].asyncmap.
DieterGraef	0:f9b6112278fe	1325	*/
DieterGraef	0:f9b6112278fe	1326	if ((ao->asyncmap & ~cilong) != 0) {
DieterGraef	0:f9b6112278fe	1327	LCPDEBUG(LOG_INFO, ("lcp_reqci: Nak ASYNCMAP %lX missing %lX\n",
DieterGraef	0:f9b6112278fe	1328	cilong, ao->asyncmap));
DieterGraef	0:f9b6112278fe	1329	orc = CONFNAK;
DieterGraef	0:f9b6112278fe	1330	PUTCHAR(CI_ASYNCMAP, nakp);
DieterGraef	0:f9b6112278fe	1331	PUTCHAR(CILEN_LONG, nakp);
DieterGraef	0:f9b6112278fe	1332	PUTLONG(ao->asyncmap \| cilong, nakp);
DieterGraef	0:f9b6112278fe	1333	break;
DieterGraef	0:f9b6112278fe	1334	}
DieterGraef	0:f9b6112278fe	1335	ho->neg_asyncmap = 1;
DieterGraef	0:f9b6112278fe	1336	ho->asyncmap = cilong;
DieterGraef	0:f9b6112278fe	1337	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1338	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " ASYNCMAP=%lX", cilong);
DieterGraef	0:f9b6112278fe	1339	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1340	#endif
DieterGraef	0:f9b6112278fe	1341	break;
DieterGraef	0:f9b6112278fe	1342
DieterGraef	0:f9b6112278fe	1343	case CI_AUTHTYPE:
DieterGraef	0:f9b6112278fe	1344	if (cilen < CILEN_SHORT) {
DieterGraef	0:f9b6112278fe	1345	LCPDEBUG(LOG_INFO, ("lcp_reqci: Reject AUTHTYPE missing arg\n"));
DieterGraef	0:f9b6112278fe	1346	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1347	break;
DieterGraef	0:f9b6112278fe	1348	} else if (!(ao->neg_upap \|\| ao->neg_chap)) {
DieterGraef	0:f9b6112278fe	1349	/*
DieterGraef	0:f9b6112278fe	1350	* Reject the option if we're not willing to authenticate.
DieterGraef	0:f9b6112278fe	1351	*/
DieterGraef	0:f9b6112278fe	1352	LCPDEBUG(LOG_INFO, ("lcp_reqci: Reject AUTHTYPE not allowed\n"));
DieterGraef	0:f9b6112278fe	1353	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1354	break;
DieterGraef	0:f9b6112278fe	1355	}
DieterGraef	0:f9b6112278fe	1356	GETSHORT(cishort, p);
DieterGraef	0:f9b6112278fe	1357
DieterGraef	0:f9b6112278fe	1358	/*
DieterGraef	0:f9b6112278fe	1359	* Authtype must be UPAP or CHAP.
DieterGraef	0:f9b6112278fe	1360	*
DieterGraef	0:f9b6112278fe	1361	* Note: if both ao->neg_upap and ao->neg_chap are set,
DieterGraef	0:f9b6112278fe	1362	* and the peer sends a Configure-Request with two
DieterGraef	0:f9b6112278fe	1363	* authenticate-protocol requests, one for CHAP and one
DieterGraef	0:f9b6112278fe	1364	* for UPAP, then we will reject the second request.
DieterGraef	0:f9b6112278fe	1365	* Whether we end up doing CHAP or UPAP depends then on
DieterGraef	0:f9b6112278fe	1366	* the ordering of the CIs in the peer's Configure-Request.
DieterGraef	0:f9b6112278fe	1367	*/
DieterGraef	0:f9b6112278fe	1368
DieterGraef	0:f9b6112278fe	1369	if (cishort == PPP_PAP) {
DieterGraef	0:f9b6112278fe	1370	if (ho->neg_chap) { /* we've already accepted CHAP */
DieterGraef	0:f9b6112278fe	1371	LCPDEBUG(LOG_WARNING, ("lcp_reqci: Reject AUTHTYPE PAP already accepted\n"));
DieterGraef	0:f9b6112278fe	1372	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1373	break;
DieterGraef	0:f9b6112278fe	1374	} else if (cilen != CILEN_SHORT) {
DieterGraef	0:f9b6112278fe	1375	LCPDEBUG(LOG_WARNING, ("lcp_reqci: Reject AUTHTYPE PAP bad len\n"));
DieterGraef	0:f9b6112278fe	1376	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1377	break;
DieterGraef	0:f9b6112278fe	1378	}
DieterGraef	0:f9b6112278fe	1379	if (!ao->neg_upap) { /* we don't want to do PAP */
DieterGraef	0:f9b6112278fe	1380	LCPDEBUG(LOG_WARNING, ("lcp_reqci: Nak AUTHTYPE PAP not allowed\n"));
DieterGraef	0:f9b6112278fe	1381	orc = CONFNAK; /* NAK it and suggest CHAP */
DieterGraef	0:f9b6112278fe	1382	PUTCHAR(CI_AUTHTYPE, nakp);
DieterGraef	0:f9b6112278fe	1383	PUTCHAR(CILEN_CHAP, nakp);
DieterGraef	0:f9b6112278fe	1384	PUTSHORT(PPP_CHAP, nakp);
DieterGraef	0:f9b6112278fe	1385	PUTCHAR(ao->chap_mdtype, nakp);
DieterGraef	0:f9b6112278fe	1386	break;
DieterGraef	0:f9b6112278fe	1387	}
DieterGraef	0:f9b6112278fe	1388	ho->neg_upap = 1;
DieterGraef	0:f9b6112278fe	1389	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1390	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " PAP (%X)", cishort);
DieterGraef	0:f9b6112278fe	1391	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1392	#endif
DieterGraef	0:f9b6112278fe	1393	break;
DieterGraef	0:f9b6112278fe	1394	}
DieterGraef	0:f9b6112278fe	1395	if (cishort == PPP_CHAP) {
DieterGraef	0:f9b6112278fe	1396	if (ho->neg_upap) { /* we've already accepted PAP */
DieterGraef	0:f9b6112278fe	1397	LCPDEBUG(LOG_WARNING, ("lcp_reqci: Reject AUTHTYPE CHAP accepted PAP\n"));
DieterGraef	0:f9b6112278fe	1398	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1399	break;
DieterGraef	0:f9b6112278fe	1400	} else if (cilen != CILEN_CHAP) {
DieterGraef	0:f9b6112278fe	1401	LCPDEBUG(LOG_WARNING, ("lcp_reqci: Reject AUTHTYPE CHAP bad len\n"));
DieterGraef	0:f9b6112278fe	1402	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1403	break;
DieterGraef	0:f9b6112278fe	1404	}
DieterGraef	0:f9b6112278fe	1405	if (!ao->neg_chap) { /* we don't want to do CHAP */
DieterGraef	0:f9b6112278fe	1406	LCPDEBUG(LOG_WARNING, ("lcp_reqci: Nak AUTHTYPE CHAP not allowed\n"));
DieterGraef	0:f9b6112278fe	1407	orc = CONFNAK; /* NAK it and suggest PAP */
DieterGraef	0:f9b6112278fe	1408	PUTCHAR(CI_AUTHTYPE, nakp);
DieterGraef	0:f9b6112278fe	1409	PUTCHAR(CILEN_SHORT, nakp);
DieterGraef	0:f9b6112278fe	1410	PUTSHORT(PPP_PAP, nakp);
DieterGraef	0:f9b6112278fe	1411	break;
DieterGraef	0:f9b6112278fe	1412	}
DieterGraef	0:f9b6112278fe	1413	GETCHAR(cichar, p); /* get digest type*/
DieterGraef	0:f9b6112278fe	1414	if (cichar != CHAP_DIGEST_MD5
DieterGraef	0:f9b6112278fe	1415	#if MSCHAP_SUPPORT
DieterGraef	0:f9b6112278fe	1416	&& cichar != CHAP_MICROSOFT
DieterGraef	0:f9b6112278fe	1417	#endif
DieterGraef	0:f9b6112278fe	1418	) {
DieterGraef	0:f9b6112278fe	1419	LCPDEBUG(LOG_WARNING, ("lcp_reqci: Nak AUTHTYPE CHAP digest=%d\n", (int)cichar));
DieterGraef	0:f9b6112278fe	1420	orc = CONFNAK;
DieterGraef	0:f9b6112278fe	1421	PUTCHAR(CI_AUTHTYPE, nakp);
DieterGraef	0:f9b6112278fe	1422	PUTCHAR(CILEN_CHAP, nakp);
DieterGraef	0:f9b6112278fe	1423	PUTSHORT(PPP_CHAP, nakp);
DieterGraef	0:f9b6112278fe	1424	PUTCHAR(ao->chap_mdtype, nakp);
DieterGraef	0:f9b6112278fe	1425	break;
DieterGraef	0:f9b6112278fe	1426	}
DieterGraef	0:f9b6112278fe	1427	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1428	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " CHAP %X,%d", cishort, (int)cichar);
DieterGraef	0:f9b6112278fe	1429	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1430	#endif
DieterGraef	0:f9b6112278fe	1431	ho->chap_mdtype = cichar; /* save md type */
DieterGraef	0:f9b6112278fe	1432	ho->neg_chap = 1;
DieterGraef	0:f9b6112278fe	1433	break;
DieterGraef	0:f9b6112278fe	1434	}
DieterGraef	0:f9b6112278fe	1435
DieterGraef	0:f9b6112278fe	1436	/*
DieterGraef	0:f9b6112278fe	1437	* We don't recognize the protocol they're asking for.
DieterGraef	0:f9b6112278fe	1438	* Nak it with something we're willing to do.
DieterGraef	0:f9b6112278fe	1439	* (At this point we know ao->neg_upap \|\| ao->neg_chap.)
DieterGraef	0:f9b6112278fe	1440	*/
DieterGraef	0:f9b6112278fe	1441	orc = CONFNAK;
DieterGraef	0:f9b6112278fe	1442	PUTCHAR(CI_AUTHTYPE, nakp);
DieterGraef	0:f9b6112278fe	1443	if (ao->neg_chap) {
DieterGraef	0:f9b6112278fe	1444	LCPDEBUG(LOG_WARNING, ("lcp_reqci: Nak AUTHTYPE %d req CHAP\n", cishort));
DieterGraef	0:f9b6112278fe	1445	PUTCHAR(CILEN_CHAP, nakp);
DieterGraef	0:f9b6112278fe	1446	PUTSHORT(PPP_CHAP, nakp);
DieterGraef	0:f9b6112278fe	1447	PUTCHAR(ao->chap_mdtype, nakp);
DieterGraef	0:f9b6112278fe	1448	} else {
DieterGraef	0:f9b6112278fe	1449	LCPDEBUG(LOG_WARNING, ("lcp_reqci: Nak AUTHTYPE %d req PAP\n", cishort));
DieterGraef	0:f9b6112278fe	1450	PUTCHAR(CILEN_SHORT, nakp);
DieterGraef	0:f9b6112278fe	1451	PUTSHORT(PPP_PAP, nakp);
DieterGraef	0:f9b6112278fe	1452	}
DieterGraef	0:f9b6112278fe	1453	break;
DieterGraef	0:f9b6112278fe	1454
DieterGraef	0:f9b6112278fe	1455	case CI_QUALITY:
DieterGraef	0:f9b6112278fe	1456	GETSHORT(cishort, p);
DieterGraef	0:f9b6112278fe	1457	GETLONG(cilong, p);
DieterGraef	0:f9b6112278fe	1458	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1459	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " QUALITY (%x %x)", cishort, (unsigned int) cilong);
DieterGraef	0:f9b6112278fe	1460	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1461	#endif
DieterGraef	0:f9b6112278fe	1462
DieterGraef	0:f9b6112278fe	1463	if (!ao->neg_lqr \|\|
DieterGraef	0:f9b6112278fe	1464	cilen != CILEN_LQR) {
DieterGraef	0:f9b6112278fe	1465	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1466	break;
DieterGraef	0:f9b6112278fe	1467	}
DieterGraef	0:f9b6112278fe	1468
DieterGraef	0:f9b6112278fe	1469	/*
DieterGraef	0:f9b6112278fe	1470	* Check the protocol and the reporting period.
DieterGraef	0:f9b6112278fe	1471	* XXX When should we Nak this, and what with?
DieterGraef	0:f9b6112278fe	1472	*/
DieterGraef	0:f9b6112278fe	1473	if (cishort != PPP_LQR) {
DieterGraef	0:f9b6112278fe	1474	orc = CONFNAK;
DieterGraef	0:f9b6112278fe	1475	PUTCHAR(CI_QUALITY, nakp);
DieterGraef	0:f9b6112278fe	1476	PUTCHAR(CILEN_LQR, nakp);
DieterGraef	0:f9b6112278fe	1477	PUTSHORT(PPP_LQR, nakp);
DieterGraef	0:f9b6112278fe	1478	PUTLONG(ao->lqr_period, nakp);
DieterGraef	0:f9b6112278fe	1479	break;
DieterGraef	0:f9b6112278fe	1480	}
DieterGraef	0:f9b6112278fe	1481	break;
DieterGraef	0:f9b6112278fe	1482
DieterGraef	0:f9b6112278fe	1483	case CI_MAGICNUMBER:
DieterGraef	0:f9b6112278fe	1484	if (!(ao->neg_magicnumber \|\| go->neg_magicnumber) \|\|
DieterGraef	0:f9b6112278fe	1485	cilen != CILEN_LONG) {
DieterGraef	0:f9b6112278fe	1486	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1487	break;
DieterGraef	0:f9b6112278fe	1488	}
DieterGraef	0:f9b6112278fe	1489	GETLONG(cilong, p);
DieterGraef	0:f9b6112278fe	1490	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1491	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " MAGICNUMBER (%lX)", cilong);
DieterGraef	0:f9b6112278fe	1492	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1493	#endif
DieterGraef	0:f9b6112278fe	1494
DieterGraef	0:f9b6112278fe	1495	/*
DieterGraef	0:f9b6112278fe	1496	* He must have a different magic number.
DieterGraef	0:f9b6112278fe	1497	*/
DieterGraef	0:f9b6112278fe	1498	if (go->neg_magicnumber &&
DieterGraef	0:f9b6112278fe	1499	cilong == go->magicnumber) {
DieterGraef	0:f9b6112278fe	1500	cilong = magic(); /* Don't put magic() inside macro! */
DieterGraef	0:f9b6112278fe	1501	orc = CONFNAK;
DieterGraef	0:f9b6112278fe	1502	PUTCHAR(CI_MAGICNUMBER, nakp);
DieterGraef	0:f9b6112278fe	1503	PUTCHAR(CILEN_LONG, nakp);
DieterGraef	0:f9b6112278fe	1504	PUTLONG(cilong, nakp);
DieterGraef	0:f9b6112278fe	1505	break;
DieterGraef	0:f9b6112278fe	1506	}
DieterGraef	0:f9b6112278fe	1507	ho->neg_magicnumber = 1;
DieterGraef	0:f9b6112278fe	1508	ho->magicnumber = cilong;
DieterGraef	0:f9b6112278fe	1509	break;
DieterGraef	0:f9b6112278fe	1510
DieterGraef	0:f9b6112278fe	1511
DieterGraef	0:f9b6112278fe	1512	case CI_PCOMPRESSION:
DieterGraef	0:f9b6112278fe	1513	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1514	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " PCOMPRESSION");
DieterGraef	0:f9b6112278fe	1515	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1516	#endif
DieterGraef	0:f9b6112278fe	1517	if (!ao->neg_pcompression \|\|
DieterGraef	0:f9b6112278fe	1518	cilen != CILEN_VOID) {
DieterGraef	0:f9b6112278fe	1519	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1520	break;
DieterGraef	0:f9b6112278fe	1521	}
DieterGraef	0:f9b6112278fe	1522	ho->neg_pcompression = 1;
DieterGraef	0:f9b6112278fe	1523	break;
DieterGraef	0:f9b6112278fe	1524
DieterGraef	0:f9b6112278fe	1525	case CI_ACCOMPRESSION:
DieterGraef	0:f9b6112278fe	1526	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1527	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " ACCOMPRESSION");
DieterGraef	0:f9b6112278fe	1528	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1529	#endif
DieterGraef	0:f9b6112278fe	1530	if (!ao->neg_accompression \|\|
DieterGraef	0:f9b6112278fe	1531	cilen != CILEN_VOID) {
DieterGraef	0:f9b6112278fe	1532	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1533	break;
DieterGraef	0:f9b6112278fe	1534	}
DieterGraef	0:f9b6112278fe	1535	ho->neg_accompression = 1;
DieterGraef	0:f9b6112278fe	1536	break;
DieterGraef	0:f9b6112278fe	1537
DieterGraef	0:f9b6112278fe	1538	case CI_MRRU:
DieterGraef	0:f9b6112278fe	1539	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1540	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " CI_MRRU");
DieterGraef	0:f9b6112278fe	1541	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1542	#endif
DieterGraef	0:f9b6112278fe	1543	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1544	break;
DieterGraef	0:f9b6112278fe	1545
DieterGraef	0:f9b6112278fe	1546	case CI_SSNHF:
DieterGraef	0:f9b6112278fe	1547	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1548	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " CI_SSNHF");
DieterGraef	0:f9b6112278fe	1549	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1550	#endif
DieterGraef	0:f9b6112278fe	1551	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1552	break;
DieterGraef	0:f9b6112278fe	1553
DieterGraef	0:f9b6112278fe	1554	case CI_EPDISC:
DieterGraef	0:f9b6112278fe	1555	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1556	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " CI_EPDISC");
DieterGraef	0:f9b6112278fe	1557	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1558	#endif
DieterGraef	0:f9b6112278fe	1559	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1560	break;
DieterGraef	0:f9b6112278fe	1561
DieterGraef	0:f9b6112278fe	1562	default:
DieterGraef	0:f9b6112278fe	1563	#if TRACELCP
DieterGraef	0:f9b6112278fe	1564	snprintf(&traceBuf[traceNdx], sizeof(traceBuf), " unknown %d", citype);
DieterGraef	0:f9b6112278fe	1565	traceNdx = strlen(traceBuf);
DieterGraef	0:f9b6112278fe	1566	#endif
DieterGraef	0:f9b6112278fe	1567	orc = CONFREJ;
DieterGraef	0:f9b6112278fe	1568	break;
DieterGraef	0:f9b6112278fe	1569	}
DieterGraef	0:f9b6112278fe	1570
DieterGraef	0:f9b6112278fe	1571	endswitch:
DieterGraef	0:f9b6112278fe	1572	#if TRACELCP
DieterGraef	0:f9b6112278fe	1573	if (traceNdx >= 80 - 32) {
DieterGraef	0:f9b6112278fe	1574	LCPDEBUG(LOG_INFO, ("lcp_reqci: rcvd%s\n", traceBuf));
DieterGraef	0:f9b6112278fe	1575	traceNdx = 0;
DieterGraef	0:f9b6112278fe	1576	}
DieterGraef	0:f9b6112278fe	1577	#endif
DieterGraef	0:f9b6112278fe	1578	if (orc == CONFACK && /* Good CI */
DieterGraef	0:f9b6112278fe	1579	rc != CONFACK) { /* but prior CI wasnt? */
DieterGraef	0:f9b6112278fe	1580	continue; /* Don't send this one */
DieterGraef	0:f9b6112278fe	1581	}
DieterGraef	0:f9b6112278fe	1582
DieterGraef	0:f9b6112278fe	1583	if (orc == CONFNAK) { /* Nak this CI? */
DieterGraef	0:f9b6112278fe	1584	if (reject_if_disagree /* Getting fed up with sending NAKs? */
DieterGraef	0:f9b6112278fe	1585	&& citype != CI_MAGICNUMBER) {
DieterGraef	0:f9b6112278fe	1586	orc = CONFREJ; /* Get tough if so */
DieterGraef	0:f9b6112278fe	1587	} else {
DieterGraef	0:f9b6112278fe	1588	if (rc == CONFREJ) { /* Rejecting prior CI? */
DieterGraef	0:f9b6112278fe	1589	continue; /* Don't send this one */
DieterGraef	0:f9b6112278fe	1590	}
DieterGraef	0:f9b6112278fe	1591	rc = CONFNAK;
DieterGraef	0:f9b6112278fe	1592	}
DieterGraef	0:f9b6112278fe	1593	}
DieterGraef	0:f9b6112278fe	1594	if (orc == CONFREJ) { /* Reject this CI */
DieterGraef	0:f9b6112278fe	1595	rc = CONFREJ;
DieterGraef	0:f9b6112278fe	1596	if (cip != rejp) { /* Need to move rejected CI? */
DieterGraef	0:f9b6112278fe	1597	BCOPY(cip, rejp, cilen); /* Move it */
DieterGraef	0:f9b6112278fe	1598	}
DieterGraef	0:f9b6112278fe	1599	INCPTR(cilen, rejp); /* Update output pointer */
DieterGraef	0:f9b6112278fe	1600	}
DieterGraef	0:f9b6112278fe	1601	}
DieterGraef	0:f9b6112278fe	1602
DieterGraef	0:f9b6112278fe	1603	/*
DieterGraef	0:f9b6112278fe	1604	* If we wanted to send additional NAKs (for unsent CIs), the
DieterGraef	0:f9b6112278fe	1605	* code would go here. The extra NAKs would go at *nakp.
DieterGraef	0:f9b6112278fe	1606	* At present there are no cases where we want to ask the
DieterGraef	0:f9b6112278fe	1607	* peer to negotiate an option.
DieterGraef	0:f9b6112278fe	1608	*/
DieterGraef	0:f9b6112278fe	1609
DieterGraef	0:f9b6112278fe	1610	switch (rc) {
DieterGraef	0:f9b6112278fe	1611	case CONFACK:
DieterGraef	0:f9b6112278fe	1612	*lenp = (int)(next - inp);
DieterGraef	0:f9b6112278fe	1613	break;
DieterGraef	0:f9b6112278fe	1614	case CONFNAK:
DieterGraef	0:f9b6112278fe	1615	/*
DieterGraef	0:f9b6112278fe	1616	* Copy the Nak'd options from the nak_buffer to the caller's buffer.
DieterGraef	0:f9b6112278fe	1617	*/
DieterGraef	0:f9b6112278fe	1618	*lenp = (int)(nakp - nak_buffer);
DieterGraef	0:f9b6112278fe	1619	BCOPY(nak_buffer, inp, *lenp);
DieterGraef	0:f9b6112278fe	1620	break;
DieterGraef	0:f9b6112278fe	1621	case CONFREJ:
DieterGraef	0:f9b6112278fe	1622	*lenp = (int)(rejp - inp);
DieterGraef	0:f9b6112278fe	1623	break;
DieterGraef	0:f9b6112278fe	1624	}
DieterGraef	0:f9b6112278fe	1625
DieterGraef	0:f9b6112278fe	1626	#if TRACELCP > 0
DieterGraef	0:f9b6112278fe	1627	if (traceNdx > 0) {
DieterGraef	0:f9b6112278fe	1628	LCPDEBUG(LOG_INFO, ("lcp_reqci: %s\n", traceBuf));
DieterGraef	0:f9b6112278fe	1629	}
DieterGraef	0:f9b6112278fe	1630	#endif
DieterGraef	0:f9b6112278fe	1631	LCPDEBUG(LOG_INFO, ("lcp_reqci: returning CONF%s.\n", CODENAME(rc)));
DieterGraef	0:f9b6112278fe	1632	return (rc); /* Return final code */
DieterGraef	0:f9b6112278fe	1633	}
DieterGraef	0:f9b6112278fe	1634
DieterGraef	0:f9b6112278fe	1635
DieterGraef	0:f9b6112278fe	1636	/*
DieterGraef	0:f9b6112278fe	1637	* lcp_up - LCP has come UP.
DieterGraef	0:f9b6112278fe	1638	*/
DieterGraef	0:f9b6112278fe	1639	static void
DieterGraef	0:f9b6112278fe	1640	lcp_up(fsm *f)
DieterGraef	0:f9b6112278fe	1641	{
DieterGraef	0:f9b6112278fe	1642	lcp_options *wo = &lcp_wantoptions[f->unit];
DieterGraef	0:f9b6112278fe	1643	lcp_options *ho = &lcp_hisoptions[f->unit];
DieterGraef	0:f9b6112278fe	1644	lcp_options *go = &lcp_gotoptions[f->unit];
DieterGraef	0:f9b6112278fe	1645	lcp_options *ao = &lcp_allowoptions[f->unit];
DieterGraef	0:f9b6112278fe	1646
DieterGraef	0:f9b6112278fe	1647	if (!go->neg_magicnumber) {
DieterGraef	0:f9b6112278fe	1648	go->magicnumber = 0;
DieterGraef	0:f9b6112278fe	1649	}
DieterGraef	0:f9b6112278fe	1650	if (!ho->neg_magicnumber) {
DieterGraef	0:f9b6112278fe	1651	ho->magicnumber = 0;
DieterGraef	0:f9b6112278fe	1652	}
DieterGraef	0:f9b6112278fe	1653
DieterGraef	0:f9b6112278fe	1654	/*
DieterGraef	0:f9b6112278fe	1655	* Set our MTU to the smaller of the MTU we wanted and
DieterGraef	0:f9b6112278fe	1656	* the MRU our peer wanted. If we negotiated an MRU,
DieterGraef	0:f9b6112278fe	1657	* set our MRU to the larger of value we wanted and
DieterGraef	0:f9b6112278fe	1658	* the value we got in the negotiation.
DieterGraef	0:f9b6112278fe	1659	*/
DieterGraef	0:f9b6112278fe	1660	ppp_send_config(f->unit, LWIP_MIN(ao->mru, (ho->neg_mru? ho->mru: PPP_MRU)),
DieterGraef	0:f9b6112278fe	1661	(ho->neg_asyncmap? ho->asyncmap: 0xffffffffl),
DieterGraef	0:f9b6112278fe	1662	ho->neg_pcompression, ho->neg_accompression);
DieterGraef	0:f9b6112278fe	1663	/*
DieterGraef	0:f9b6112278fe	1664	* If the asyncmap hasn't been negotiated, we really should
DieterGraef	0:f9b6112278fe	1665	* set the receive asyncmap to ffffffff, but we set it to 0
DieterGraef	0:f9b6112278fe	1666	* for backwards contemptibility.
DieterGraef	0:f9b6112278fe	1667	*/
DieterGraef	0:f9b6112278fe	1668	ppp_recv_config(f->unit, (go->neg_mru? LWIP_MAX(wo->mru, go->mru): PPP_MRU),
DieterGraef	0:f9b6112278fe	1669	(go->neg_asyncmap? go->asyncmap: 0x00000000),
DieterGraef	0:f9b6112278fe	1670	go->neg_pcompression, go->neg_accompression);
DieterGraef	0:f9b6112278fe	1671
DieterGraef	0:f9b6112278fe	1672	if (ho->neg_mru) {
DieterGraef	0:f9b6112278fe	1673	peer_mru[f->unit] = ho->mru;
DieterGraef	0:f9b6112278fe	1674	}
DieterGraef	0:f9b6112278fe	1675
DieterGraef	0:f9b6112278fe	1676	lcp_echo_lowerup(f->unit); /* Enable echo messages */
DieterGraef	0:f9b6112278fe	1677
DieterGraef	0:f9b6112278fe	1678	link_established(f->unit); /* The link is up; authenticate now */
DieterGraef	0:f9b6112278fe	1679	}
DieterGraef	0:f9b6112278fe	1680
DieterGraef	0:f9b6112278fe	1681
DieterGraef	0:f9b6112278fe	1682	/*
DieterGraef	0:f9b6112278fe	1683	* lcp_down - LCP has gone DOWN.
DieterGraef	0:f9b6112278fe	1684	*
DieterGraef	0:f9b6112278fe	1685	* Alert other protocols.
DieterGraef	0:f9b6112278fe	1686	*/
DieterGraef	0:f9b6112278fe	1687	static void
DieterGraef	0:f9b6112278fe	1688	lcp_down(fsm *f)
DieterGraef	0:f9b6112278fe	1689	{
DieterGraef	0:f9b6112278fe	1690	lcp_options *go = &lcp_gotoptions[f->unit];
DieterGraef	0:f9b6112278fe	1691
DieterGraef	0:f9b6112278fe	1692	lcp_echo_lowerdown(f->unit);
DieterGraef	0:f9b6112278fe	1693
DieterGraef	0:f9b6112278fe	1694	link_down(f->unit);
DieterGraef	0:f9b6112278fe	1695
DieterGraef	0:f9b6112278fe	1696	ppp_send_config(f->unit, PPP_MRU, 0xffffffffl, 0, 0);
DieterGraef	0:f9b6112278fe	1697	ppp_recv_config(f->unit, PPP_MRU,
DieterGraef	0:f9b6112278fe	1698	(go->neg_asyncmap? go->asyncmap: 0x00000000),
DieterGraef	0:f9b6112278fe	1699	go->neg_pcompression, go->neg_accompression);
DieterGraef	0:f9b6112278fe	1700	peer_mru[f->unit] = PPP_MRU;
DieterGraef	0:f9b6112278fe	1701	}
DieterGraef	0:f9b6112278fe	1702
DieterGraef	0:f9b6112278fe	1703
DieterGraef	0:f9b6112278fe	1704	/*
DieterGraef	0:f9b6112278fe	1705	* lcp_starting - LCP needs the lower layer up.
DieterGraef	0:f9b6112278fe	1706	*/
DieterGraef	0:f9b6112278fe	1707	static void
DieterGraef	0:f9b6112278fe	1708	lcp_starting(fsm *f)
DieterGraef	0:f9b6112278fe	1709	{
DieterGraef	0:f9b6112278fe	1710	link_required(f->unit); /* lwip: currently does nothing */
DieterGraef	0:f9b6112278fe	1711	}
DieterGraef	0:f9b6112278fe	1712
DieterGraef	0:f9b6112278fe	1713
DieterGraef	0:f9b6112278fe	1714	/*
DieterGraef	0:f9b6112278fe	1715	* lcp_finished - LCP has finished with the lower layer.
DieterGraef	0:f9b6112278fe	1716	*/
DieterGraef	0:f9b6112278fe	1717	static void
DieterGraef	0:f9b6112278fe	1718	lcp_finished(fsm *f)
DieterGraef	0:f9b6112278fe	1719	{
DieterGraef	0:f9b6112278fe	1720	link_terminated(f->unit); /* we are finished with the link */
DieterGraef	0:f9b6112278fe	1721	}
DieterGraef	0:f9b6112278fe	1722
DieterGraef	0:f9b6112278fe	1723
DieterGraef	0:f9b6112278fe	1724	#if PPP_ADDITIONAL_CALLBACKS
DieterGraef	0:f9b6112278fe	1725	/*
DieterGraef	0:f9b6112278fe	1726	* print_string - print a readable representation of a string using
DieterGraef	0:f9b6112278fe	1727	* printer.
DieterGraef	0:f9b6112278fe	1728	*/
DieterGraef	0:f9b6112278fe	1729	static void
DieterGraef	0:f9b6112278fe	1730	print_string( char p, int len, void (printer) (void , char , ...), void *arg)
DieterGraef	0:f9b6112278fe	1731	{
DieterGraef	0:f9b6112278fe	1732	int c;
DieterGraef	0:f9b6112278fe	1733
DieterGraef	0:f9b6112278fe	1734	printer(arg, "\"");
DieterGraef	0:f9b6112278fe	1735	for (; len > 0; --len) {
DieterGraef	0:f9b6112278fe	1736	c = *p++;
DieterGraef	0:f9b6112278fe	1737	if (' ' <= c && c <= '~') {
DieterGraef	0:f9b6112278fe	1738	if (c == '\\' \|\| c == '"') {
DieterGraef	0:f9b6112278fe	1739	printer(arg, "\\");
DieterGraef	0:f9b6112278fe	1740	}
DieterGraef	0:f9b6112278fe	1741	printer(arg, "%c", c);
DieterGraef	0:f9b6112278fe	1742	} else {
DieterGraef	0:f9b6112278fe	1743	switch (c) {
DieterGraef	0:f9b6112278fe	1744	case '\n':
DieterGraef	0:f9b6112278fe	1745	printer(arg, "\\n");
DieterGraef	0:f9b6112278fe	1746	break;
DieterGraef	0:f9b6112278fe	1747	case '\r':
DieterGraef	0:f9b6112278fe	1748	printer(arg, "\\r");
DieterGraef	0:f9b6112278fe	1749	break;
DieterGraef	0:f9b6112278fe	1750	case '\t':
DieterGraef	0:f9b6112278fe	1751	printer(arg, "\\t");
DieterGraef	0:f9b6112278fe	1752	break;
DieterGraef	0:f9b6112278fe	1753	default:
DieterGraef	0:f9b6112278fe	1754	printer(arg, "\\%.3o", c);
DieterGraef	0:f9b6112278fe	1755	}
DieterGraef	0:f9b6112278fe	1756	}
DieterGraef	0:f9b6112278fe	1757	}
DieterGraef	0:f9b6112278fe	1758	printer(arg, "\"");
DieterGraef	0:f9b6112278fe	1759	}
DieterGraef	0:f9b6112278fe	1760
DieterGraef	0:f9b6112278fe	1761
DieterGraef	0:f9b6112278fe	1762	/*
DieterGraef	0:f9b6112278fe	1763	* lcp_printpkt - print the contents of an LCP packet.
DieterGraef	0:f9b6112278fe	1764	*/
DieterGraef	0:f9b6112278fe	1765	static char *lcp_codenames[] = {
DieterGraef	0:f9b6112278fe	1766	"ConfReq", "ConfAck", "ConfNak", "ConfRej",
DieterGraef	0:f9b6112278fe	1767	"TermReq", "TermAck", "CodeRej", "ProtRej",
DieterGraef	0:f9b6112278fe	1768	"EchoReq", "EchoRep", "DiscReq"
DieterGraef	0:f9b6112278fe	1769	};
DieterGraef	0:f9b6112278fe	1770
DieterGraef	0:f9b6112278fe	1771	static int
DieterGraef	0:f9b6112278fe	1772	lcp_printpkt( u_char p, int plen, void (printer) (void , char , ...), void *arg)
DieterGraef	0:f9b6112278fe	1773	{
DieterGraef	0:f9b6112278fe	1774	int code, id, len, olen;
DieterGraef	0:f9b6112278fe	1775	u_char pstart, optend;
DieterGraef	0:f9b6112278fe	1776	u_short cishort;
DieterGraef	0:f9b6112278fe	1777	u32_t cilong;
DieterGraef	0:f9b6112278fe	1778
DieterGraef	0:f9b6112278fe	1779	if (plen < HEADERLEN) {
DieterGraef	0:f9b6112278fe	1780	return 0;
DieterGraef	0:f9b6112278fe	1781	}
DieterGraef	0:f9b6112278fe	1782	pstart = p;
DieterGraef	0:f9b6112278fe	1783	GETCHAR(code, p);
DieterGraef	0:f9b6112278fe	1784	GETCHAR(id, p);
DieterGraef	0:f9b6112278fe	1785	GETSHORT(len, p);
DieterGraef	0:f9b6112278fe	1786	if (len < HEADERLEN \|\| len > plen) {
DieterGraef	0:f9b6112278fe	1787	return 0;
DieterGraef	0:f9b6112278fe	1788	}
DieterGraef	0:f9b6112278fe	1789
DieterGraef	0:f9b6112278fe	1790	if (code >= 1 && code <= sizeof(lcp_codenames) / sizeof(char *)) {
DieterGraef	0:f9b6112278fe	1791	printer(arg, " %s", lcp_codenames[code-1]);
DieterGraef	0:f9b6112278fe	1792	} else {
DieterGraef	0:f9b6112278fe	1793	printer(arg, " code=0x%x", code);
DieterGraef	0:f9b6112278fe	1794	}
DieterGraef	0:f9b6112278fe	1795	printer(arg, " id=0x%x", id);
DieterGraef	0:f9b6112278fe	1796	len -= HEADERLEN;
DieterGraef	0:f9b6112278fe	1797	switch (code) {
DieterGraef	0:f9b6112278fe	1798	case CONFREQ:
DieterGraef	0:f9b6112278fe	1799	case CONFACK:
DieterGraef	0:f9b6112278fe	1800	case CONFNAK:
DieterGraef	0:f9b6112278fe	1801	case CONFREJ:
DieterGraef	0:f9b6112278fe	1802	/* print option list */
DieterGraef	0:f9b6112278fe	1803	while (len >= 2) {
DieterGraef	0:f9b6112278fe	1804	GETCHAR(code, p);
DieterGraef	0:f9b6112278fe	1805	GETCHAR(olen, p);
DieterGraef	0:f9b6112278fe	1806	p -= 2;
DieterGraef	0:f9b6112278fe	1807	if (olen < 2 \|\| olen > len) {
DieterGraef	0:f9b6112278fe	1808	break;
DieterGraef	0:f9b6112278fe	1809	}
DieterGraef	0:f9b6112278fe	1810	printer(arg, " <");
DieterGraef	0:f9b6112278fe	1811	len -= olen;
DieterGraef	0:f9b6112278fe	1812	optend = p + olen;
DieterGraef	0:f9b6112278fe	1813	switch (code) {
DieterGraef	0:f9b6112278fe	1814	case CI_MRU:
DieterGraef	0:f9b6112278fe	1815	if (olen == CILEN_SHORT) {
DieterGraef	0:f9b6112278fe	1816	p += 2;
DieterGraef	0:f9b6112278fe	1817	GETSHORT(cishort, p);
DieterGraef	0:f9b6112278fe	1818	printer(arg, "mru %d", cishort);
DieterGraef	0:f9b6112278fe	1819	}
DieterGraef	0:f9b6112278fe	1820	break;
DieterGraef	0:f9b6112278fe	1821	case CI_ASYNCMAP:
DieterGraef	0:f9b6112278fe	1822	if (olen == CILEN_LONG) {
DieterGraef	0:f9b6112278fe	1823	p += 2;
DieterGraef	0:f9b6112278fe	1824	GETLONG(cilong, p);
DieterGraef	0:f9b6112278fe	1825	printer(arg, "asyncmap 0x%lx", cilong);
DieterGraef	0:f9b6112278fe	1826	}
DieterGraef	0:f9b6112278fe	1827	break;
DieterGraef	0:f9b6112278fe	1828	case CI_AUTHTYPE:
DieterGraef	0:f9b6112278fe	1829	if (olen >= CILEN_SHORT) {
DieterGraef	0:f9b6112278fe	1830	p += 2;
DieterGraef	0:f9b6112278fe	1831	printer(arg, "auth ");
DieterGraef	0:f9b6112278fe	1832	GETSHORT(cishort, p);
DieterGraef	0:f9b6112278fe	1833	switch (cishort) {
DieterGraef	0:f9b6112278fe	1834	case PPP_PAP:
DieterGraef	0:f9b6112278fe	1835	printer(arg, "pap");
DieterGraef	0:f9b6112278fe	1836	break;
DieterGraef	0:f9b6112278fe	1837	case PPP_CHAP:
DieterGraef	0:f9b6112278fe	1838	printer(arg, "chap");
DieterGraef	0:f9b6112278fe	1839	break;
DieterGraef	0:f9b6112278fe	1840	default:
DieterGraef	0:f9b6112278fe	1841	printer(arg, "0x%x", cishort);
DieterGraef	0:f9b6112278fe	1842	}
DieterGraef	0:f9b6112278fe	1843	}
DieterGraef	0:f9b6112278fe	1844	break;
DieterGraef	0:f9b6112278fe	1845	case CI_QUALITY:
DieterGraef	0:f9b6112278fe	1846	if (olen >= CILEN_SHORT) {
DieterGraef	0:f9b6112278fe	1847	p += 2;
DieterGraef	0:f9b6112278fe	1848	printer(arg, "quality ");
DieterGraef	0:f9b6112278fe	1849	GETSHORT(cishort, p);
DieterGraef	0:f9b6112278fe	1850	switch (cishort) {
DieterGraef	0:f9b6112278fe	1851	case PPP_LQR:
DieterGraef	0:f9b6112278fe	1852	printer(arg, "lqr");
DieterGraef	0:f9b6112278fe	1853	break;
DieterGraef	0:f9b6112278fe	1854	default:
DieterGraef	0:f9b6112278fe	1855	printer(arg, "0x%x", cishort);
DieterGraef	0:f9b6112278fe	1856	}
DieterGraef	0:f9b6112278fe	1857	}
DieterGraef	0:f9b6112278fe	1858	break;
DieterGraef	0:f9b6112278fe	1859	case CI_CALLBACK:
DieterGraef	0:f9b6112278fe	1860	if (olen >= CILEN_CHAR) {
DieterGraef	0:f9b6112278fe	1861	p += 2;
DieterGraef	0:f9b6112278fe	1862	printer(arg, "callback ");
DieterGraef	0:f9b6112278fe	1863	GETSHORT(cishort, p);
DieterGraef	0:f9b6112278fe	1864	switch (cishort) {
DieterGraef	0:f9b6112278fe	1865	case CBCP_OPT:
DieterGraef	0:f9b6112278fe	1866	printer(arg, "CBCP");
DieterGraef	0:f9b6112278fe	1867	break;
DieterGraef	0:f9b6112278fe	1868	default:
DieterGraef	0:f9b6112278fe	1869	printer(arg, "0x%x", cishort);
DieterGraef	0:f9b6112278fe	1870	}
DieterGraef	0:f9b6112278fe	1871	}
DieterGraef	0:f9b6112278fe	1872	break;
DieterGraef	0:f9b6112278fe	1873	case CI_MAGICNUMBER:
DieterGraef	0:f9b6112278fe	1874	if (olen == CILEN_LONG) {
DieterGraef	0:f9b6112278fe	1875	p += 2;
DieterGraef	0:f9b6112278fe	1876	GETLONG(cilong, p);
DieterGraef	0:f9b6112278fe	1877	printer(arg, "magic 0x%x", cilong);
DieterGraef	0:f9b6112278fe	1878	}
DieterGraef	0:f9b6112278fe	1879	break;
DieterGraef	0:f9b6112278fe	1880	case CI_PCOMPRESSION:
DieterGraef	0:f9b6112278fe	1881	if (olen == CILEN_VOID) {
DieterGraef	0:f9b6112278fe	1882	p += 2;
DieterGraef	0:f9b6112278fe	1883	printer(arg, "pcomp");
DieterGraef	0:f9b6112278fe	1884	}
DieterGraef	0:f9b6112278fe	1885	break;
DieterGraef	0:f9b6112278fe	1886	case CI_ACCOMPRESSION:
DieterGraef	0:f9b6112278fe	1887	if (olen == CILEN_VOID) {
DieterGraef	0:f9b6112278fe	1888	p += 2;
DieterGraef	0:f9b6112278fe	1889	printer(arg, "accomp");
DieterGraef	0:f9b6112278fe	1890	}
DieterGraef	0:f9b6112278fe	1891	break;
DieterGraef	0:f9b6112278fe	1892	}
DieterGraef	0:f9b6112278fe	1893	while (p < optend) {
DieterGraef	0:f9b6112278fe	1894	GETCHAR(code, p);
DieterGraef	0:f9b6112278fe	1895	printer(arg, " %.2x", code);
DieterGraef	0:f9b6112278fe	1896	}
DieterGraef	0:f9b6112278fe	1897	printer(arg, ">");
DieterGraef	0:f9b6112278fe	1898	}
DieterGraef	0:f9b6112278fe	1899	break;
DieterGraef	0:f9b6112278fe	1900
DieterGraef	0:f9b6112278fe	1901	case TERMACK:
DieterGraef	0:f9b6112278fe	1902	case TERMREQ:
DieterGraef	0:f9b6112278fe	1903	if (len > 0 && p >= ' ' && p < 0x7f) {
DieterGraef	0:f9b6112278fe	1904	printer(arg, " ");
DieterGraef	0:f9b6112278fe	1905	print_string((char*)p, len, printer, arg);
DieterGraef	0:f9b6112278fe	1906	p += len;
DieterGraef	0:f9b6112278fe	1907	len = 0;
DieterGraef	0:f9b6112278fe	1908	}
DieterGraef	0:f9b6112278fe	1909	break;
DieterGraef	0:f9b6112278fe	1910
DieterGraef	0:f9b6112278fe	1911	case ECHOREQ:
DieterGraef	0:f9b6112278fe	1912	case ECHOREP:
DieterGraef	0:f9b6112278fe	1913	case DISCREQ:
DieterGraef	0:f9b6112278fe	1914	if (len >= 4) {
DieterGraef	0:f9b6112278fe	1915	GETLONG(cilong, p);
DieterGraef	0:f9b6112278fe	1916	printer(arg, " magic=0x%x", cilong);
DieterGraef	0:f9b6112278fe	1917	p += 4;
DieterGraef	0:f9b6112278fe	1918	len -= 4;
DieterGraef	0:f9b6112278fe	1919	}
DieterGraef	0:f9b6112278fe	1920	break;
DieterGraef	0:f9b6112278fe	1921	}
DieterGraef	0:f9b6112278fe	1922
DieterGraef	0:f9b6112278fe	1923	/* print the rest of the bytes in the packet */
DieterGraef	0:f9b6112278fe	1924	for (; len > 0; --len) {
DieterGraef	0:f9b6112278fe	1925	GETCHAR(code, p);
DieterGraef	0:f9b6112278fe	1926	printer(arg, " %.2x", code);
DieterGraef	0:f9b6112278fe	1927	}
DieterGraef	0:f9b6112278fe	1928
DieterGraef	0:f9b6112278fe	1929	return (int)(p - pstart);
DieterGraef	0:f9b6112278fe	1930	}
DieterGraef	0:f9b6112278fe	1931	#endif /* PPP_ADDITIONAL_CALLBACKS */
DieterGraef	0:f9b6112278fe	1932
DieterGraef	0:f9b6112278fe	1933	/*
DieterGraef	0:f9b6112278fe	1934	* Time to shut down the link because there is nothing out there.
DieterGraef	0:f9b6112278fe	1935	*/
DieterGraef	0:f9b6112278fe	1936	static void
DieterGraef	0:f9b6112278fe	1937	LcpLinkFailure (fsm *f)
DieterGraef	0:f9b6112278fe	1938	{
DieterGraef	0:f9b6112278fe	1939	if (f->state == LS_OPENED) {
DieterGraef	0:f9b6112278fe	1940	LCPDEBUG(LOG_INFO, ("No response to %d echo-requests\n", lcp_echos_pending));
DieterGraef	0:f9b6112278fe	1941	LCPDEBUG(LOG_NOTICE, ("Serial link appears to be disconnected.\n"));
DieterGraef	0:f9b6112278fe	1942	lcp_close(f->unit, "Peer not responding");
DieterGraef	0:f9b6112278fe	1943	}
DieterGraef	0:f9b6112278fe	1944	}
DieterGraef	0:f9b6112278fe	1945
DieterGraef	0:f9b6112278fe	1946	/*
DieterGraef	0:f9b6112278fe	1947	* Timer expired for the LCP echo requests from this process.
DieterGraef	0:f9b6112278fe	1948	*/
DieterGraef	0:f9b6112278fe	1949	static void
DieterGraef	0:f9b6112278fe	1950	LcpEchoCheck (fsm *f)
DieterGraef	0:f9b6112278fe	1951	{
DieterGraef	0:f9b6112278fe	1952	LcpSendEchoRequest (f);
DieterGraef	0:f9b6112278fe	1953
DieterGraef	0:f9b6112278fe	1954	/*
DieterGraef	0:f9b6112278fe	1955	* Start the timer for the next interval.
DieterGraef	0:f9b6112278fe	1956	*/
DieterGraef	0:f9b6112278fe	1957	LWIP_ASSERT("lcp_echo_timer_running == 0", lcp_echo_timer_running == 0);
DieterGraef	0:f9b6112278fe	1958
DieterGraef	0:f9b6112278fe	1959	TIMEOUT (LcpEchoTimeout, f, lcp_echo_interval);
DieterGraef	0:f9b6112278fe	1960	lcp_echo_timer_running = 1;
DieterGraef	0:f9b6112278fe	1961	}
DieterGraef	0:f9b6112278fe	1962
DieterGraef	0:f9b6112278fe	1963	/*
DieterGraef	0:f9b6112278fe	1964	* LcpEchoTimeout - Timer expired on the LCP echo
DieterGraef	0:f9b6112278fe	1965	*/
DieterGraef	0:f9b6112278fe	1966	static void
DieterGraef	0:f9b6112278fe	1967	LcpEchoTimeout (void *arg)
DieterGraef	0:f9b6112278fe	1968	{
DieterGraef	0:f9b6112278fe	1969	if (lcp_echo_timer_running != 0) {
DieterGraef	0:f9b6112278fe	1970	lcp_echo_timer_running = 0;
DieterGraef	0:f9b6112278fe	1971	LcpEchoCheck ((fsm *) arg);
DieterGraef	0:f9b6112278fe	1972	}
DieterGraef	0:f9b6112278fe	1973	}
DieterGraef	0:f9b6112278fe	1974
DieterGraef	0:f9b6112278fe	1975	/*
DieterGraef	0:f9b6112278fe	1976	* LcpEchoReply - LCP has received a reply to the echo
DieterGraef	0:f9b6112278fe	1977	*/
DieterGraef	0:f9b6112278fe	1978	static void
DieterGraef	0:f9b6112278fe	1979	lcp_received_echo_reply (fsm f, int id, u_char inp, int len)
DieterGraef	0:f9b6112278fe	1980	{
DieterGraef	0:f9b6112278fe	1981	u32_t magic;
DieterGraef	0:f9b6112278fe	1982
DieterGraef	0:f9b6112278fe	1983	LWIP_UNUSED_ARG(id);
DieterGraef	0:f9b6112278fe	1984
DieterGraef	0:f9b6112278fe	1985	/* Check the magic number - don't count replies from ourselves. */
DieterGraef	0:f9b6112278fe	1986	if (len < 4) {
DieterGraef	0:f9b6112278fe	1987	LCPDEBUG(LOG_WARNING, ("lcp: received short Echo-Reply, length %d\n", len));
DieterGraef	0:f9b6112278fe	1988	return;
DieterGraef	0:f9b6112278fe	1989	}
DieterGraef	0:f9b6112278fe	1990	GETLONG(magic, inp);
DieterGraef	0:f9b6112278fe	1991	if (lcp_gotoptions[f->unit].neg_magicnumber && magic == lcp_gotoptions[f->unit].magicnumber) {
DieterGraef	0:f9b6112278fe	1992	LCPDEBUG(LOG_WARNING, ("appear to have received our own echo-reply!\n"));
DieterGraef	0:f9b6112278fe	1993	return;
DieterGraef	0:f9b6112278fe	1994	}
DieterGraef	0:f9b6112278fe	1995
DieterGraef	0:f9b6112278fe	1996	/* Reset the number of outstanding echo frames */
DieterGraef	0:f9b6112278fe	1997	lcp_echos_pending = 0;
DieterGraef	0:f9b6112278fe	1998	}
DieterGraef	0:f9b6112278fe	1999
DieterGraef	0:f9b6112278fe	2000	/*
DieterGraef	0:f9b6112278fe	2001	* LcpSendEchoRequest - Send an echo request frame to the peer
DieterGraef	0:f9b6112278fe	2002	*/
DieterGraef	0:f9b6112278fe	2003	static void
DieterGraef	0:f9b6112278fe	2004	LcpSendEchoRequest (fsm *f)
DieterGraef	0:f9b6112278fe	2005	{
DieterGraef	0:f9b6112278fe	2006	u32_t lcp_magic;
DieterGraef	0:f9b6112278fe	2007	u_char pkt[4], *pktp;
DieterGraef	0:f9b6112278fe	2008
DieterGraef	0:f9b6112278fe	2009	/*
DieterGraef	0:f9b6112278fe	2010	* Detect the failure of the peer at this point.
DieterGraef	0:f9b6112278fe	2011	*/
DieterGraef	0:f9b6112278fe	2012	if (lcp_echo_fails != 0) {
DieterGraef	0:f9b6112278fe	2013	if (lcp_echos_pending >= lcp_echo_fails) {
DieterGraef	0:f9b6112278fe	2014	LcpLinkFailure(f);
DieterGraef	0:f9b6112278fe	2015	lcp_echos_pending = 0;
DieterGraef	0:f9b6112278fe	2016	}
DieterGraef	0:f9b6112278fe	2017	}
DieterGraef	0:f9b6112278fe	2018
DieterGraef	0:f9b6112278fe	2019	/*
DieterGraef	0:f9b6112278fe	2020	* Make and send the echo request frame.
DieterGraef	0:f9b6112278fe	2021	*/
DieterGraef	0:f9b6112278fe	2022	if (f->state == LS_OPENED) {
DieterGraef	0:f9b6112278fe	2023	lcp_magic = lcp_gotoptions[f->unit].magicnumber;
DieterGraef	0:f9b6112278fe	2024	pktp = pkt;
DieterGraef	0:f9b6112278fe	2025	PUTLONG(lcp_magic, pktp);
DieterGraef	0:f9b6112278fe	2026	fsm_sdata(f, ECHOREQ, (u_char)(lcp_echo_number++ & 0xFF), pkt, (int)(pktp - pkt));
DieterGraef	0:f9b6112278fe	2027	++lcp_echos_pending;
DieterGraef	0:f9b6112278fe	2028	}
DieterGraef	0:f9b6112278fe	2029	}
DieterGraef	0:f9b6112278fe	2030
DieterGraef	0:f9b6112278fe	2031	/*
DieterGraef	0:f9b6112278fe	2032	* lcp_echo_lowerup - Start the timer for the LCP frame
DieterGraef	0:f9b6112278fe	2033	*/
DieterGraef	0:f9b6112278fe	2034
DieterGraef	0:f9b6112278fe	2035	static void
DieterGraef	0:f9b6112278fe	2036	lcp_echo_lowerup (int unit)
DieterGraef	0:f9b6112278fe	2037	{
DieterGraef	0:f9b6112278fe	2038	fsm *f = &lcp_fsm[unit];
DieterGraef	0:f9b6112278fe	2039
DieterGraef	0:f9b6112278fe	2040	/* Clear the parameters for generating echo frames */
DieterGraef	0:f9b6112278fe	2041	lcp_echos_pending = 0;
DieterGraef	0:f9b6112278fe	2042	lcp_echo_number = 0;
DieterGraef	0:f9b6112278fe	2043	lcp_echo_timer_running = 0;
DieterGraef	0:f9b6112278fe	2044
DieterGraef	0:f9b6112278fe	2045	/* If a timeout interval is specified then start the timer */
DieterGraef	0:f9b6112278fe	2046	if (lcp_echo_interval != 0) {
DieterGraef	0:f9b6112278fe	2047	LcpEchoCheck (f);
DieterGraef	0:f9b6112278fe	2048	}
DieterGraef	0:f9b6112278fe	2049	}
DieterGraef	0:f9b6112278fe	2050
DieterGraef	0:f9b6112278fe	2051	/*
DieterGraef	0:f9b6112278fe	2052	* lcp_echo_lowerdown - Stop the timer for the LCP frame
DieterGraef	0:f9b6112278fe	2053	*/
DieterGraef	0:f9b6112278fe	2054
DieterGraef	0:f9b6112278fe	2055	static void
DieterGraef	0:f9b6112278fe	2056	lcp_echo_lowerdown (int unit)
DieterGraef	0:f9b6112278fe	2057	{
DieterGraef	0:f9b6112278fe	2058	fsm *f = &lcp_fsm[unit];
DieterGraef	0:f9b6112278fe	2059
DieterGraef	0:f9b6112278fe	2060	if (lcp_echo_timer_running != 0) {
DieterGraef	0:f9b6112278fe	2061	UNTIMEOUT (LcpEchoTimeout, f);
DieterGraef	0:f9b6112278fe	2062	lcp_echo_timer_running = 0;
DieterGraef	0:f9b6112278fe	2063	}
DieterGraef	0:f9b6112278fe	2064	}
DieterGraef	0:f9b6112278fe	2065
DieterGraef	0:f9b6112278fe	2066	#endif /* PPP_SUPPORT */

Repository toolbox

Export to desktop IDE

Build repository

Repository details

Type:	Program
Mbed OS support:	Mbed 2 deprecated
Created:	07 Feb 2018
Imports:	0
Forks:	0
Commits:	5
Dependents:	0
Dependencies:	4
Followers:	1

F7_Ethernet/lwip/netif/ppp/lcp.c@0:f9b6112278fe, 2016-06-18 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning