if_spppsubr.c revision 12495
167957Skris/* 267957Skris * Synchronous PPP/Cisco link level subroutines. 367957Skris * Keepalive protocol implemented in both Cisco and PPP modes. 467957Skris * 567957Skris * Copyright (C) 1994 Cronyx Ltd. 667957Skris * Author: Serge Vakulenko, <vak@zebub.msk.su> 767957Skris * 867957Skris * This software is distributed with NO WARRANTIES, not even the implied 967957Skris * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 1067957Skris * 1167957Skris * Authors grant any other persons or organisations permission to use 1267957Skris * or modify this software as long as this message is kept with the software, 1367957Skris * all derivative works or modified versions. 1467957Skris * 1567957Skris * Version 1.9, Wed Oct 4 18:58:15 MSK 1995 1667957Skris */ 1767957Skris#undef DEBUG 1867957Skris 1967957Skris#include <sys/param.h> 2067957Skris#include <sys/systm.h> 2167957Skris#include <sys/kernel.h> 2267957Skris#include <sys/ioctl.h> 2367957Skris#include <sys/socket.h> 2467957Skris#include <sys/mbuf.h> 2567957Skris 2667957Skris#include <net/if.h> 2767957Skris#include <net/netisr.h> 2867957Skris#include <net/if_types.h> 2967957Skris 3067957Skris#ifdef INET 3167957Skris#include <netinet/in.h> 3267957Skris#include <netinet/in_systm.h> 3367957Skris#include <netinet/in_var.h> 3467957Skris#include <netinet/ip.h> 3567957Skris#include <netinet/tcp.h> 3667957Skris#include <netinet/if_ether.h> 3767957Skris#endif 3867957Skris 3967957Skris#ifdef IPX 4067957Skris#include <netipx/ipx.h> 4167957Skris#include <netipx/ipx_if.h> 4267957Skris#endif 4367957Skris 4467957Skris#ifdef NS 4567957Skris#include <netns/ns.h> 4667957Skris#include <netns/ns_if.h> 4767957Skris#endif 4867957Skris 4967957Skris#ifdef ISO 5067957Skris#include <netiso/argo_debug.h> 5167957Skris#include <netiso/iso.h> 5267957Skris#include <netiso/iso_var.h> 5367957Skris#include <netiso/iso_snpac.h> 5467957Skris#endif 5567957Skris 5667957Skris#include <net/if_sppp.h> 5767957Skris 5867957Skris#ifdef DEBUG 5967957Skris#define print(s) printf s 6067957Skris#else 6167957Skris#define print(s) {/*void*/} 6267957Skris#endif 6367957Skris 6467957Skris#define MAXALIVECNT 3 /* max. alive packets */ 6567957Skris 6667957Skris#define PPP_ALLSTATIONS 0xff /* All-Stations broadcast address */ 6767957Skris#define PPP_UI 0x03 /* Unnumbered Information */ 6867957Skris#define PPP_IP 0x0021 /* Internet Protocol */ 6967957Skris#define PPP_ISO 0x0023 /* ISO OSI Protocol */ 7067957Skris#define PPP_XNS 0x0025 /* Xerox NS Protocol */ 7167957Skris#define PPP_IPX 0x002b /* Novell IPX Protocol */ 7267957Skris#define PPP_LCP 0xc021 /* Link Control Protocol */ 7367957Skris#define PPP_IPCP 0x8021 /* Internet Protocol Control Protocol */ 7467957Skris 7567957Skris#define LCP_CONF_REQ 1 /* PPP LCP configure request */ 7667957Skris#define LCP_CONF_ACK 2 /* PPP LCP configure acknowledge */ 7767957Skris#define LCP_CONF_NAK 3 /* PPP LCP configure negative ack */ 7867957Skris#define LCP_CONF_REJ 4 /* PPP LCP configure reject */ 7967957Skris#define LCP_TERM_REQ 5 /* PPP LCP terminate request */ 8067957Skris#define LCP_TERM_ACK 6 /* PPP LCP terminate acknowledge */ 8167957Skris#define LCP_CODE_REJ 7 /* PPP LCP code reject */ 8267957Skris#define LCP_PROTO_REJ 8 /* PPP LCP protocol reject */ 8367957Skris#define LCP_ECHO_REQ 9 /* PPP LCP echo request */ 8467957Skris#define LCP_ECHO_REPLY 10 /* PPP LCP echo reply */ 8567957Skris#define LCP_DISC_REQ 11 /* PPP LCP discard request */ 8667957Skris 8767957Skris#define LCP_OPT_MRU 1 /* maximum receive unit */ 8867957Skris#define LCP_OPT_ASYNC_MAP 2 /* async control character map */ 8967957Skris#define LCP_OPT_AUTH_PROTO 3 /* authentication protocol */ 9067957Skris#define LCP_OPT_QUAL_PROTO 4 /* quality protocol */ 9167957Skris#define LCP_OPT_MAGIC 5 /* magic number */ 9267957Skris#define LCP_OPT_RESERVED 6 /* reserved */ 9367957Skris#define LCP_OPT_PROTO_COMP 7 /* protocol field compression */ 9467957Skris#define LCP_OPT_ADDR_COMP 8 /* address/control field compression */ 9567957Skris 9667957Skris#define IPCP_CONF_REQ LCP_CONF_REQ /* PPP IPCP configure request */ 9767957Skris#define IPCP_CONF_ACK LCP_CONF_ACK /* PPP IPCP configure acknowledge */ 9867957Skris#define IPCP_CONF_NAK LCP_CONF_NAK /* PPP IPCP configure negative ack */ 9967957Skris#define IPCP_CONF_REJ LCP_CONF_REJ /* PPP IPCP configure reject */ 10067957Skris#define IPCP_TERM_REQ LCP_TERM_REQ /* PPP IPCP terminate request */ 10167957Skris#define IPCP_TERM_ACK LCP_TERM_ACK /* PPP IPCP terminate acknowledge */ 10267957Skris#define IPCP_CODE_REJ LCP_CODE_REJ /* PPP IPCP code reject */ 10367957Skris 10467957Skris#define CISCO_MULTICAST 0x8f /* Cisco multicast address */ 10567957Skris#define CISCO_UNICAST 0x0f /* Cisco unicast address */ 10667957Skris#define CISCO_KEEPALIVE 0x8035 /* Cisco keepalive protocol */ 10767957Skris#define CISCO_ADDR_REQ 0 /* Cisco address request */ 10867957Skris#define CISCO_ADDR_REPLY 1 /* Cisco address reply */ 10967957Skris#define CISCO_KEEPALIVE_REQ 2 /* Cisco keepalive request */ 11067957Skris 11167957Skrisstruct ppp_header { 11267957Skris u_char address; 11367957Skris u_char control; 11467957Skris u_short protocol; 11567957Skris}; 11667957Skris#define PPP_HEADER_LEN sizeof (struct ppp_header) 11767957Skris 11867957Skrisstruct lcp_header { 11967957Skris u_char type; 12067957Skris u_char ident; 12167957Skris u_short len; 12267957Skris}; 12367957Skris#define LCP_HEADER_LEN sizeof (struct lcp_header) 12467957Skris 12567957Skrisstruct cisco_packet { 12667957Skris u_long type; 12767957Skris u_long par1; 12867957Skris u_long par2; 12967957Skris u_short rel; 13067957Skris u_short time0; 13167957Skris u_short time1; 13267957Skris}; 13367957Skris#define CISCO_PACKET_LEN 18 13467957Skris 13567957Skrisstruct sppp *spppq; 13667957Skris 13767957Skris/* 13867957Skris * The following disgusting hack gets around the problem that IP TOS 13967957Skris * can't be set yet. We want to put "interactive" traffic on a high 14067957Skris * priority queue. To decide if traffic is interactive, we check that 14167957Skris * a) it is TCP and b) one of its ports is telnet, rlogin or ftp control. 14267957Skris */ 14367957Skrisstatic u_short interactive_ports[8] = { 14467957Skris 0, 513, 0, 0, 14567957Skris 0, 21, 0, 23, 14667957Skris}; 14767957Skris#define INTERACTIVE(p) (interactive_ports[(p) & 7] == (p)) 14867957Skris 14967957Skris/* 15067957Skris * Timeout routine activation macros. 15167957Skris */ 15267957Skris#define TIMO(p,s) if (! ((p)->pp_flags & PP_TIMO)) { \ 15367957Skris timeout (sppp_cp_timeout, (void*) (p), (s)*hz); \ 15467957Skris (p)->pp_flags |= PP_TIMO; } 15567957Skris#define UNTIMO(p) if ((p)->pp_flags & PP_TIMO) { \ 15667957Skris untimeout (sppp_cp_timeout, (void*) (p)); \ 15767957Skris (p)->pp_flags &= ~PP_TIMO; } 15867957Skris 15967957Skrisvoid sppp_keepalive (void *dummy); 16067957Skrisvoid sppp_cp_send (struct sppp *sp, u_short proto, u_char type, 16167957Skris u_char ident, u_short len, void *data); 16267957Skrisvoid sppp_cisco_send (struct sppp *sp, int type, long par1, long par2); 16367957Skrisvoid sppp_lcp_input (struct sppp *sp, struct mbuf *m); 16467957Skrisvoid sppp_cisco_input (struct sppp *sp, struct mbuf *m); 16567957Skrisvoid sppp_ipcp_input (struct sppp *sp, struct mbuf *m); 16667957Skrisvoid sppp_lcp_open (struct sppp *sp); 16767957Skrisvoid sppp_ipcp_open (struct sppp *sp); 16867957Skrisint sppp_lcp_conf_parse_options (struct sppp *sp, struct lcp_header *h, 16967957Skris int len, u_long *magic); 17067957Skrisvoid sppp_cp_timeout (void *arg); 17167957Skrischar *sppp_lcp_type_name (u_char type); 17267957Skrischar *sppp_ipcp_type_name (u_char type); 17367957Skrisvoid sppp_print_bytes (u_char *p, u_short len); 17467957Skris 17567957Skris/* 17667957Skris * Flush interface queue. 17767957Skris */ 17867957Skrisstatic void qflush (struct ifqueue *ifq) 17967957Skris{ 18067957Skris struct mbuf *m, *n; 18167957Skris 18267957Skris n = ifq->ifq_head; 18367957Skris while ((m = n)) { 18467957Skris n = m->m_act; 18567957Skris m_freem (m); 18667957Skris } 18767957Skris ifq->ifq_head = 0; 18867957Skris ifq->ifq_tail = 0; 18967957Skris ifq->ifq_len = 0; 19067957Skris} 19167957Skris 19267957Skris/* 19367957Skris * Process the received packet. 19467957Skris */ 19567957Skrisvoid sppp_input (struct ifnet *ifp, struct mbuf *m) 19667957Skris{ 19767957Skris struct ppp_header *h; 19867957Skris struct sppp *sp = (struct sppp*) ifp; 19967957Skris struct ifqueue *inq = 0; 20067957Skris int s; 20167957Skris 20267957Skris ifp->if_lastchange = time; 20367957Skris if (ifp->if_flags & IFF_UP) 20467957Skris /* Count received bytes, add FCS and one flag */ 20567957Skris ifp->if_ibytes += m->m_pkthdr.len + 3; 20667957Skris 20767957Skris if (m->m_pkthdr.len <= PPP_HEADER_LEN) { 20867957Skris /* Too small packet, drop it. */ 20967957Skris if (ifp->if_flags & IFF_DEBUG) 21067957Skris printf ("%s%d: input packet is too small, %d bytes\n", 21167957Skris ifp->if_name, ifp->if_unit, m->m_pkthdr.len); 21267957Skrisdrop: ++ifp->if_iqdrops; 21367957Skris m_freem (m); 21467957Skris return; 21567957Skris } 21667957Skris 21767957Skris /* Get PPP header. */ 21867957Skris h = mtod (m, struct ppp_header*); 21967957Skris m_adj (m, PPP_HEADER_LEN); 22067957Skris 22167957Skris switch (h->address) { 22267957Skris default: /* Invalid PPP packet. */ 22367957Skrisinvalid: if (ifp->if_flags & IFF_DEBUG) 22467957Skris printf ("%s%d: invalid input packet <0x%x 0x%x 0x%x>\n", 22567957Skris ifp->if_name, ifp->if_unit, 22667957Skris h->address, h->control, ntohs (h->protocol)); 22767957Skris goto drop; 22867957Skris case PPP_ALLSTATIONS: 22967957Skris if (h->control != PPP_UI) 23067957Skris goto invalid; 23167957Skris if (sp->pp_flags & PP_CISCO) { 23267957Skris if (ifp->if_flags & IFF_DEBUG) 23367957Skris printf ("%s%d: PPP packet in Cisco mode <0x%x 0x%x 0x%x>\n", 23467957Skris ifp->if_name, ifp->if_unit, 23567957Skris h->address, h->control, ntohs (h->protocol)); 23667957Skris goto drop; 23767957Skris } 23867957Skris switch (ntohs (h->protocol)) { 23967957Skris default: 24067957Skris if (sp->lcp.state == LCP_STATE_OPENED) 24167957Skris sppp_cp_send (sp, PPP_LCP, LCP_PROTO_REJ, 24267957Skris ++sp->pp_seq, m->m_pkthdr.len + 2, 24367957Skris &h->protocol); 24467957Skris if (ifp->if_flags & IFF_DEBUG) 24567957Skris printf ("%s%d: invalid input protocol <0x%x 0x%x 0x%x>\n", 24667957Skris ifp->if_name, ifp->if_unit, 24767957Skris h->address, h->control, ntohs (h->protocol)); 24867957Skris ++ifp->if_noproto; 24967957Skris goto drop; 25067957Skris case PPP_LCP: 25167957Skris sppp_lcp_input ((struct sppp*) ifp, m); 25267957Skris m_freem (m); 25367957Skris return; 25467957Skris#ifdef INET 25567957Skris case PPP_IPCP: 25667957Skris if (sp->lcp.state == LCP_STATE_OPENED) 25767957Skris sppp_ipcp_input ((struct sppp*) ifp, m); 25867957Skris m_freem (m); 25967957Skris return; 26067957Skris case PPP_IP: 26167957Skris if (sp->ipcp.state == IPCP_STATE_OPENED) { 26267957Skris schednetisr (NETISR_IP); 26367957Skris inq = &ipintrq; 26467957Skris } 26567957Skris break; 26667957Skris#endif 26767957Skris#ifdef IPX 26867957Skris case PPP_IPX: 26967957Skris /* IPX IPXCP not implemented yet */ 27067957Skris if (sp->lcp.state == LCP_STATE_OPENED) { 27167957Skris schednetisr (NETISR_IPX); 27267957Skris inq = &ipxintrq; 27367957Skris } 27467957Skris break; 27567957Skris#endif 27667957Skris#ifdef NS 27767957Skris case PPP_XNS: 27867957Skris /* XNS IDPCP not implemented yet */ 27967957Skris if (sp->lcp.state == LCP_STATE_OPENED) { 28067957Skris schednetisr (NETISR_NS); 28167957Skris inq = &nsintrq; 28267957Skris } 28367957Skris break; 28467957Skris#endif 28567957Skris#ifdef ISO 28667957Skris case PPP_ISO: 28767957Skris /* OSI NLCP not implemented yet */ 28867957Skris if (sp->lcp.state == LCP_STATE_OPENED) { 28967957Skris schednetisr (NETISR_ISO); 29067957Skris inq = &clnlintrq; 29167957Skris } 29267957Skris break; 29367957Skris#endif 29467957Skris } 29567957Skris break; 29667957Skris case CISCO_MULTICAST: 29767957Skris case CISCO_UNICAST: 29867957Skris /* Don't check the control field here (RFC 1547). */ 29967957Skris if (! (sp->pp_flags & PP_CISCO)) { 30067957Skris if (ifp->if_flags & IFF_DEBUG) 30167957Skris printf ("%s%d: Cisco packet in PPP mode <0x%x 0x%x 0x%x>\n", 30267957Skris ifp->if_name, ifp->if_unit, 30367957Skris h->address, h->control, ntohs (h->protocol)); 30467957Skris goto drop; 30567957Skris } 30667957Skris switch (ntohs (h->protocol)) { 30767957Skris default: 30867957Skris ++ifp->if_noproto; 30967957Skris goto invalid; 31067957Skris case CISCO_KEEPALIVE: 31167957Skris sppp_cisco_input ((struct sppp*) ifp, m); 31267957Skris m_freem (m); 31367957Skris return; 31467957Skris#ifdef INET 31567957Skris case ETHERTYPE_IP: 31667957Skris schednetisr (NETISR_IP); 31767957Skris inq = &ipintrq; 31867957Skris break; 31967957Skris#endif 32067957Skris#ifdef IPX 32167957Skris case ETHERTYPE_IPX: 32267957Skris schednetisr (NETISR_IPX); 32367957Skris inq = &ipxintrq; 32467957Skris break; 32567957Skris#endif 32667957Skris#ifdef NS 32767957Skris case ETHERTYPE_NS: 32867957Skris schednetisr (NETISR_NS); 32967957Skris inq = &nsintrq; 33067957Skris break; 33167957Skris#endif 33267957Skris } 33367957Skris break; 33467957Skris } 33567957Skris 33667957Skris if (! (ifp->if_flags & IFF_UP) || ! inq) 33767957Skris goto drop; 33867957Skris 33967957Skris /* Check queue. */ 34067957Skris s = splimp (); 34167957Skris if (IF_QFULL (inq)) { 34267957Skris /* Queue overflow. */ 34367957Skris IF_DROP (inq); 34467957Skris splx (s); 34567957Skris if (ifp->if_flags & IFF_DEBUG) 34667957Skris printf ("%s%d: protocol queue overflow\n", 34767957Skris ifp->if_name, ifp->if_unit); 34867957Skris goto drop; 34967957Skris } 35067957Skris IF_ENQUEUE (inq, m); 35167957Skris splx (s); 35267957Skris} 35367957Skris 35467957Skris/* 35567957Skris * Enqueue transmit packet. 35667957Skris */ 35767957Skrisint sppp_output (struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst, struct rtentry *rt) 35867957Skris{ 35967957Skris struct sppp *sp = (struct sppp*) ifp; 36067957Skris struct ppp_header *h; 36167957Skris struct ifqueue *ifq; 36267957Skris int s = splimp (); 36367957Skris 36467957Skris if (! (ifp->if_flags & IFF_UP) || ! (ifp->if_flags & IFF_RUNNING)) { 36567957Skris m_freem (m); 36667957Skris splx (s); 36767957Skris return (ENETDOWN); 36867957Skris } 36967957Skris 37067957Skris ifq = &ifp->if_snd; 37167957Skris#ifdef INET 37267957Skris /* 37367957Skris * Put low delay, telnet, rlogin and ftp control packets 37467957Skris * in front of the queue. 37567957Skris */ 37667957Skris if (dst->sa_family == AF_INET) { 37767957Skris struct ip *ip = mtod (m, struct ip*); 37867957Skris struct tcphdr *tcp = (struct tcphdr*) ((long*)ip + ip->ip_hl); 37967957Skris 38067957Skris if (! IF_QFULL (&sp->pp_fastq) && 38167957Skris ((ip->ip_tos & IPTOS_LOWDELAY) || 38267957Skris ip->ip_p == IPPROTO_TCP && 38367957Skris m->m_len >= sizeof (struct ip) + sizeof (struct tcphdr) && 38467957Skris (INTERACTIVE (ntohs (tcp->th_sport)) || 38567957Skris INTERACTIVE (ntohs (tcp->th_dport))))) 38667957Skris ifq = &sp->pp_fastq; 38767957Skris } 38867957Skris#endif 38967957Skris 39067957Skris /* 39167957Skris * Prepend general data packet PPP header. For now, IP only. 39267957Skris */ 39367957Skris M_PREPEND (m, PPP_HEADER_LEN, M_DONTWAIT); 39467957Skris if (! m) { 39567957Skris if (ifp->if_flags & IFF_DEBUG) 39667957Skris printf ("%s%d: no memory for transmit header\n", 39767957Skris ifp->if_name, ifp->if_unit); 39867957Skris splx (s); 39967957Skris return (ENOBUFS); 40067957Skris } 40167957Skris h = mtod (m, struct ppp_header*); 40267957Skris if (sp->pp_flags & PP_CISCO) { 40367957Skris h->address = CISCO_MULTICAST; /* broadcast address */ 40467957Skris h->control = 0; 40567957Skris } else { 40667957Skris h->address = PPP_ALLSTATIONS; /* broadcast address */ 40767957Skris h->control = PPP_UI; /* Unnumbered Info */ 40867957Skris } 40967957Skris 41067957Skris switch (dst->sa_family) { 41167957Skris#ifdef INET 41267957Skris case AF_INET: /* Internet Protocol */ 41367957Skris if (sp->pp_flags & PP_CISCO) 41467957Skris h->protocol = htons (ETHERTYPE_IP); 41567957Skris else if (sp->ipcp.state == IPCP_STATE_OPENED) 41667957Skris h->protocol = htons (PPP_IP); 41767957Skris else { 41867957Skris m_freem (m); 41967957Skris splx (s); 42067957Skris return (ENETDOWN); 42167957Skris } 42267957Skris break; 42367957Skris#endif 42467957Skris#ifdef NS 42567957Skris case AF_NS: /* Xerox NS Protocol */ 42667957Skris h->protocol = htons ((sp->pp_flags & PP_CISCO) ? 42767957Skris ETHERTYPE_NS : PPP_XNS); 42867957Skris break; 42967957Skris#endif 43067957Skris#ifdef IPX 43167957Skris case AF_IPX: /* Novell IPX Protocol */ 43267957Skris h->protocol = htons ((sp->pp_flags & PP_CISCO) ? 43367957Skris ETHERTYPE_IPX : PPP_IPX); 43467957Skris break; 43567957Skris#endif 43667957Skris#ifdef ISO 43767957Skris case AF_ISO: /* ISO OSI Protocol */ 43867957Skris if (sp->pp_flags & PP_CISCO) 43967957Skris goto nosupport; 44067957Skris h->protocol = htons (PPP_ISO); 44167957Skris break; 44267957Skris#endif 44367957Skrisnosupport: 44467957Skris default: 44567957Skris m_freem (m); 44667957Skris splx (s); 44767957Skris return (EAFNOSUPPORT); 44867957Skris } 44967957Skris 45067957Skris /* 45167957Skris * Queue message on interface, and start output if interface 45267957Skris * not yet active. 45367957Skris */ 45467957Skris if (IF_QFULL (ifq)) { 45567957Skris IF_DROP (&ifp->if_snd); 45667957Skris m_freem (m); 45767957Skris splx (s); 45867957Skris return (ENOBUFS); 45967957Skris } 46067957Skris IF_ENQUEUE (ifq, m); 46167957Skris if (! (ifp->if_flags & IFF_OACTIVE)) 46267957Skris (*ifp->if_start) (ifp); 46367957Skris 46467957Skris /* 46567957Skris * Count output packets and bytes. 46667957Skris * The packet length includes header, FCS and 1 flag, 46767957Skris * according to RFC 1333. 46867957Skris */ 46967957Skris ifp->if_obytes += m->m_pkthdr.len + 3; 47067957Skris ifp->if_lastchange = time; 47167957Skris splx (s); 47267957Skris return (0); 47367957Skris} 47467957Skris 47567957Skrisvoid sppp_attach (struct ifnet *ifp) 47667957Skris{ 47767957Skris struct sppp *sp = (struct sppp*) ifp; 47867957Skris 47967957Skris /* Initialize keepalive handler. */ 48067957Skris if (! spppq) 48167957Skris timeout (sppp_keepalive, 0, hz * 10); 48267957Skris 48367957Skris /* Insert new entry into the keepalive list. */ 48467957Skris sp->pp_next = spppq; 48567957Skris spppq = sp; 48667957Skris 48767957Skris sp->pp_if.if_type = IFT_PPP; 48867957Skris sp->pp_if.if_output = sppp_output; 48967957Skris sp->pp_fastq.ifq_maxlen = 32; 49067957Skris sp->pp_loopcnt = 0; 49167957Skris sp->pp_alivecnt = 0; 49267957Skris sp->pp_seq = 0; 49367957Skris sp->pp_rseq = 0; 49467957Skris sp->lcp.magic = 0; 49567957Skris sp->lcp.state = LCP_STATE_CLOSED; 49667957Skris sp->ipcp.state = IPCP_STATE_CLOSED; 49767957Skris} 49867957Skris 49967957Skrisvoid sppp_detach (struct ifnet *ifp) 50067957Skris{ 50167957Skris struct sppp **q, *p, *sp = (struct sppp*) ifp; 50267957Skris 50367957Skris /* Remove the entry from the keepalive list. */ 50467957Skris for (q = &spppq; (p = *q); q = &p->pp_next) 50567957Skris if (p == sp) { 50667957Skris *q = p->pp_next; 50767957Skris break; 50867957Skris } 50967957Skris 51067957Skris /* Stop keepalive handler. */ 51167957Skris if (! spppq) 51267957Skris untimeout (sppp_keepalive, 0); 51367957Skris UNTIMO (sp); 51467957Skris} 51567957Skris 51667957Skris/* 51767957Skris * Flush the interface output queue. 51867957Skris */ 51967957Skrisvoid sppp_flush (struct ifnet *ifp) 52067957Skris{ 521 struct sppp *sp = (struct sppp*) ifp; 522 523 qflush (&sp->pp_if.if_snd); 524 qflush (&sp->pp_fastq); 525} 526 527/* 528 * Check if the output queue is empty. 529 */ 530int sppp_isempty (struct ifnet *ifp) 531{ 532 struct sppp *sp = (struct sppp*) ifp; 533 int empty, s = splimp (); 534 535 empty = !sp->pp_fastq.ifq_head && !sp->pp_if.if_snd.ifq_head; 536 splx (s); 537 return (empty); 538} 539 540/* 541 * Get next packet to send. 542 */ 543struct mbuf *sppp_dequeue (struct ifnet *ifp) 544{ 545 struct sppp *sp = (struct sppp*) ifp; 546 struct mbuf *m; 547 int s = splimp (); 548 549 IF_DEQUEUE (&sp->pp_fastq, m); 550 if (! m) 551 IF_DEQUEUE (&sp->pp_if.if_snd, m); 552 splx (s); 553 return (m); 554} 555 556/* 557 * Send keepalive packets, every 10 seconds. 558 */ 559void sppp_keepalive (void *dummy) 560{ 561 struct sppp *sp; 562 int s = splimp (); 563 564 for (sp=spppq; sp; sp=sp->pp_next) { 565 struct ifnet *ifp = &sp->pp_if; 566 567 /* Keepalive mode disabled or channel down? */ 568 if (! (sp->pp_flags & PP_KEEPALIVE) || 569 ! (ifp->if_flags & IFF_RUNNING)) 570 continue; 571 572 /* No keepalive in PPP mode if LCP not opened yet. */ 573 if (! (sp->pp_flags & PP_CISCO) && 574 sp->lcp.state != LCP_STATE_OPENED) 575 continue; 576 577 if (sp->pp_alivecnt == MAXALIVECNT) { 578 /* No keepalive packets got. Stop the interface. */ 579 printf ("%s%d: down\n", ifp->if_name, ifp->if_unit); 580 if_down (ifp); 581 qflush (&sp->pp_fastq); 582 if (! (sp->pp_flags & PP_CISCO)) { 583 /* Shut down the PPP link. */ 584 sp->lcp.state = LCP_STATE_CLOSED; 585 sp->ipcp.state = IPCP_STATE_CLOSED; 586 UNTIMO (sp); 587 /* Initiate negotiation. */ 588 sppp_lcp_open (sp); 589 } 590 } 591 if (sp->pp_alivecnt <= MAXALIVECNT) 592 ++sp->pp_alivecnt; 593 if (sp->pp_flags & PP_CISCO) 594 sppp_cisco_send (sp, CISCO_KEEPALIVE_REQ, ++sp->pp_seq, 595 sp->pp_rseq); 596 else if (sp->lcp.state == LCP_STATE_OPENED) { 597 long nmagic = htonl (sp->lcp.magic); 598 sp->lcp.echoid = ++sp->pp_seq; 599 sppp_cp_send (sp, PPP_LCP, LCP_ECHO_REQ, 600 sp->lcp.echoid, 4, &nmagic); 601 } 602 } 603 splx (s); 604 timeout (sppp_keepalive, 0, hz * 10); 605} 606 607/* 608 * Handle incoming PPP Link Control Protocol packets. 609 */ 610void sppp_lcp_input (struct sppp *sp, struct mbuf *m) 611{ 612 struct lcp_header *h; 613 struct ifnet *ifp = &sp->pp_if; 614 int len = m->m_pkthdr.len; 615 u_char *p, opt[6]; 616 u_long rmagic; 617 618 if (len < 4) { 619 if (ifp->if_flags & IFF_DEBUG) 620 printf ("%s%d: invalid lcp packet length: %d bytes\n", 621 ifp->if_name, ifp->if_unit, len); 622 return; 623 } 624 h = mtod (m, struct lcp_header*); 625 if (ifp->if_flags & IFF_DEBUG) { 626 char state = '?'; 627 switch (sp->lcp.state) { 628 case LCP_STATE_CLOSED: state = 'C'; break; 629 case LCP_STATE_ACK_RCVD: state = 'R'; break; 630 case LCP_STATE_ACK_SENT: state = 'S'; break; 631 case LCP_STATE_OPENED: state = 'O'; break; 632 } 633 printf ("%s%d: lcp input(%c): %d bytes <%s id=%xh len=%xh", 634 ifp->if_name, ifp->if_unit, state, len, 635 sppp_lcp_type_name (h->type), h->ident, ntohs (h->len)); 636 if (len > 4) 637 sppp_print_bytes ((u_char*) (h+1), len-4); 638 printf (">\n"); 639 } 640 if (len > ntohs (h->len)) 641 len = ntohs (h->len); 642 switch (h->type) { 643 default: 644 /* Unknown packet type -- send Code-Reject packet. */ 645 sppp_cp_send (sp, PPP_LCP, LCP_CODE_REJ, ++sp->pp_seq, 646 m->m_pkthdr.len, h); 647 break; 648 case LCP_CONF_REQ: 649 if (len < 4) { 650 if (ifp->if_flags & IFF_DEBUG) 651 printf ("%s%d: invalid lcp configure request packet length: %d bytes\n", 652 ifp->if_name, ifp->if_unit, len); 653 break; 654 } 655 if (len>4 && !sppp_lcp_conf_parse_options (sp, h, len, &rmagic)) 656 goto badreq; 657 if (rmagic == sp->lcp.magic) { 658 /* Local and remote magics equal -- loopback? */ 659 if (sp->pp_loopcnt >= MAXALIVECNT*5) { 660 printf ("%s%d: loopback\n", 661 ifp->if_name, ifp->if_unit); 662 sp->pp_loopcnt = 0; 663 if (ifp->if_flags & IFF_UP) { 664 if_down (ifp); 665 qflush (&sp->pp_fastq); 666 } 667 } else if (ifp->if_flags & IFF_DEBUG) 668 printf ("%s%d: conf req: magic glitch\n", 669 ifp->if_name, ifp->if_unit); 670 ++sp->pp_loopcnt; 671 672 /* MUST send Conf-Nack packet. */ 673 rmagic = ~sp->lcp.magic; 674 opt[0] = LCP_OPT_MAGIC; 675 opt[1] = sizeof (opt); 676 opt[2] = rmagic >> 24; 677 opt[3] = rmagic >> 16; 678 opt[4] = rmagic >> 8; 679 opt[5] = rmagic; 680 sppp_cp_send (sp, PPP_LCP, LCP_CONF_NAK, 681 h->ident, sizeof (opt), &opt); 682badreq: 683 switch (sp->lcp.state) { 684 case LCP_STATE_OPENED: 685 /* Initiate renegotiation. */ 686 sppp_lcp_open (sp); 687 /* fall through... */ 688 case LCP_STATE_ACK_SENT: 689 /* Go to closed state. */ 690 sp->lcp.state = LCP_STATE_CLOSED; 691 sp->ipcp.state = IPCP_STATE_CLOSED; 692 } 693 break; 694 } 695 /* Send Configure-Ack packet. */ 696 sp->pp_loopcnt = 0; 697 sppp_cp_send (sp, PPP_LCP, LCP_CONF_ACK, 698 h->ident, len-4, h+1); 699 /* Change the state. */ 700 switch (sp->lcp.state) { 701 case LCP_STATE_CLOSED: 702 sp->lcp.state = LCP_STATE_ACK_SENT; 703 break; 704 case LCP_STATE_ACK_RCVD: 705 sp->lcp.state = LCP_STATE_OPENED; 706 sppp_ipcp_open (sp); 707 break; 708 case LCP_STATE_OPENED: 709 /* Remote magic changed -- close session. */ 710 sp->lcp.state = LCP_STATE_CLOSED; 711 sp->ipcp.state = IPCP_STATE_CLOSED; 712 /* Initiate renegotiation. */ 713 sppp_lcp_open (sp); 714 /* An ACK has already been sent. */ 715 sp->lcp.state = LCP_STATE_ACK_SENT; 716 break; 717 } 718 break; 719 case LCP_CONF_ACK: 720 if (h->ident != sp->lcp.confid) 721 break; 722 UNTIMO (sp); 723 if (! (ifp->if_flags & IFF_UP) && 724 (ifp->if_flags & IFF_RUNNING)) { 725 /* Coming out of loopback mode. */ 726 ifp->if_flags |= IFF_UP; 727 printf ("%s%d: up\n", ifp->if_name, ifp->if_unit); 728 } 729 switch (sp->lcp.state) { 730 case LCP_STATE_CLOSED: 731 sp->lcp.state = LCP_STATE_ACK_RCVD; 732 TIMO (sp, 5); 733 break; 734 case LCP_STATE_ACK_SENT: 735 sp->lcp.state = LCP_STATE_OPENED; 736 sppp_ipcp_open (sp); 737 break; 738 } 739 break; 740 case LCP_CONF_NAK: 741 if (h->ident != sp->lcp.confid) 742 break; 743 p = (u_char*) (h+1); 744 if (len>=10 && p[0] == LCP_OPT_MAGIC && p[1] >= 4) { 745 rmagic = (u_long)p[2] << 24 | 746 (u_long)p[3] << 16 | p[4] << 8 | p[5]; 747 if (rmagic == ~sp->lcp.magic) { 748 if (ifp->if_flags & IFF_DEBUG) 749 printf ("%s%d: conf nak: magic glitch\n", 750 ifp->if_name, ifp->if_unit); 751 sp->lcp.magic += time.tv_sec + time.tv_usec; 752 } else 753 sp->lcp.magic = rmagic; 754 } 755 if (sp->lcp.state != LCP_STATE_ACK_SENT) { 756 /* Go to closed state. */ 757 sp->lcp.state = LCP_STATE_CLOSED; 758 sp->ipcp.state = IPCP_STATE_CLOSED; 759 } 760 /* The link will be renegotiated after timeout, 761 * to avoid endless req-nack loop. */ 762 UNTIMO (sp); 763 TIMO (sp, 2); 764 break; 765 case LCP_CONF_REJ: 766 if (h->ident != sp->lcp.confid) 767 break; 768 UNTIMO (sp); 769 /* Initiate renegotiation. */ 770 sppp_lcp_open (sp); 771 if (sp->lcp.state != LCP_STATE_ACK_SENT) { 772 /* Go to closed state. */ 773 sp->lcp.state = LCP_STATE_CLOSED; 774 sp->ipcp.state = IPCP_STATE_CLOSED; 775 } 776 break; 777 case LCP_TERM_REQ: 778 UNTIMO (sp); 779 /* Send Terminate-Ack packet. */ 780 sppp_cp_send (sp, PPP_LCP, LCP_TERM_ACK, h->ident, 0, 0); 781 /* Go to closed state. */ 782 sp->lcp.state = LCP_STATE_CLOSED; 783 sp->ipcp.state = IPCP_STATE_CLOSED; 784 /* Initiate renegotiation. */ 785 sppp_lcp_open (sp); 786 break; 787 case LCP_TERM_ACK: 788 case LCP_CODE_REJ: 789 case LCP_PROTO_REJ: 790 /* Ignore for now. */ 791 break; 792 case LCP_DISC_REQ: 793 /* Discard the packet. */ 794 break; 795 case LCP_ECHO_REQ: 796 if (sp->lcp.state != LCP_STATE_OPENED) 797 break; 798 if (len < 8) { 799 if (ifp->if_flags & IFF_DEBUG) 800 printf ("%s%d: invalid lcp echo request packet length: %d bytes\n", 801 ifp->if_name, ifp->if_unit, len); 802 break; 803 } 804 if (ntohl (*(long*)(h+1)) == sp->lcp.magic) { 805 /* Line loopback mode detected. */ 806 printf ("%s%d: loopback\n", ifp->if_name, ifp->if_unit); 807 if_down (ifp); 808 qflush (&sp->pp_fastq); 809 810 /* Shut down the PPP link. */ 811 sp->lcp.state = LCP_STATE_CLOSED; 812 sp->ipcp.state = IPCP_STATE_CLOSED; 813 UNTIMO (sp); 814 /* Initiate negotiation. */ 815 sppp_lcp_open (sp); 816 break; 817 } 818 *(long*)(h+1) = htonl (sp->lcp.magic); 819 sppp_cp_send (sp, PPP_LCP, LCP_ECHO_REPLY, h->ident, len-4, h+1); 820 break; 821 case LCP_ECHO_REPLY: 822 if (h->ident != sp->lcp.echoid) 823 break; 824 if (len < 8) { 825 if (ifp->if_flags & IFF_DEBUG) 826 printf ("%s%d: invalid lcp echo reply packet length: %d bytes\n", 827 ifp->if_name, ifp->if_unit, len); 828 break; 829 } 830 if (ntohl (*(long*)(h+1)) != sp->lcp.magic) 831 sp->pp_alivecnt = 0; 832 break; 833 } 834} 835 836/* 837 * Handle incoming Cisco keepalive protocol packets. 838 */ 839void sppp_cisco_input (struct sppp *sp, struct mbuf *m) 840{ 841 struct cisco_packet *h; 842 struct ifaddr *ifa; 843 struct ifnet *ifp = &sp->pp_if; 844 845 if (m->m_pkthdr.len != CISCO_PACKET_LEN) { 846 if (ifp->if_flags & IFF_DEBUG) 847 printf ("%s%d: invalid cisco packet length: %d bytes\n", 848 ifp->if_name, ifp->if_unit, m->m_pkthdr.len); 849 return; 850 } 851 h = mtod (m, struct cisco_packet*); 852 if (ifp->if_flags & IFF_DEBUG) 853 printf ("%s%d: cisco input: %d bytes <%lxh %lxh %lxh %xh %xh-%xh>\n", 854 ifp->if_name, ifp->if_unit, m->m_pkthdr.len, 855 ntohl (h->type), h->par1, h->par2, h->rel, 856 h->time0, h->time1); 857 switch (ntohl (h->type)) { 858 default: 859 if (ifp->if_flags & IFF_DEBUG) 860 printf ("%s%d: unknown cisco packet type: 0x%lx\n", 861 ifp->if_name, ifp->if_unit, ntohl (h->type)); 862 break; 863 case CISCO_ADDR_REPLY: 864 /* Reply on address request, ignore */ 865 break; 866 case CISCO_KEEPALIVE_REQ: 867 sp->pp_alivecnt = 0; 868 sp->pp_rseq = ntohl (h->par1); 869 if (sp->pp_seq == sp->pp_rseq) { 870 /* Local and remote sequence numbers are equal. 871 * Probably, the line is in loopback mode. */ 872 if (sp->pp_loopcnt >= MAXALIVECNT) { 873 printf ("%s%d: loopback\n", 874 ifp->if_name, ifp->if_unit); 875 sp->pp_loopcnt = 0; 876 if (ifp->if_flags & IFF_UP) { 877 if_down (ifp); 878 qflush (&sp->pp_fastq); 879 } 880 } 881 ++sp->pp_loopcnt; 882 883 /* Generate new local sequence number */ 884 sp->pp_seq ^= time.tv_sec ^ time.tv_usec; 885 break; 886 } 887 sp->pp_loopcnt = 0; 888 if (! (ifp->if_flags & IFF_UP) && 889 (ifp->if_flags & IFF_RUNNING)) { 890 ifp->if_flags |= IFF_UP; 891 printf ("%s%d: up\n", ifp->if_name, ifp->if_unit); 892 } 893 break; 894 case CISCO_ADDR_REQ: 895 for (ifa=ifp->if_addrlist; ifa; ifa=ifa->ifa_next) 896 if (ifa->ifa_addr->sa_family == AF_INET) 897 break; 898 if (! ifa) { 899 if (ifp->if_flags & IFF_DEBUG) 900 printf ("%s%d: unknown address for cisco request\n", 901 ifp->if_name, ifp->if_unit); 902 return; 903 } 904 sppp_cisco_send (sp, CISCO_ADDR_REPLY, 905 ntohl (((struct sockaddr_in*)ifa->ifa_addr)->sin_addr.s_addr), 906 ntohl (((struct sockaddr_in*)ifa->ifa_netmask)->sin_addr.s_addr)); 907 break; 908 } 909} 910 911/* 912 * Send PPP LCP packet. 913 */ 914void sppp_cp_send (struct sppp *sp, u_short proto, u_char type, 915 u_char ident, u_short len, void *data) 916{ 917 struct ppp_header *h; 918 struct lcp_header *lh; 919 struct mbuf *m; 920 struct ifnet *ifp = &sp->pp_if; 921 922 if (len > MHLEN - PPP_HEADER_LEN - LCP_HEADER_LEN) 923 len = MHLEN - PPP_HEADER_LEN - LCP_HEADER_LEN; 924 MGETHDR (m, M_DONTWAIT, MT_DATA); 925 if (! m) 926 return; 927 m->m_pkthdr.len = m->m_len = PPP_HEADER_LEN + LCP_HEADER_LEN + len; 928 m->m_pkthdr.rcvif = 0; 929 930 h = mtod (m, struct ppp_header*); 931 h->address = PPP_ALLSTATIONS; /* broadcast address */ 932 h->control = PPP_UI; /* Unnumbered Info */ 933 h->protocol = htons (proto); /* Link Control Protocol */ 934 935 lh = (struct lcp_header*) (h + 1); 936 lh->type = type; 937 lh->ident = ident; 938 lh->len = htons (LCP_HEADER_LEN + len); 939 if (len) 940 bcopy (data, lh+1, len); 941 942 if (ifp->if_flags & IFF_DEBUG) { 943 printf ("%s%d: %s output <%s id=%xh len=%xh", 944 ifp->if_name, ifp->if_unit, 945 proto==PPP_LCP ? "lcp" : "ipcp", 946 proto==PPP_LCP ? sppp_lcp_type_name (lh->type) : 947 sppp_ipcp_type_name (lh->type), lh->ident, 948 ntohs (lh->len)); 949 if (len) 950 sppp_print_bytes ((u_char*) (lh+1), len); 951 printf (">\n"); 952 } 953 if (IF_QFULL (&sp->pp_fastq)) { 954 IF_DROP (&ifp->if_snd); 955 m_freem (m); 956 } else 957 IF_ENQUEUE (&sp->pp_fastq, m); 958 if (! (ifp->if_flags & IFF_OACTIVE)) 959 (*ifp->if_start) (ifp); 960 ifp->if_obytes += m->m_pkthdr.len + 3; 961} 962 963/* 964 * Send Cisco keepalive packet. 965 */ 966void sppp_cisco_send (struct sppp *sp, int type, long par1, long par2) 967{ 968 struct ppp_header *h; 969 struct cisco_packet *ch; 970 struct mbuf *m; 971 struct ifnet *ifp = &sp->pp_if; 972 u_long t = (time.tv_sec - boottime.tv_sec) * 1000; 973 974 MGETHDR (m, M_DONTWAIT, MT_DATA); 975 if (! m) 976 return; 977 m->m_pkthdr.len = m->m_len = PPP_HEADER_LEN + CISCO_PACKET_LEN; 978 m->m_pkthdr.rcvif = 0; 979 980 h = mtod (m, struct ppp_header*); 981 h->address = CISCO_MULTICAST; 982 h->control = 0; 983 h->protocol = htons (CISCO_KEEPALIVE); 984 985 ch = (struct cisco_packet*) (h + 1); 986 ch->type = htonl (type); 987 ch->par1 = htonl (par1); 988 ch->par2 = htonl (par2); 989 ch->rel = -1; 990 ch->time0 = htons ((u_short) (t >> 16)); 991 ch->time1 = htons ((u_short) t); 992 993 if (ifp->if_flags & IFF_DEBUG) 994 printf ("%s%d: cisco output: <%lxh %lxh %lxh %xh %xh-%xh>\n", 995 ifp->if_name, ifp->if_unit, ntohl (ch->type), ch->par1, 996 ch->par2, ch->rel, ch->time0, ch->time1); 997 998 if (IF_QFULL (&sp->pp_fastq)) { 999 IF_DROP (&ifp->if_snd); 1000 m_freem (m); 1001 } else 1002 IF_ENQUEUE (&sp->pp_fastq, m); 1003 if (! (ifp->if_flags & IFF_OACTIVE)) 1004 (*ifp->if_start) (ifp); 1005 ifp->if_obytes += m->m_pkthdr.len + 3; 1006} 1007 1008/* 1009 * Process an ioctl request. Called on low priority level. 1010 */ 1011int sppp_ioctl (struct ifnet *ifp, int cmd, void *data) 1012{ 1013 struct ifreq *ifr = (struct ifreq*) data; 1014 struct sppp *sp = (struct sppp*) ifp; 1015 int s, going_up, going_down; 1016 1017 switch (cmd) { 1018 default: 1019 return (EINVAL); 1020 1021 case SIOCAIFADDR: 1022 case SIOCSIFDSTADDR: 1023 break; 1024 1025 case SIOCSIFADDR: 1026 ifp->if_flags |= IFF_UP; 1027 /* fall through... */ 1028 1029 case SIOCSIFFLAGS: 1030 s = splimp (); 1031 going_up = (ifp->if_flags & IFF_UP) && 1032 ! (ifp->if_flags & IFF_RUNNING); 1033 going_down = ! (ifp->if_flags & IFF_UP) && 1034 (ifp->if_flags & IFF_RUNNING); 1035 if (going_up || going_down) { 1036 /* Shut down the PPP link. */ 1037 ifp->if_flags &= ~IFF_RUNNING; 1038 sp->lcp.state = LCP_STATE_CLOSED; 1039 sp->ipcp.state = IPCP_STATE_CLOSED; 1040 UNTIMO (sp); 1041 } 1042 if (going_up) { 1043 /* Interface is starting -- initiate negotiation. */ 1044 ifp->if_flags |= IFF_RUNNING; 1045 if (!(sp->pp_flags & PP_CISCO)) 1046 sppp_lcp_open (sp); 1047 } 1048 splx (s); 1049 break; 1050 1051#ifdef SIOCSIFMTU 1052#ifndef ifr_mtu 1053#define ifr_mtu ifr_metric 1054#endif 1055 case SIOCSIFMTU: 1056 if (ifr->ifr_mtu < 128 || ifr->ifr_mtu > PP_MTU) 1057 return (EINVAL); 1058 ifp->if_mtu = ifr->ifr_mtu; 1059 break; 1060#endif 1061#ifdef SLIOCSETMTU 1062 case SLIOCSETMTU: 1063 if (*(short*)data < 128 || *(short*)data > PP_MTU) 1064 return (EINVAL); 1065 ifp->if_mtu = *(short*)data; 1066 break; 1067#endif 1068#ifdef SIOCGIFMTU 1069 case SIOCGIFMTU: 1070 ifr->ifr_mtu = ifp->if_mtu; 1071 break; 1072#endif 1073#ifdef SLIOCGETMTU 1074 case SLIOCGETMTU: 1075 *(short*)data = ifp->if_mtu; 1076 break; 1077#endif 1078#ifdef MULTICAST 1079 case SIOCADDMULTI: 1080 case SIOCDELMULTI: 1081 break; 1082#endif 1083 } 1084 return (0); 1085} 1086 1087/* 1088 * Analyze the LCP Configure-Request options list 1089 * for the presence of unknown options. 1090 * If the request contains unknown options, build and 1091 * send Configure-reject packet, containing only unknown options. 1092 */ 1093int sppp_lcp_conf_parse_options (struct sppp *sp, struct lcp_header *h, 1094 int len, u_long *magic) 1095{ 1096 u_char *buf, *r, *p; 1097 int rlen; 1098 1099 len -= 4; 1100 buf = r = malloc (len, M_TEMP, M_NOWAIT); 1101 if (! buf) 1102 return (0); 1103 1104 p = (void*) (h+1); 1105 for (rlen=0; len>1 && p[1]; len-=p[1], p+=p[1]) { 1106 switch (*p) { 1107 case LCP_OPT_MAGIC: 1108 /* Magic number -- extract. */ 1109 if (len >= 6 && p[1] == 6) { 1110 *magic = (u_long)p[2] << 24 | 1111 (u_long)p[3] << 16 | p[4] << 8 | p[5]; 1112 continue; 1113 } 1114 break; 1115 case LCP_OPT_ASYNC_MAP: 1116 /* Async control character map -- check to be zero. */ 1117 if (len >= 6 && p[1] == 6 && ! p[2] && ! p[3] && 1118 ! p[4] && ! p[5]) 1119 continue; 1120 break; 1121 case LCP_OPT_MRU: 1122 /* Maximum receive unit -- always OK. */ 1123 continue; 1124 default: 1125 /* Others not supported. */ 1126 break; 1127 } 1128 /* Add the option to rejected list. */ 1129 bcopy (p, r, p[1]); 1130 r += p[1]; 1131 rlen += p[1]; 1132 } 1133 if (rlen) 1134 sppp_cp_send (sp, PPP_LCP, LCP_CONF_REJ, h->ident, rlen, buf); 1135 free (buf, M_TEMP); 1136 return (rlen == 0); 1137} 1138 1139void sppp_ipcp_input (struct sppp *sp, struct mbuf *m) 1140{ 1141 struct lcp_header *h; 1142 struct ifnet *ifp = &sp->pp_if; 1143 int len = m->m_pkthdr.len; 1144 1145 if (len < 4) { 1146 /* if (ifp->if_flags & IFF_DEBUG) */ 1147 printf ("%s%d: invalid ipcp packet length: %d bytes\n", 1148 ifp->if_name, ifp->if_unit, len); 1149 return; 1150 } 1151 h = mtod (m, struct lcp_header*); 1152 if (ifp->if_flags & IFF_DEBUG) { 1153 printf ("%s%d: ipcp input: %d bytes <%s id=%xh len=%xh", 1154 ifp->if_name, ifp->if_unit, len, 1155 sppp_ipcp_type_name (h->type), h->ident, ntohs (h->len)); 1156 if (len > 4) 1157 sppp_print_bytes ((u_char*) (h+1), len-4); 1158 printf (">\n"); 1159 } 1160 if (len > ntohs (h->len)) 1161 len = ntohs (h->len); 1162 switch (h->type) { 1163 default: 1164 /* Unknown packet type -- send Code-Reject packet. */ 1165 sppp_cp_send (sp, PPP_IPCP, IPCP_CODE_REJ, ++sp->pp_seq, len, h); 1166 break; 1167 case IPCP_CONF_REQ: 1168 if (len < 4) { 1169 if (ifp->if_flags & IFF_DEBUG) 1170 printf ("%s%d: invalid ipcp configure request packet length: %d bytes\n", 1171 ifp->if_name, ifp->if_unit, len); 1172 return; 1173 } 1174 if (len > 4) { 1175 sppp_cp_send (sp, PPP_IPCP, LCP_CONF_REJ, h->ident, 1176 len-4, h+1); 1177 1178 switch (sp->ipcp.state) { 1179 case IPCP_STATE_OPENED: 1180 /* Initiate renegotiation. */ 1181 sppp_ipcp_open (sp); 1182 /* fall through... */ 1183 case IPCP_STATE_ACK_SENT: 1184 /* Go to closed state. */ 1185 sp->ipcp.state = IPCP_STATE_CLOSED; 1186 } 1187 } else { 1188 /* Send Configure-Ack packet. */ 1189 sppp_cp_send (sp, PPP_IPCP, IPCP_CONF_ACK, h->ident, 1190 0, 0); 1191 /* Change the state. */ 1192 if (sp->ipcp.state == IPCP_STATE_ACK_RCVD) 1193 sp->ipcp.state = IPCP_STATE_OPENED; 1194 else 1195 sp->ipcp.state = IPCP_STATE_ACK_SENT; 1196 } 1197 break; 1198 case IPCP_CONF_ACK: 1199 if (h->ident != sp->ipcp.confid) 1200 break; 1201 UNTIMO (sp); 1202 switch (sp->ipcp.state) { 1203 case IPCP_STATE_CLOSED: 1204 sp->ipcp.state = IPCP_STATE_ACK_RCVD; 1205 TIMO (sp, 5); 1206 break; 1207 case IPCP_STATE_ACK_SENT: 1208 sp->ipcp.state = IPCP_STATE_OPENED; 1209 break; 1210 } 1211 break; 1212 case IPCP_CONF_NAK: 1213 case IPCP_CONF_REJ: 1214 if (h->ident != sp->ipcp.confid) 1215 break; 1216 UNTIMO (sp); 1217 /* Initiate renegotiation. */ 1218 sppp_ipcp_open (sp); 1219 if (sp->ipcp.state != IPCP_STATE_ACK_SENT) 1220 /* Go to closed state. */ 1221 sp->ipcp.state = IPCP_STATE_CLOSED; 1222 break; 1223 case IPCP_TERM_REQ: 1224 /* Send Terminate-Ack packet. */ 1225 sppp_cp_send (sp, PPP_IPCP, IPCP_TERM_ACK, h->ident, 0, 0); 1226 /* Go to closed state. */ 1227 sp->ipcp.state = IPCP_STATE_CLOSED; 1228 /* Initiate renegotiation. */ 1229 sppp_ipcp_open (sp); 1230 break; 1231 case IPCP_TERM_ACK: 1232 /* Ignore for now. */ 1233 case IPCP_CODE_REJ: 1234 /* Ignore for now. */ 1235 break; 1236 } 1237} 1238 1239void sppp_lcp_open (struct sppp *sp) 1240{ 1241 char opt[6]; 1242 1243 if (! sp->lcp.magic) 1244 sp->lcp.magic = time.tv_sec + time.tv_usec; 1245 opt[0] = LCP_OPT_MAGIC; 1246 opt[1] = sizeof (opt); 1247 opt[2] = sp->lcp.magic >> 24; 1248 opt[3] = sp->lcp.magic >> 16; 1249 opt[4] = sp->lcp.magic >> 8; 1250 opt[5] = sp->lcp.magic; 1251 sp->lcp.confid = ++sp->pp_seq; 1252 sppp_cp_send (sp, PPP_LCP, LCP_CONF_REQ, sp->lcp.confid, 1253 sizeof (opt), &opt); 1254 TIMO (sp, 2); 1255} 1256 1257void sppp_ipcp_open (struct sppp *sp) 1258{ 1259 sp->ipcp.confid = ++sp->pp_seq; 1260 sppp_cp_send (sp, PPP_IPCP, IPCP_CONF_REQ, sp->ipcp.confid, 0, 0); 1261 TIMO (sp, 2); 1262} 1263 1264/* 1265 * Process PPP control protocol timeouts. 1266 */ 1267void sppp_cp_timeout (void *arg) 1268{ 1269 struct sppp *sp = (struct sppp*) arg; 1270 int s = splimp (); 1271 1272 sp->pp_flags &= ~PP_TIMO; 1273 if (! (sp->pp_if.if_flags & IFF_RUNNING) || (sp->pp_flags & PP_CISCO)) { 1274 splx (s); 1275 return; 1276 } 1277 switch (sp->lcp.state) { 1278 case LCP_STATE_CLOSED: 1279 /* No ACK for Configure-Request, retry. */ 1280 sppp_lcp_open (sp); 1281 break; 1282 case LCP_STATE_ACK_RCVD: 1283 /* ACK got, but no Configure-Request for peer, retry. */ 1284 sppp_lcp_open (sp); 1285 sp->lcp.state = LCP_STATE_CLOSED; 1286 break; 1287 case LCP_STATE_ACK_SENT: 1288 /* ACK sent but no ACK for Configure-Request, retry. */ 1289 sppp_lcp_open (sp); 1290 break; 1291 case LCP_STATE_OPENED: 1292 /* LCP is already OK, try IPCP. */ 1293 switch (sp->ipcp.state) { 1294 case IPCP_STATE_CLOSED: 1295 /* No ACK for Configure-Request, retry. */ 1296 sppp_ipcp_open (sp); 1297 break; 1298 case IPCP_STATE_ACK_RCVD: 1299 /* ACK got, but no Configure-Request for peer, retry. */ 1300 sppp_ipcp_open (sp); 1301 sp->ipcp.state = IPCP_STATE_CLOSED; 1302 break; 1303 case IPCP_STATE_ACK_SENT: 1304 /* ACK sent but no ACK for Configure-Request, retry. */ 1305 sppp_ipcp_open (sp); 1306 break; 1307 case IPCP_STATE_OPENED: 1308 /* IPCP is OK. */ 1309 break; 1310 } 1311 break; 1312 } 1313 splx (s); 1314} 1315 1316char *sppp_lcp_type_name (u_char type) 1317{ 1318 static char buf [8]; 1319 switch (type) { 1320 case LCP_CONF_REQ: return ("conf-req"); 1321 case LCP_CONF_ACK: return ("conf-ack"); 1322 case LCP_CONF_NAK: return ("conf-nack"); 1323 case LCP_CONF_REJ: return ("conf-rej"); 1324 case LCP_TERM_REQ: return ("term-req"); 1325 case LCP_TERM_ACK: return ("term-ack"); 1326 case LCP_CODE_REJ: return ("code-rej"); 1327 case LCP_PROTO_REJ: return ("proto-rej"); 1328 case LCP_ECHO_REQ: return ("echo-req"); 1329 case LCP_ECHO_REPLY: return ("echo-reply"); 1330 case LCP_DISC_REQ: return ("discard-req"); 1331 } 1332 sprintf (buf, "%xh", type); 1333 return (buf); 1334} 1335 1336char *sppp_ipcp_type_name (u_char type) 1337{ 1338 static char buf [8]; 1339 switch (type) { 1340 case IPCP_CONF_REQ: return ("conf-req"); 1341 case IPCP_CONF_ACK: return ("conf-ack"); 1342 case IPCP_CONF_NAK: return ("conf-nack"); 1343 case IPCP_CONF_REJ: return ("conf-rej"); 1344 case IPCP_TERM_REQ: return ("term-req"); 1345 case IPCP_TERM_ACK: return ("term-ack"); 1346 case IPCP_CODE_REJ: return ("code-rej"); 1347 } 1348 sprintf (buf, "%xh", type); 1349 return (buf); 1350} 1351 1352void sppp_print_bytes (u_char *p, u_short len) 1353{ 1354 printf (" %x", *p++); 1355 while (--len > 0) 1356 printf ("-%x", *p++); 1357} 1358