Lines Matching defs:sp
216 void (*Up)(struct sppp *sp);
217 void (*Down)(struct sppp *sp);
218 void (*Open)(struct sppp *sp);
219 void (*Close)(struct sppp *sp);
220 void (*TO)(void *sp);
221 int (*RCR)(struct sppp *sp, struct lcp_header *h, int len);
222 void (*RCN_rej)(struct sppp *sp, struct lcp_header *h, int len);
223 void (*RCN_nak)(struct sppp *sp, struct lcp_header *h, int len);
225 void (*tlu)(struct sppp *sp);
226 void (*tld)(struct sppp *sp);
227 void (*tls)(struct sppp *sp);
228 void (*tlf)(struct sppp *sp);
229 void (*scr)(struct sppp *sp);
235 #define SPPP_LOCK(sp) mtx_lock (&(sp)->mtx)
236 #define SPPP_UNLOCK(sp) mtx_unlock (&(sp)->mtx)
237 #define SPPP_LOCK_ASSERT(sp) mtx_assert (&(sp)->mtx, MA_OWNED)
238 #define SPPP_LOCK_OWNED(sp) mtx_owned (&(sp)->mtx)
258 struct ifnet *ifp = SP2IFP(sp); \
264 static void sppp_cisco_send(struct sppp *sp, int type, long par1, long par2);
265 static void sppp_cisco_input(struct sppp *sp, struct mbuf *m);
267 static void sppp_cp_input(const struct cp *cp, struct sppp *sp,
269 static void sppp_cp_send(struct sppp *sp, u_short proto, u_char type,
272 static void sppp_cp_change_state(const struct cp *cp, struct sppp *sp,
275 struct sppp *sp, unsigned int type, unsigned int id,
278 static void sppp_up_event(const struct cp *cp, struct sppp *sp);
279 static void sppp_down_event(const struct cp *cp, struct sppp *sp);
280 static void sppp_open_event(const struct cp *cp, struct sppp *sp);
281 static void sppp_close_event(const struct cp *cp, struct sppp *sp);
282 static void sppp_to_event(const struct cp *cp, struct sppp *sp);
284 static void sppp_null(struct sppp *sp);
286 static void sppp_pp_up(struct sppp *sp);
287 static void sppp_pp_down(struct sppp *sp);
289 static void sppp_lcp_init(struct sppp *sp);
290 static void sppp_lcp_up(struct sppp *sp);
291 static void sppp_lcp_down(struct sppp *sp);
292 static void sppp_lcp_open(struct sppp *sp);
293 static void sppp_lcp_close(struct sppp *sp);
294 static void sppp_lcp_TO(void *sp);
295 static int sppp_lcp_RCR(struct sppp *sp, struct lcp_header *h, int len);
296 static void sppp_lcp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len);
297 static void sppp_lcp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len);
298 static void sppp_lcp_tlu(struct sppp *sp);
299 static void sppp_lcp_tld(struct sppp *sp);
300 static void sppp_lcp_tls(struct sppp *sp);
301 static void sppp_lcp_tlf(struct sppp *sp);
302 static void sppp_lcp_scr(struct sppp *sp);
303 static void sppp_lcp_check_and_close(struct sppp *sp);
304 static int sppp_ncp_check(struct sppp *sp);
306 static void sppp_ipcp_init(struct sppp *sp);
307 static void sppp_ipcp_up(struct sppp *sp);
308 static void sppp_ipcp_down(struct sppp *sp);
309 static void sppp_ipcp_open(struct sppp *sp);
310 static void sppp_ipcp_close(struct sppp *sp);
311 static void sppp_ipcp_TO(void *sp);
312 static int sppp_ipcp_RCR(struct sppp *sp, struct lcp_header *h, int len);
313 static void sppp_ipcp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len);
314 static void sppp_ipcp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len);
315 static void sppp_ipcp_tlu(struct sppp *sp);
316 static void sppp_ipcp_tld(struct sppp *sp);
317 static void sppp_ipcp_tls(struct sppp *sp);
318 static void sppp_ipcp_tlf(struct sppp *sp);
319 static void sppp_ipcp_scr(struct sppp *sp);
321 static void sppp_ipv6cp_init(struct sppp *sp);
322 static void sppp_ipv6cp_up(struct sppp *sp);
323 static void sppp_ipv6cp_down(struct sppp *sp);
324 static void sppp_ipv6cp_open(struct sppp *sp);
325 static void sppp_ipv6cp_close(struct sppp *sp);
326 static void sppp_ipv6cp_TO(void *sp);
327 static int sppp_ipv6cp_RCR(struct sppp *sp, struct lcp_header *h, int len);
328 static void sppp_ipv6cp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len);
329 static void sppp_ipv6cp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len);
330 static void sppp_ipv6cp_tlu(struct sppp *sp);
331 static void sppp_ipv6cp_tld(struct sppp *sp);
332 static void sppp_ipv6cp_tls(struct sppp *sp);
333 static void sppp_ipv6cp_tlf(struct sppp *sp);
334 static void sppp_ipv6cp_scr(struct sppp *sp);
336 static void sppp_pap_input(struct sppp *sp, struct mbuf *m);
337 static void sppp_pap_init(struct sppp *sp);
338 static void sppp_pap_open(struct sppp *sp);
339 static void sppp_pap_close(struct sppp *sp);
340 static void sppp_pap_TO(void *sp);
341 static void sppp_pap_my_TO(void *sp);
342 static void sppp_pap_tlu(struct sppp *sp);
343 static void sppp_pap_tld(struct sppp *sp);
344 static void sppp_pap_scr(struct sppp *sp);
346 static void sppp_chap_input(struct sppp *sp, struct mbuf *m);
347 static void sppp_chap_init(struct sppp *sp);
348 static void sppp_chap_open(struct sppp *sp);
349 static void sppp_chap_close(struct sppp *sp);
350 static void sppp_chap_TO(void *sp);
351 static void sppp_chap_tlu(struct sppp *sp);
352 static void sppp_chap_tld(struct sppp *sp);
353 static void sppp_chap_scr(struct sppp *sp);
368 static int sppp_params(struct sppp *sp, u_long cmd, void *data);
371 static void sppp_phase_network(struct sppp *sp);
376 static void sppp_set_ip_addr(struct sppp *sp, u_long src);
379 static void sppp_get_ip6_addrs(struct sppp *sp, struct in6_addr *src,
382 static void sppp_set_ip6_addr(struct sppp *sp, const struct in6_addr *src);
383 static void sppp_gen_ip6_addr(struct sppp *sp, const struct in6_addr *src);
385 static void sppp_suggest_ip6_addr(struct sppp *sp, struct in6_addr *src);
455 struct sppp *sp;
457 sp = malloc(sizeof(struct sppp), M_SPPP, M_WAITOK | M_ZERO);
458 sp->pp_ifp = ifp;
460 return (sp);
511 struct sppp *sp = IFP2SP(ifp);
518 SPPP_LOCK(sp);
533 SPPP_UNLOCK(sp);
540 if (sp->pp_mode == PP_FR) {
541 sppp_fr_input (sp, m);
542 SPPP_UNLOCK(sp);
554 if (sp->pp_mode == IFF_CISCO) {
571 if (sp->state[IDX_LCP] == STATE_OPENED)
572 sppp_cp_send (sp, PPP_LCP, PROTO_REJ,
573 ++sp->pp_seq[IDX_LCP], m->m_pkthdr.len + 2,
578 sppp_cp_input(&lcp, sp, m);
580 SPPP_UNLOCK(sp);
583 if (sp->pp_phase >= PHASE_AUTHENTICATE)
584 sppp_pap_input(sp, m);
586 SPPP_UNLOCK(sp);
589 if (sp->pp_phase >= PHASE_AUTHENTICATE)
590 sppp_chap_input(sp, m);
592 SPPP_UNLOCK(sp);
596 if (sp->pp_phase == PHASE_NETWORK)
597 sppp_cp_input(&ipcp, sp, m);
599 SPPP_UNLOCK(sp);
602 if (sp->state[IDX_IPCP] == STATE_OPENED) {
608 if (sp->state[IDX_IPCP] == STATE_OPENED) {
613 sp->pp_comp,
631 SPPP_UNLOCK(sp);
640 if (sp->state[IDX_IPCP] == STATE_OPENED) {
644 sp->pp_comp,
659 if (sp->pp_phase == PHASE_NETWORK)
660 sppp_cp_input(&ipv6cp, sp, m);
662 SPPP_UNLOCK(sp);
666 if (sp->state[IDX_IPV6CP] == STATE_OPENED)
676 if (sp->pp_mode != IFF_CISCO) {
690 sppp_cisco_input (sp, m);
692 SPPP_UNLOCK(sp);
722 SPPP_UNLOCK(sp);
738 sp->pp_last_recv = time_uptime;
744 struct sppp *sp = dummy;
746 sp->if_start(SP2IFP(sp));
755 struct sppp *sp = IFP2SP(ifp);
757 if (SPPP_LOCK_OWNED(sp)) {
758 if (callout_pending(&sp->ifstart_callout))
760 callout_reset(&sp->ifstart_callout, 1, sppp_ifstart_sched,
761 (void *)sp);
763 sp->if_start(ifp);
774 struct sppp *sp = IFP2SP(ifp);
783 SPPP_LOCK(sp);
792 SPPP_UNLOCK(sp);
808 !(sp->confflags & CONF_ENABLE_IPV6))
816 lcp.Open(sp);
839 SPPP_UNLOCK(sp);
852 else if (_IF_QFULL(&sp->pp_fastq))
855 ifq = &sp->pp_fastq;
861 ifq = &sp->pp_fastq;
863 ifq = &sp->pp_fastq;
868 if (sp->pp_mode != IFF_CISCO && sp->pp_mode != PP_FR &&
869 (sp->ipcp.flags & IPCP_VJ) && ip->ip_p == IPPROTO_TCP)
870 switch (sl_compress_tcp(m, ip, sp->pp_comp,
871 sp->ipcp.compress_cid)) {
883 SPPP_UNLOCK(sp);
895 if (sp->pp_mode == PP_FR) {
897 m = sppp_fr_header (sp, m, dst->sa_family);
912 SPPP_UNLOCK(sp);
920 if (sp->pp_mode == IFF_CISCO) {
931 if (sp->pp_mode == IFF_CISCO)
944 if (sp->state[IDX_IPCP] != STATE_OPENED)
951 if (sp->pp_mode == IFF_CISCO)
964 if (sp->state[IDX_IPV6CP] != STATE_OPENED)
972 SPPP_UNLOCK(sp);
987 SPPP_UNLOCK(sp);
990 SPPP_UNLOCK(sp);
997 sp->pp_last_sent = time_uptime;
1004 struct sppp *sp = IFP2SP(ifp);
1007 mtx_init(&sp->mtx, "sppp", MTX_NETWORK_LOCK, MTX_DEF | MTX_RECURSE);
1010 callout_init(&sp->keepalive_callout, 1);
1011 callout_reset(&sp->keepalive_callout, hz * 10, sppp_keepalive,
1012 (void *)sp);
1018 sp->pp_flags = PP_KEEPALIVE;
1021 sp->pp_fastq.ifq_maxlen = 32;
1022 sp->pp_cpq.ifq_maxlen = 20;
1023 sp->pp_loopcnt = 0;
1024 sp->pp_alivecnt = 0;
1025 bzero(&sp->pp_seq[0], sizeof(sp->pp_seq));
1026 bzero(&sp->pp_rseq[0], sizeof(sp->pp_rseq));
1027 sp->pp_phase = PHASE_DEAD;
1028 sp->pp_up = sppp_pp_up;
1029 sp->pp_down = sppp_pp_down;
1030 if(!mtx_initialized(&sp->pp_cpq.ifq_mtx))
1031 mtx_init(&sp->pp_cpq.ifq_mtx, "sppp_cpq", NULL, MTX_DEF);
1032 if(!mtx_initialized(&sp->pp_fastq.ifq_mtx))
1033 mtx_init(&sp->pp_fastq.ifq_mtx, "sppp_fastq", NULL, MTX_DEF);
1034 sp->pp_last_recv = sp->pp_last_sent = time_uptime;
1035 sp->confflags = 0;
1037 sp->confflags |= CONF_ENABLE_VJ;
1040 sp->confflags |= CONF_ENABLE_IPV6;
1042 callout_init(&sp->ifstart_callout, 1);
1043 sp->if_start = ifp->if_start;
1045 sp->pp_comp = malloc(sizeof(struct slcompress), M_TEMP, M_WAITOK);
1046 sl_compress_init(sp->pp_comp, -1);
1047 sppp_lcp_init(sp);
1048 sppp_ipcp_init(sp);
1049 sppp_ipv6cp_init(sp);
1050 sppp_pap_init(sp);
1051 sppp_chap_init(sp);
1057 struct sppp *sp = IFP2SP(ifp);
1060 KASSERT(mtx_initialized(&sp->mtx), ("sppp mutex is not initialized"));
1063 if (!callout_drain(&sp->keepalive_callout))
1064 callout_stop(&sp->keepalive_callout);
1067 if (!callout_drain(&sp->ch[i]))
1068 callout_stop(&sp->ch[i]);
1070 if (!callout_drain(&sp->pap_my_to_ch))
1071 callout_stop(&sp->pap_my_to_ch);
1072 mtx_destroy(&sp->pp_cpq.ifq_mtx);
1073 mtx_destroy(&sp->pp_fastq.ifq_mtx);
1074 mtx_destroy(&sp->mtx);
1083 struct sppp *sp = IFP2SP(ifp);
1085 sppp_qflush ((struct ifqueue *)&SP2IFP(sp)->if_snd);
1086 sppp_qflush (&sp->pp_fastq);
1087 sppp_qflush (&sp->pp_cpq);
1093 struct sppp *sp = IFP2SP(ifp);
1095 SPPP_LOCK(sp);
1097 SPPP_UNLOCK(sp);
1106 struct sppp *sp = IFP2SP(ifp);
1109 SPPP_LOCK(sp);
1110 empty = !sp->pp_fastq.ifq_head && !sp->pp_cpq.ifq_head &&
1111 !SP2IFP(sp)->if_snd.ifq_head;
1112 SPPP_UNLOCK(sp);
1122 struct sppp *sp = IFP2SP(ifp);
1125 SPPP_LOCK(sp);
1132 IF_DEQUEUE(&sp->pp_cpq, m);
1134 (sppp_ncp_check(sp) || sp->pp_mode == IFF_CISCO ||
1135 sp->pp_mode == PP_FR)) {
1136 IF_DEQUEUE(&sp->pp_fastq, m);
1138 IF_DEQUEUE (&SP2IFP(sp)->if_snd, m);
1140 SPPP_UNLOCK(sp);
1150 struct sppp *sp = IFP2SP(ifp);
1153 SPPP_LOCK(sp);
1155 m = sp->pp_cpq.ifq_head;
1157 (sp->pp_phase == PHASE_NETWORK ||
1158 sp->pp_mode == IFF_CISCO ||
1159 sp->pp_mode == PP_FR))
1160 if ((m = sp->pp_fastq.ifq_head) == NULL)
1161 m = SP2IFP(sp)->if_snd.ifq_head;
1162 SPPP_UNLOCK(sp);
1173 struct sppp *sp = IFP2SP(ifp);
1176 SPPP_LOCK(sp);
1202 newmode = sp->pp_flags & PP_FR;
1204 if (newmode != sp->pp_mode) {
1211 if (sp->pp_mode != IFF_CISCO &&
1212 sp->pp_mode != PP_FR)
1213 lcp.Close(sp);
1214 else if (sp->pp_tlf)
1215 (sp->pp_tlf)(sp);
1218 sp->pp_mode = newmode;
1222 if (sp->pp_mode != IFF_CISCO &&
1223 sp->pp_mode != PP_FR)
1224 lcp.Close(sp);
1225 sp->pp_mode = newmode;
1226 if (sp->pp_mode == 0) {
1228 lcp.Open(sp);
1230 if ((sp->pp_mode == IFF_CISCO) ||
1231 (sp->pp_mode == PP_FR)) {
1232 if (sp->pp_tls)
1233 (sp->pp_tls)(sp);
1245 if (ifr->ifr_mtu < 128 || ifr->ifr_mtu > sp->lcp.their_mru)
1252 if (*(short*)data < 128 || *(short*)data > sp->lcp.their_mru)
1273 rv = sppp_params(sp, cmd, data);
1279 SPPP_UNLOCK(sp);
1291 sppp_cisco_input(struct sppp *sp, struct mbuf *m)
1322 sp->pp_alivecnt = 0;
1323 sp->pp_rseq[IDX_LCP] = ntohl (h->par1);
1324 if (sp->pp_seq[IDX_LCP] == sp->pp_rseq[IDX_LCP]) {
1327 if (sp->pp_loopcnt >= MAXALIVECNT) {
1330 sp->pp_loopcnt = 0;
1333 sppp_qflush (&sp->pp_cpq);
1336 ++sp->pp_loopcnt;
1339 sp->pp_seq[IDX_LCP] = random();
1342 sp->pp_loopcnt = 0;
1350 sppp_get_ip_addrs(sp, &me, 0, &mymask);
1352 sppp_cisco_send(sp, CISCO_ADDR_REPLY, me, mymask);
1361 sppp_cisco_send(struct sppp *sp, int type, long par1, long par2)
1397 if (! IF_HANDOFF_ADJ(&sp->pp_cpq, m, ifp, 3))
1409 sppp_cp_send(struct sppp *sp, u_short proto, u_char type,
1446 if (! IF_HANDOFF_ADJ(&sp->pp_cpq, m, ifp, 3))
1454 sppp_cp_input(const struct cp *cp, struct sppp *sp, struct mbuf *m)
1474 sppp_state_name(sp->state[cp->protoidx]),
1493 switch (sp->state[cp->protoidx]) {
1498 sppp_cp_send(sp, cp->proto, TERM_ACK, h->ident,
1502 rv = (cp->RCR)(sp, h, len);
1503 switch (sp->state[cp->protoidx]) {
1505 (cp->tld)(sp);
1506 (cp->scr)(sp);
1517 if (sp->state[cp->protoidx] == (rv ? STATE_ACK_SENT:
1520 sppp_cp_change_state(cp, sp, rv?
1524 sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
1525 (cp->scr)(sp);
1526 sppp_cp_change_state(cp, sp, rv?
1531 sppp_cp_change_state(cp, sp, STATE_OPENED);
1536 (cp->tlu)(sp);
1538 sppp_cp_change_state(cp, sp, STATE_ACK_RCVD);
1544 sppp_state_name(sp->state[cp->protoidx]));
1549 if (h->ident != sp->confid[cp->protoidx]) {
1553 h->ident, sp->confid[cp->protoidx]);
1557 switch (sp->state[cp->protoidx]) {
1560 sppp_cp_send(sp, cp->proto, TERM_ACK, h->ident, 0, 0);
1566 sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
1567 sppp_cp_change_state(cp, sp, STATE_ACK_RCVD);
1570 (cp->tld)(sp);
1573 (cp->scr)(sp);
1574 sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
1577 sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
1578 sppp_cp_change_state(cp, sp, STATE_OPENED);
1582 (cp->tlu)(sp);
1588 sppp_state_name(sp->state[cp->protoidx]));
1594 if (h->ident != sp->confid[cp->protoidx]) {
1598 h->ident, sp->confid[cp->protoidx]);
1603 (cp->RCN_nak)(sp, h, len);
1605 (cp->RCN_rej)(sp, h, len);
1607 switch (sp->state[cp->protoidx]) {
1610 sppp_cp_send(sp, cp->proto, TERM_ACK, h->ident, 0, 0);
1614 sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
1620 if (sp->pp_loopcnt)
1622 (cp->scr)(sp);
1625 (cp->tld)(sp);
1628 sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
1629 (cp->scr)(sp);
1638 sppp_state_name(sp->state[cp->protoidx]));
1644 switch (sp->state[cp->protoidx]) {
1647 sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
1659 sppp_cp_send(sp, cp->proto, TERM_ACK, h->ident, 0, 0);
1662 (cp->tld)(sp);
1663 sp->rst_counter[cp->protoidx] = 0;
1664 sppp_cp_change_state(cp, sp, STATE_STOPPING);
1671 sppp_state_name(sp->state[cp->protoidx]));
1676 switch (sp->state[cp->protoidx]) {
1683 sppp_cp_change_state(cp, sp, STATE_CLOSED);
1684 (cp->tlf)(sp);
1687 sppp_cp_change_state(cp, sp, STATE_STOPPED);
1688 (cp->tlf)(sp);
1691 sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
1694 (cp->tld)(sp);
1695 (cp->scr)(sp);
1696 sppp_cp_change_state(cp, sp, STATE_ACK_RCVD);
1702 sppp_state_name(sp->state[cp->protoidx]));
1713 switch (sp->state[cp->protoidx]) {
1723 sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
1729 sppp_state_name(sp->state[cp->protoidx]));
1758 upper ? sppp_state_name(sp->state[upper->protoidx]) : "?");
1765 if (sp->state[upper->protoidx] == STATE_REQ_SENT) {
1766 upper->Close(sp);
1772 switch (sp->state[cp->protoidx]) {
1782 sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
1788 sppp_state_name(sp->state[cp->protoidx]));
1801 if (sp->state[cp->protoidx] != STATE_OPENED) {
1815 if ((sp->lcp.opts & (1 << LCP_OPT_MAGIC)) &&
1816 ntohl (*(long*)(h+1)) == sp->lcp.magic) {
1819 sp->pp_loopcnt = MAXALIVECNT * 5;
1821 sppp_qflush (&sp->pp_cpq);
1825 lcp.Down(sp);
1826 lcp.Up(sp);
1829 *(long*)(h+1) = htonl (sp->lcp.magic);
1833 sppp_cp_send (sp, PPP_LCP, ECHO_REPLY, h->ident, len-4, h+1);
1838 if (h->ident != sp->lcp.echoid) {
1852 if (!(sp->lcp.opts & (1 << LCP_OPT_MAGIC)) ||
1853 ntohl (*(long*)(h+1)) != sp->lcp.magic)
1854 sp->pp_alivecnt = 0;
1862 sppp_cp_send(sp, cp->proto, CODE_REJ,
1863 ++sp->pp_seq[cp->protoidx], m->m_pkthdr.len, h);
1874 sppp_up_event(const struct cp *cp, struct sppp *sp)
1881 sppp_state_name(sp->state[cp->protoidx]));
1883 switch (sp->state[cp->protoidx]) {
1885 sppp_cp_change_state(cp, sp, STATE_CLOSED);
1888 sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
1889 (cp->scr)(sp);
1890 sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
1895 sppp_state_name(sp->state[cp->protoidx]));
1900 sppp_down_event(const struct cp *cp, struct sppp *sp)
1907 sppp_state_name(sp->state[cp->protoidx]));
1909 switch (sp->state[cp->protoidx]) {
1912 sppp_cp_change_state(cp, sp, STATE_INITIAL);
1915 sppp_cp_change_state(cp, sp, STATE_STARTING);
1916 (cp->tls)(sp);
1922 sppp_cp_change_state(cp, sp, STATE_STARTING);
1925 (cp->tld)(sp);
1926 sppp_cp_change_state(cp, sp, STATE_STARTING);
1931 sppp_state_name(sp->state[cp->protoidx]));
1937 sppp_open_event(const struct cp *cp, struct sppp *sp)
1944 sppp_state_name(sp->state[cp->protoidx]));
1946 switch (sp->state[cp->protoidx]) {
1948 sppp_cp_change_state(cp, sp, STATE_STARTING);
1949 (cp->tls)(sp);
1954 sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
1955 (cp->scr)(sp);
1956 sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
1970 sppp_cp_change_state(cp, sp, STATE_STARTING);
1971 (cp->tls)(sp);
1980 sppp_cp_change_state(cp, sp, STATE_STOPPING);
1987 sppp_close_event(const struct cp *cp, struct sppp *sp)
1994 sppp_state_name(sp->state[cp->protoidx]));
1996 switch (sp->state[cp->protoidx]) {
2002 sppp_cp_change_state(cp, sp, STATE_INITIAL);
2003 (cp->tlf)(sp);
2006 sppp_cp_change_state(cp, sp, STATE_CLOSED);
2009 sppp_cp_change_state(cp, sp, STATE_CLOSING);
2012 (cp->tld)(sp);
2017 sp->rst_counter[cp->protoidx] = sp->lcp.max_terminate;
2018 sppp_cp_send(sp, cp->proto, TERM_REQ,
2019 ++sp->pp_seq[cp->protoidx], 0, 0);
2020 sppp_cp_change_state(cp, sp, STATE_CLOSING);
2026 sppp_to_event(const struct cp *cp, struct sppp *sp)
2030 SPPP_LOCK(sp);
2034 sppp_state_name(sp->state[cp->protoidx]),
2035 sp->rst_counter[cp->protoidx]);
2037 if (--sp->rst_counter[cp->protoidx] < 0)
2039 switch (sp->state[cp->protoidx]) {
2041 sppp_cp_change_state(cp, sp, STATE_CLOSED);
2042 (cp->tlf)(sp);
2045 sppp_cp_change_state(cp, sp, STATE_STOPPED);
2046 (cp->tlf)(sp);
2051 sppp_cp_change_state(cp, sp, STATE_STOPPED);
2052 (cp->tlf)(sp);
2057 switch (sp->state[cp->protoidx]) {
2060 sppp_cp_send(sp, cp->proto, TERM_REQ,
2061 ++sp->pp_seq[cp->protoidx], 0, 0);
2062 callout_reset(&sp->ch[cp->protoidx], sp->lcp.timeout,
2063 cp->TO, (void *)sp);
2067 (cp->scr)(sp);
2069 sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
2072 (cp->scr)(sp);
2073 callout_reset(&sp->ch[cp->protoidx], sp->lcp.timeout,
2074 cp->TO, (void *)sp);
2078 SPPP_UNLOCK(sp);
2086 sppp_cp_change_state(const struct cp *cp, struct sppp *sp, int newstate)
2088 sp->state[cp->protoidx] = newstate;
2090 callout_stop (&sp->ch[cp->protoidx]);
2104 callout_reset(&sp->ch[cp->protoidx], sp->lcp.timeout,
2105 cp->TO, (void *)sp);
2118 sppp_pp_up(struct sppp *sp)
2120 SPPP_LOCK(sp);
2121 lcp.Up(sp);
2122 SPPP_UNLOCK(sp);
2126 sppp_pp_down(struct sppp *sp)
2128 SPPP_LOCK(sp);
2129 lcp.Down(sp);
2130 SPPP_UNLOCK(sp);
2134 sppp_lcp_init(struct sppp *sp)
2136 sp->lcp.opts = (1 << LCP_OPT_MAGIC);
2137 sp->lcp.magic = 0;
2138 sp->state[IDX_LCP] = STATE_INITIAL;
2139 sp->fail_counter[IDX_LCP] = 0;
2140 sp->pp_seq[IDX_LCP] = 0;
2141 sp->pp_rseq[IDX_LCP] = 0;
2142 sp->lcp.protos = 0;
2143 sp->lcp.mru = sp->lcp.their_mru = PP_MTU;
2146 sp->lcp.timeout = 3 * hz;
2147 sp->lcp.max_terminate = 2;
2148 sp->lcp.max_configure = 10;
2149 sp->lcp.max_failure = 10;
2150 callout_init(&sp->ch[IDX_LCP], 1);
2154 sppp_lcp_up(struct sppp *sp)
2158 sp->pp_alivecnt = 0;
2159 sp->lcp.opts = (1 << LCP_OPT_MAGIC);
2160 sp->lcp.magic = 0;
2161 sp->lcp.protos = 0;
2162 sp->lcp.mru = sp->lcp.their_mru = PP_MTU;
2166 if (sp->hisauth.proto != 0)
2167 sp->lcp.opts |= (1 << LCP_OPT_AUTH_PROTO);
2169 sp->lcp.opts &= ~(1 << LCP_OPT_AUTH_PROTO);
2170 sp->pp_flags &= ~PP_NEEDAUTH;
2181 if (sp->state[IDX_LCP] == STATE_INITIAL) {
2184 sp->pp_flags |= PP_CALLIN;
2185 lcp.Open(sp);
2189 (sp->state[IDX_LCP] == STATE_INITIAL)) {
2191 lcp.Open(sp);
2194 sppp_up_event(&lcp, sp);
2198 sppp_lcp_down(struct sppp *sp)
2202 sppp_down_event(&lcp, sp);
2221 sp->pp_flags &= ~PP_CALLIN;
2222 if (sp->state[IDX_LCP] != STATE_INITIAL)
2223 lcp.Close(sp);
2229 sppp_lcp_open(struct sppp *sp)
2231 sppp_open_event(&lcp, sp);
2235 sppp_lcp_close(struct sppp *sp)
2237 sppp_close_event(&lcp, sp);
2253 sppp_lcp_RCR(struct sppp *sp, struct lcp_header *h, int len)
2311 if (sp->myauth.proto == 0) {
2322 sp->pp_flags |= PP_NEEDAUTH;
2338 sppp_cp_send (sp, PPP_LCP, CONF_REJ, h->ident, rlen, buf);
2362 if (nmagic != sp->lcp.magic) {
2363 sp->pp_loopcnt = 0;
2368 if (debug && sp->pp_loopcnt < MAXALIVECNT*5)
2370 ++sp->pp_loopcnt;
2376 nmagic = ~sp->lcp.magic;
2406 sp->lcp.their_mru = p[2] * 256 + p[3];
2408 log(-1, "%lu ", sp->lcp.their_mru);
2413 if (sp->myauth.proto != authproto) {
2417 sppp_proto_name(sp->hisauth.proto),
2419 p[2] = sp->myauth.proto >> 8;
2420 p[3] = sp->myauth.proto;
2440 if (sp->pp_loopcnt >= MAXALIVECNT*5) {
2441 if (sp->pp_loopcnt == MAXALIVECNT*5)
2446 sppp_qflush(&sp->pp_cpq);
2448 lcp.Down(sp);
2449 lcp.Up(sp);
2451 } else if (!sp->pp_loopcnt &&
2452 ++sp->fail_counter[IDX_LCP] >= sp->lcp.max_failure) {
2456 sp->lcp.max_failure);
2457 sppp_cp_send(sp, PPP_LCP, CONF_REJ, h->ident, rlen, buf);
2461 sppp_cp_send (sp, PPP_LCP, CONF_NAK, h->ident, rlen, buf);
2466 sp->fail_counter[IDX_LCP] = 0;
2467 sp->pp_loopcnt = 0;
2468 sppp_cp_send (sp, PPP_LCP, CONF_ACK,
2481 sppp_lcp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len)
2503 sp->lcp.opts &= ~(1 << LCP_OPT_MAGIC);
2504 sp->lcp.magic = 0;
2512 sp->lcp.opts &= ~(1 << LCP_OPT_MRU);
2520 if ((sp->pp_flags & PP_CALLIN) == 0 &&
2521 (sp->hisauth.flags & AUTHFLAG_NOCALLOUT) != 0) {
2525 sp->lcp.opts &= ~(1 << LCP_OPT_AUTH_PROTO);
2530 lcp.Close(sp);
2545 sppp_lcp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len)
2568 if ((sp->lcp.opts & (1 << LCP_OPT_MAGIC)) &&
2577 if (magic == ~sp->lcp.magic) {
2580 sp->lcp.magic = random();
2582 sp->lcp.magic = magic;
2600 sp->lcp.mru = mru;
2601 sp->lcp.opts |= (1 << LCP_OPT_MRU);
2611 lcp.Close(sp);
2622 sppp_lcp_tlu(struct sppp *sp)
2638 (cps[i])->Open(sp);
2640 if ((sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) != 0 ||
2641 (sp->pp_flags & PP_NEEDAUTH) != 0)
2642 sp->pp_phase = PHASE_AUTHENTICATE;
2644 sp->pp_phase = PHASE_NETWORK;
2648 sppp_phase_name(sp->pp_phase));
2659 (cps[i])->Open(sp);
2661 if (sp->pp_phase == PHASE_NETWORK) {
2673 (sp->confflags & CONF_ENABLE_IPV6)))
2674 (cps[i])->Open(sp);
2679 if ((sp->lcp.protos & mask) && ((cps[i])->flags & CP_LCP) == 0)
2680 (cps[i])->Up(sp);
2683 if (sp->pp_chg)
2684 sp->pp_chg(sp, (int)sp->pp_phase);
2686 if (sp->pp_phase == PHASE_NETWORK)
2688 sppp_lcp_check_and_close(sp);
2692 sppp_lcp_tld(struct sppp *sp)
2698 sp->pp_phase = PHASE_TERMINATE;
2702 sppp_phase_name(sp->pp_phase));
2711 if ((sp->lcp.protos & mask) && ((cps[i])->flags & CP_LCP) == 0) {
2712 (cps[i])->Down(sp);
2713 (cps[i])->Close(sp);
2718 sppp_lcp_tls(struct sppp *sp)
2722 sp->pp_phase = PHASE_ESTABLISH;
2726 sppp_phase_name(sp->pp_phase));
2729 if (sp->pp_tls)
2730 (sp->pp_tls)(sp);
2732 (sp->pp_up)(sp);
2736 sppp_lcp_tlf(struct sppp *sp)
2740 sp->pp_phase = PHASE_DEAD;
2743 sppp_phase_name(sp->pp_phase));
2746 if (sp->pp_tlf)
2747 (sp->pp_tlf)(sp);
2749 (sp->pp_down)(sp);
2753 sppp_lcp_scr(struct sppp *sp)
2759 if (sp->lcp.opts & (1 << LCP_OPT_MAGIC)) {
2760 if (! sp->lcp.magic)
2761 sp->lcp.magic = random();
2764 opt[i++] = sp->lcp.magic >> 24;
2765 opt[i++] = sp->lcp.magic >> 16;
2766 opt[i++] = sp->lcp.magic >> 8;
2767 opt[i++] = sp->lcp.magic;
2770 if (sp->lcp.opts & (1 << LCP_OPT_MRU)) {
2773 opt[i++] = sp->lcp.mru >> 8;
2774 opt[i++] = sp->lcp.mru;
2777 if (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) {
2778 authproto = sp->hisauth.proto;
2787 sp->confid[IDX_LCP] = ++sp->pp_seq[IDX_LCP];
2788 sppp_cp_send (sp, PPP_LCP, CONF_REQ, sp->confid[IDX_LCP], i, &opt);
2795 sppp_ncp_check(struct sppp *sp)
2800 if ((sp->lcp.protos & mask) && (cps[i])->flags & CP_NCP)
2810 sppp_lcp_check_and_close(struct sppp *sp)
2813 if (sp->pp_phase < PHASE_NETWORK)
2817 if (sppp_ncp_check(sp))
2820 lcp.Close(sp);
2833 sppp_ipcp_init(struct sppp *sp)
2835 sp->ipcp.opts = 0;
2836 sp->ipcp.flags = 0;
2837 sp->state[IDX_IPCP] = STATE_INITIAL;
2838 sp->fail_counter[IDX_IPCP] = 0;
2839 sp->pp_seq[IDX_IPCP] = 0;
2840 sp->pp_rseq[IDX_IPCP] = 0;
2841 callout_init(&sp->ch[IDX_IPCP], 1);
2845 sppp_ipcp_up(struct sppp *sp)
2847 sppp_up_event(&ipcp, sp);
2851 sppp_ipcp_down(struct sppp *sp)
2853 sppp_down_event(&ipcp, sp);
2857 sppp_ipcp_open(struct sppp *sp)
2862 sp->ipcp.flags &= ~(IPCP_HISADDR_SEEN | IPCP_MYADDR_SEEN |
2864 sp->ipcp.opts = 0;
2866 sppp_get_ip_addrs(sp, &myaddr, &hisaddr, 0);
2885 sp->ipcp.flags |= IPCP_MYADDR_DYN;
2886 sp->ipcp.opts |= (1 << IPCP_OPT_ADDRESS);
2888 sp->ipcp.flags |= IPCP_MYADDR_SEEN;
2889 if (sp->confflags & CONF_ENABLE_VJ) {
2890 sp->ipcp.opts |= (1 << IPCP_OPT_COMPRESSION);
2891 sp->ipcp.max_state = MAX_STATES - 1;
2892 sp->ipcp.compress_cid = 1;
2894 sppp_open_event(&ipcp, sp);
2898 sppp_ipcp_close(struct sppp *sp)
2900 sppp_close_event(&ipcp, sp);
2901 if (sp->ipcp.flags & IPCP_MYADDR_DYN)
2905 sppp_set_ip_addr(sp, 0L);
2921 sppp_ipcp_RCR(struct sppp *sp, struct lcp_header *h, int len)
2924 struct ifnet *ifp = SP2IFP(sp);
2951 if (!(sp->confflags & CONF_ENABLE_VJ)) {
3003 sppp_cp_send (sp, PPP_IPCP, CONF_REJ, h->ident, rlen, buf);
3009 sppp_get_ip_addrs(sp, 0, &hisaddr, 0);
3026 sp->ipcp.flags |= IPCP_VJ;
3027 sl_compress_init(sp->pp_comp, p[4]);
3028 sp->ipcp.max_state = p[4];
3029 sp->ipcp.compress_cid = p[5];
3038 p[4] = sp->ipcp.max_state;
3039 p[5] = sp->ipcp.compress_cid;
3058 sp->ipcp.flags |= IPCP_HISADDR_SEEN;
3099 if (rlen == 0 && !(sp->ipcp.flags & IPCP_HISADDR_SEEN) && !gotmyaddr) {
3114 sppp_cp_send (sp, PPP_IPCP, CONF_NAK, h->ident, rlen, buf);
3118 sppp_cp_send (sp, PPP_IPCP, CONF_ACK,
3131 sppp_ipcp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len)
3134 struct ifnet *ifp = SP2IFP(sp);
3153 sp->ipcp.opts &= ~(1 << IPCP_OPT_COMPRESSION);
3161 sp->ipcp.opts &= ~(1 << IPCP_OPT_ADDRESS);
3176 sppp_ipcp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len)
3179 struct ifnet *ifp = SP2IFP(sp);
3206 sl_compress_init(sp->pp_comp, p[4]);
3207 sp->ipcp.max_state = p[4];
3208 sp->ipcp.compress_cid = p[5];
3212 sp->ipcp.opts &=
3225 sp->ipcp.opts |= (1 << IPCP_OPT_ADDRESS);
3237 if (sp->ipcp.flags & IPCP_MYADDR_DYN) {
3238 sppp_set_ip_addr(sp, wantaddr);
3241 sp->ipcp.flags |= IPCP_MYADDR_SEEN;
3254 sppp_ipcp_tlu(struct sppp *sp)
3257 if (sp->pp_con)
3258 sp->pp_con(sp);
3262 sppp_ipcp_tld(struct sppp *sp)
3267 sppp_ipcp_tls(struct sppp *sp)
3270 sp->lcp.protos |= (1 << IDX_IPCP);
3274 sppp_ipcp_tlf(struct sppp *sp)
3277 sp->lcp.protos &= ~(1 << IDX_IPCP);
3278 sppp_lcp_check_and_close(sp);
3282 sppp_ipcp_scr(struct sppp *sp)
3288 if (sp->ipcp.opts & (1 << IPCP_OPT_COMPRESSION)) {
3293 opt[i++] = sp->ipcp.max_state;
3294 opt[i++] = sp->ipcp.compress_cid;
3296 if (sp->ipcp.opts & (1 << IPCP_OPT_ADDRESS)) {
3297 sppp_get_ip_addrs(sp, &ouraddr, 0, 0);
3306 sp->confid[IDX_IPCP] = ++sp->pp_seq[IDX_IPCP];
3307 sppp_cp_send(sp, PPP_IPCP, CONF_REQ, sp->confid[IDX_IPCP], i, &opt);
3311 sppp_ipcp_init(struct sppp *sp)
3316 sppp_ipcp_up(struct sppp *sp)
3321 sppp_ipcp_down(struct sppp *sp)
3326 sppp_ipcp_open(struct sppp *sp)
3331 sppp_ipcp_close(struct sppp *sp)
3341 sppp_ipcp_RCR(struct sppp *sp, struct lcp_header *h, int len)
3347 sppp_ipcp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len)
3352 sppp_ipcp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len)
3357 sppp_ipcp_tlu(struct sppp *sp)
3362 sppp_ipcp_tld(struct sppp *sp)
3367 sppp_ipcp_tls(struct sppp *sp)
3372 sppp_ipcp_tlf(struct sppp *sp)
3377 sppp_ipcp_scr(struct sppp *sp)
3392 sppp_ipv6cp_init(struct sppp *sp)
3394 sp->ipv6cp.opts = 0;
3395 sp->ipv6cp.flags = 0;
3396 sp->state[IDX_IPV6CP] = STATE_INITIAL;
3397 sp->fail_counter[IDX_IPV6CP] = 0;
3398 sp->pp_seq[IDX_IPV6CP] = 0;
3399 sp->pp_rseq[IDX_IPV6CP] = 0;
3400 callout_init(&sp->ch[IDX_IPV6CP], 1);
3404 sppp_ipv6cp_up(struct sppp *sp)
3406 sppp_up_event(&ipv6cp, sp);
3410 sppp_ipv6cp_down(struct sppp *sp)
3412 sppp_down_event(&ipv6cp, sp);
3416 sppp_ipv6cp_open(struct sppp *sp)
3422 sp->ipv6cp.flags &= ~(IPV6CP_MYIFID_SEEN|IPV6CP_MYIFID_DYN);
3424 sp->ipv6cp.flags &= ~IPV6CP_MYIFID_SEEN;
3427 sppp_get_ip6_addrs(sp, &myaddr, &hisaddr, 0);
3442 sp->ipv6cp.flags |= IPV6CP_MYIFID_SEEN;
3443 sp->ipv6cp.opts |= (1 << IPV6CP_OPT_IFID);
3444 sppp_open_event(&ipv6cp, sp);
3448 sppp_ipv6cp_close(struct sppp *sp)
3450 sppp_close_event(&ipv6cp, sp);
3466 sppp_ipv6cp_RCR(struct sppp *sp, struct lcp_header *h, int len)
3469 struct ifnet *ifp = SP2IFP(sp);
3531 sppp_cp_send (sp, PPP_IPV6CP, CONF_REJ, h->ident, rlen, buf);
3537 sppp_get_ip6_addrs(sp, &myaddr, 0, 0);
3561 (void)in6_setscope(&desiredaddr, SP2IFP(sp), NULL);
3587 sppp_suggest_ip6_addr(sp, &suggestaddr);
3605 sppp_cp_send (sp, PPP_IPV6CP, type, h->ident, origlen, h+1);
3617 sppp_cp_send (sp, PPP_IPV6CP, type, h->ident, rlen, buf);
3630 sppp_ipv6cp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len)
3633 struct ifnet *ifp = SP2IFP(sp);
3656 sp->ipv6cp.opts &= ~(1 << IPV6CP_OPT_IFID);
3660 sp->ipv6cp.opts &= ~(1 << IPV6CP_OPT_COMPRESS);
3676 sppp_ipv6cp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len)
3679 struct ifnet *ifp = SP2IFP(sp);
3709 (void)in6_setscope(&suggestaddr, SP2IFP(sp), NULL);
3712 sp->ipv6cp.opts |= (1 << IPV6CP_OPT_IFID);
3721 if (sp->ipv6cp.flags & IPV6CP_MYIFID_DYN) {
3734 sppp_gen_ip6_addr(sp, &suggestaddr);
3736 sppp_set_ip6_addr(sp, &suggestaddr, 0);
3739 sp->ipv6cp.flags |= IPV6CP_MYIFID_SEEN;
3770 sppp_ipv6cp_tlu(struct sppp *sp)
3773 if (sp->pp_con)
3774 sp->pp_con(sp);
3778 sppp_ipv6cp_tld(struct sppp *sp)
3783 sppp_ipv6cp_tls(struct sppp *sp)
3786 sp->lcp.protos |= (1 << IDX_IPV6CP);
3790 sppp_ipv6cp_tlf(struct sppp *sp)
3795 sp->lcp.protos &= ~(1 << IDX_IPV6CP);
3796 sppp_lcp_check_and_close(sp);
3801 sppp_ipv6cp_scr(struct sppp *sp)
3807 if (sp->ipv6cp.opts & (1 << IPV6CP_OPT_IFID)) {
3808 sppp_get_ip6_addrs(sp, &ouraddr, 0, 0);
3816 if (sp->ipv6cp.opts & (1 << IPV6CP_OPT_COMPRESSION)) {
3825 sp->confid[IDX_IPV6CP] = ++sp->pp_seq[IDX_IPV6CP];
3826 sppp_cp_send(sp, PPP_IPV6CP, CONF_REQ, sp->confid[IDX_IPV6CP], i, &opt);
3829 static void sppp_ipv6cp_init(struct sppp *sp)
3833 static void sppp_ipv6cp_up(struct sppp *sp)
3837 static void sppp_ipv6cp_down(struct sppp *sp)
3842 static void sppp_ipv6cp_open(struct sppp *sp)
3846 static void sppp_ipv6cp_close(struct sppp *sp)
3850 static void sppp_ipv6cp_TO(void *sp)
3854 static int sppp_ipv6cp_RCR(struct sppp *sp, struct lcp_header *h, int len)
3859 static void sppp_ipv6cp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len)
3863 static void sppp_ipv6cp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len)
3867 static void sppp_ipv6cp_tlu(struct sppp *sp)
3871 static void sppp_ipv6cp_tld(struct sppp *sp)
3875 static void sppp_ipv6cp_tls(struct sppp *sp)
3879 static void sppp_ipv6cp_tlf(struct sppp *sp)
3883 static void sppp_ipv6cp_scr(struct sppp *sp)
3977 sppp_chap_input(struct sppp *sp, struct mbuf *m)
4034 MD5Update(&ctx, sp->myauth.secret,
4035 sppp_strnlen(sp->myauth.secret, AUTHKEYLEN));
4040 sppp_auth_send(&chap, sp, CHAP_RESPONSE, h->ident,
4043 (size_t)sppp_strnlen(sp->myauth.name, AUTHNAMELEN),
4044 sp->myauth.name,
4058 SPPP_LOCK(sp);
4059 sp->pp_flags &= ~PP_NEEDAUTH;
4060 if (sp->myauth.proto == PPP_CHAP &&
4061 (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) &&
4062 (sp->lcp.protos & (1 << IDX_CHAP)) == 0) {
4068 SPPP_UNLOCK(sp);
4071 SPPP_UNLOCK(sp);
4072 sppp_phase_network(sp);
4109 if (h->ident != sp->confid[IDX_CHAP]) {
4115 h->ident, sp->confid[IDX_CHAP]);
4118 if (name_len != sppp_strnlen(sp->hisauth.name, AUTHNAMELEN)
4119 || bcmp(name, sp->hisauth.name, name_len) != 0) {
4124 sppp_print_string(sp->hisauth.name,
4125 sppp_strnlen(sp->hisauth.name, AUTHNAMELEN));
4132 sppp_state_name(sp->state[IDX_CHAP]),
4152 MD5Update(&ctx, sp->hisauth.secret,
4153 sppp_strnlen(sp->hisauth.secret, AUTHKEYLEN));
4154 MD5Update(&ctx, sp->myauth.challenge, AUTHKEYLEN);
4163 sppp_auth_send(&chap, sp, CHAP_FAILURE, h->ident,
4166 chap.tld(sp);
4170 if (sp->state[IDX_CHAP] == STATE_REQ_SENT ||
4171 sp->state[IDX_CHAP] == STATE_OPENED)
4172 sppp_auth_send(&chap, sp, CHAP_SUCCESS, h->ident,
4175 if (sp->state[IDX_CHAP] == STATE_REQ_SENT) {
4176 sppp_cp_change_state(&chap, sp, STATE_OPENED);
4177 chap.tlu(sp);
4187 sppp_state_name(sp->state[IDX_CHAP]),
4198 sppp_chap_init(struct sppp *sp)
4201 sp->state[IDX_CHAP] = STATE_CLOSED;
4202 sp->fail_counter[IDX_CHAP] = 0;
4203 sp->pp_seq[IDX_CHAP] = 0;
4204 sp->pp_rseq[IDX_CHAP] = 0;
4205 callout_init(&sp->ch[IDX_CHAP], 1);
4209 sppp_chap_open(struct sppp *sp)
4211 if (sp->myauth.proto == PPP_CHAP &&
4212 (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) != 0) {
4214 chap.scr(sp);
4215 sp->rst_counter[IDX_CHAP] = sp->lcp.max_configure;
4216 sppp_cp_change_state(&chap, sp, STATE_REQ_SENT);
4222 sppp_chap_close(struct sppp *sp)
4224 if (sp->state[IDX_CHAP] != STATE_CLOSED)
4225 sppp_cp_change_state(&chap, sp, STATE_CLOSED);
4231 struct sppp *sp = (struct sppp *)cookie;
4234 SPPP_LOCK(sp);
4238 sppp_state_name(sp->state[IDX_CHAP]),
4239 sp->rst_counter[IDX_CHAP]);
4241 if (--sp->rst_counter[IDX_CHAP] < 0)
4243 switch (sp->state[IDX_CHAP]) {
4245 chap.tld(sp);
4246 sppp_cp_change_state(&chap, sp, STATE_CLOSED);
4251 switch (sp->state[IDX_CHAP]) {
4254 sp->rst_counter[IDX_CHAP] = sp->lcp.max_configure;
4257 chap.scr(sp);
4259 sppp_cp_change_state(&chap, sp, STATE_REQ_SENT);
4263 SPPP_UNLOCK(sp);
4267 sppp_chap_tlu(struct sppp *sp)
4273 sp->rst_counter[IDX_CHAP] = sp->lcp.max_configure;
4281 if ((sp->hisauth.flags & AUTHFLAG_NORECHALLENGE) == 0) {
4287 callout_reset(&sp->ch[IDX_CHAP], i * hz, chap.TO, (void *)sp);
4294 sp->pp_phase == PHASE_NETWORK? "reconfirmed": "tlu");
4295 if ((sp->hisauth.flags & AUTHFLAG_NORECHALLENGE) == 0)
4301 SPPP_LOCK(sp);
4303 sp->lcp.protos |= (1 << IDX_CHAP);
4305 if (sp->pp_flags & PP_NEEDAUTH) {
4311 SPPP_UNLOCK(sp);
4314 SPPP_UNLOCK(sp);
4320 if (sp->pp_phase != PHASE_NETWORK)
4321 sppp_phase_network(sp);
4325 sppp_chap_tld(struct sppp *sp)
4331 callout_stop(&sp->ch[IDX_CHAP]);
4332 sp->lcp.protos &= ~(1 << IDX_CHAP);
4334 lcp.Close(sp);
4338 sppp_chap_scr(struct sppp *sp)
4344 ch = (u_long *)sp->myauth.challenge;
4352 sp->confid[IDX_CHAP] = ++sp->pp_seq[IDX_CHAP];
4354 sppp_auth_send(&chap, sp, CHAP_CHALLENGE, sp->confid[IDX_CHAP],
4356 (size_t)AUTHKEYLEN, sp->myauth.challenge,
4357 (size_t)sppp_strnlen(sp->myauth.name, AUTHNAMELEN),
4358 sp->myauth.name,
4379 sppp_pap_input(struct sppp *sp, struct mbuf *m)
4421 sppp_state_name(sp->state[IDX_PAP]),
4429 if (name_len != sppp_strnlen(sp->hisauth.name, AUTHNAMELEN) ||
4430 passwd_len != sppp_strnlen(sp->hisauth.secret, AUTHKEYLEN) ||
4431 bcmp(name, sp->hisauth.name, name_len) != 0 ||
4432 bcmp(passwd, sp->hisauth.secret, passwd_len) != 0) {
4435 sppp_auth_send(&pap, sp, PAP_NAK, h->ident,
4439 pap.tld(sp);
4443 if (sp->state[IDX_PAP] == STATE_REQ_SENT ||
4444 sp->state[IDX_PAP] == STATE_OPENED) {
4446 sppp_auth_send(&pap, sp, PAP_ACK, h->ident,
4451 if (sp->state[IDX_PAP] == STATE_REQ_SENT) {
4452 sppp_cp_change_state(&pap, sp, STATE_OPENED);
4453 pap.tlu(sp);
4459 callout_stop(&sp->pap_my_to_ch);
4470 SPPP_LOCK(sp);
4471 sp->pp_flags &= ~PP_NEEDAUTH;
4472 if (sp->myauth.proto == PPP_PAP &&
4473 (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) &&
4474 (sp->lcp.protos & (1 << IDX_PAP)) == 0) {
4480 SPPP_UNLOCK(sp);
4483 SPPP_UNLOCK(sp);
4484 sppp_phase_network(sp);
4488 callout_stop (&sp->pap_my_to_ch);
4520 sppp_pap_init(struct sppp *sp)
4523 sp->state[IDX_PAP] = STATE_CLOSED;
4524 sp->fail_counter[IDX_PAP] = 0;
4525 sp->pp_seq[IDX_PAP] = 0;
4526 sp->pp_rseq[IDX_PAP] = 0;
4527 callout_init(&sp->ch[IDX_PAP], 1);
4528 callout_init(&sp->pap_my_to_ch, 1);
4532 sppp_pap_open(struct sppp *sp)
4534 if (sp->hisauth.proto == PPP_PAP &&
4535 (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) != 0) {
4537 sp->rst_counter[IDX_PAP] = sp->lcp.max_configure;
4538 sppp_cp_change_state(&pap, sp, STATE_REQ_SENT);
4540 if (sp->myauth.proto == PPP_PAP) {
4542 pap.scr(sp);
4543 callout_reset(&sp->pap_my_to_ch, sp->lcp.timeout,
4544 sppp_pap_my_TO, (void *)sp);
4549 sppp_pap_close(struct sppp *sp)
4551 if (sp->state[IDX_PAP] != STATE_CLOSED)
4552 sppp_cp_change_state(&pap, sp, STATE_CLOSED);
4562 struct sppp *sp = (struct sppp *)cookie;
4565 SPPP_LOCK(sp);
4569 sppp_state_name(sp->state[IDX_PAP]),
4570 sp->rst_counter[IDX_PAP]);
4572 if (--sp->rst_counter[IDX_PAP] < 0)
4574 switch (sp->state[IDX_PAP]) {
4576 pap.tld(sp);
4577 sppp_cp_change_state(&pap, sp, STATE_CLOSED);
4582 switch (sp->state[IDX_PAP]) {
4585 sppp_cp_change_state(&pap, sp, STATE_REQ_SENT);
4589 SPPP_UNLOCK(sp);
4600 struct sppp *sp = (struct sppp *)cookie;
4607 SPPP_LOCK(sp);
4608 pap.scr(sp);
4609 SPPP_UNLOCK(sp);
4613 sppp_pap_tlu(struct sppp *sp)
4617 sp->rst_counter[IDX_PAP] = sp->lcp.max_configure;
4623 SPPP_LOCK(sp);
4625 sp->lcp.protos |= (1 << IDX_PAP);
4627 if (sp->pp_flags & PP_NEEDAUTH) {
4633 SPPP_UNLOCK(sp);
4636 SPPP_UNLOCK(sp);
4637 sppp_phase_network(sp);
4641 sppp_pap_tld(struct sppp *sp)
4647 callout_stop (&sp->ch[IDX_PAP]);
4648 callout_stop (&sp->pap_my_to_ch);
4649 sp->lcp.protos &= ~(1 << IDX_PAP);
4651 lcp.Close(sp);
4655 sppp_pap_scr(struct sppp *sp)
4659 sp->confid[IDX_PAP] = ++sp->pp_seq[IDX_PAP];
4660 pwdlen = sppp_strnlen(sp->myauth.secret, AUTHKEYLEN);
4661 idlen = sppp_strnlen(sp->myauth.name, AUTHNAMELEN);
4663 sppp_auth_send(&pap, sp, PAP_REQ, sp->confid[IDX_PAP],
4665 (size_t)idlen, sp->myauth.name,
4667 (size_t)pwdlen, sp->myauth.secret,
4687 sppp_auth_send(const struct cp *cp, struct sppp *sp,
4744 if (! IF_HANDOFF_ADJ(&sp->pp_cpq, m, ifp, 3))
4772 struct sppp *sp = (struct sppp*)dummy;
4773 struct ifnet *ifp = SP2IFP(sp);
4775 SPPP_LOCK(sp);
4777 if (! (sp->pp_flags & PP_KEEPALIVE) ||
4781 if (sp->pp_mode == PP_FR) {
4782 sppp_fr_keepalive (sp);
4787 if (sp->pp_mode != IFF_CISCO &&
4788 sp->pp_phase < PHASE_AUTHENTICATE)
4791 if (sp->pp_alivecnt == MAXALIVECNT) {
4795 sppp_qflush (&sp->pp_cpq);
4796 if (sp->pp_mode != IFF_CISCO) {
4799 lcp.Down(sp);
4801 lcp.Up(sp);
4804 if (sp->pp_alivecnt <= MAXALIVECNT)
4805 ++sp->pp_alivecnt;
4806 if (sp->pp_mode == IFF_CISCO)
4807 sppp_cisco_send (sp, CISCO_KEEPALIVE_REQ,
4808 ++sp->pp_seq[IDX_LCP], sp->pp_rseq[IDX_LCP]);
4809 else if (sp->pp_phase >= PHASE_AUTHENTICATE) {
4810 long nmagic = htonl (sp->lcp.magic);
4811 sp->lcp.echoid = ++sp->pp_seq[IDX_LCP];
4812 sppp_cp_send (sp, PPP_LCP, ECHO_REQ,
4813 sp->lcp.echoid, 4, &nmagic);
4816 SPPP_UNLOCK(sp);
4817 callout_reset(&sp->keepalive_callout, hz * 10, sppp_keepalive,
4818 (void *)sp);
4825 sppp_get_ip_addrs(struct sppp *sp, u_long *src, u_long *dst, u_long *srcmask)
4827 struct ifnet *ifp = SP2IFP(sp);
4869 sppp_set_ip_addr(struct sppp *sp, u_long src)
4927 sppp_get_ip6_addrs(struct sppp *sp, struct in6_addr *src, struct in6_addr *dst,
4930 struct ifnet *ifp = SP2IFP(sp);
4977 sppp_gen_ip6_addr(struct sppp *sp, struct in6_addr *addr)
4986 sppp_set_ip6_addr(struct sppp *sp, const struct in6_addr *src)
5029 sppp_suggest_ip6_addr(struct sppp *sp, struct in6_addr *suggest)
5034 sppp_get_ip6_addrs(sp, &myaddr, 0, 0);
5051 sppp_params(struct sppp *sp, u_long cmd, void *data)
5089 spr->defs.pp_phase = sp->pp_phase;
5090 spr->defs.enable_vj = (sp->confflags & CONF_ENABLE_VJ) != 0;
5091 spr->defs.enable_ipv6 = (sp->confflags & CONF_ENABLE_IPV6) != 0;
5092 spr->defs.lcp = sp->lcp;
5093 spr->defs.ipcp = sp->ipcp;
5094 spr->defs.ipv6cp = sp->ipv6cp;
5095 spr->defs.myauth = sp->myauth;
5096 spr->defs.hisauth = sp->hisauth;
5107 spr->defs.lcp.timeout = sp->lcp.timeout * 1000 / hz;
5141 if (sp->pp_phase != PHASE_DEAD &&
5142 sp->pp_phase != PHASE_ESTABLISH) {
5157 bzero(&sp->myauth, sizeof sp->myauth);
5160 sp->myauth.proto = spr->defs.myauth.proto;
5161 bcopy(spr->defs.myauth.name, sp->myauth.name, AUTHNAMELEN);
5163 bcopy(spr->defs.myauth.secret, sp->myauth.secret,
5168 bzero(&sp->hisauth, sizeof sp->hisauth);
5171 sp->hisauth.proto = spr->defs.hisauth.proto;
5172 sp->hisauth.flags = spr->defs.hisauth.flags;
5173 bcopy(spr->defs.hisauth.name, sp->hisauth.name, AUTHNAMELEN);
5175 bcopy(spr->defs.hisauth.secret, sp->hisauth.secret,
5180 sp->lcp.timeout = spr->defs.lcp.timeout * hz / 1000;
5184 sp->confflags |= CONF_ENABLE_VJ;
5186 sp->confflags &= ~CONF_ENABLE_VJ;
5190 sp->confflags |= CONF_ENABLE_IPV6;
5192 sp->confflags &= ~CONF_ENABLE_IPV6;
5207 sppp_phase_network(struct sppp *sp)
5213 sp->pp_phase = PHASE_NETWORK;
5217 sppp_phase_name(sp->pp_phase));
5222 (cps[i])->Open(sp);
5226 if ((sp->lcp.protos & mask) && ((cps[i])->flags & CP_NCP))
5227 (cps[i])->Up(sp);
5230 sppp_lcp_check_and_close(sp);