Attached is the BCP patch for pppd 2.4.1. In addition to BCP, there are also a few changes to support a pppd plugin for devices using the kernel generic HDLC layer. The plugin itself is not included in this patch. There were some changes to log messages that I tried to remove by hand. The patch applies cleanly and compiles on 686. It has never been tested on 686, though, only on powerpc. I would appreciate hearing about any difficulties you encounter. You must patch the kernel too. I will send those changes in a separate mail. -- Dan Eble <dane@xxxxxxxxxx> _____ . Software Engineer | _ |/| Applied Innovation Inc. | |_| | | http://www.aiinet.com/ |__/|_|_| -------------- next part -------------- diff -wbBurN pppd-2.4.1/include/linux/ppp_defs.h pppd-ai/include/linux/ppp_defs.h --- pppd-2.4.1/include/linux/ppp_defs.h 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/include/linux/ppp_defs.h 2004-02-25 08:34:47.000000000 -0500 @@ -70,13 +70,16 @@ #define PPP_IPX 0x2b /* IPX protocol */ #define PPP_VJC_COMP 0x2d /* VJ compressed TCP */ #define PPP_VJC_UNCOMP 0x2f /* VJ uncompressed TCP */ +#define PPP_BRIDGE 0x31 /* Bridged LAN traffic or BPDU */ #define PPP_MP 0x3d /* Multilink protocol */ #define PPP_IPV6 0x57 /* Internet Protocol Version 6 */ #define PPP_COMPFRAG 0xfb /* fragment compressed below bundle */ #define PPP_COMP 0xfd /* compressed packet */ +#define PPP_BPDU_IEEE 0x0201 /* IEEE 802.1 (D or G) bridge PDU */ #define PPP_IPCP 0x8021 /* IP Control Protocol */ #define PPP_ATCP 0x8029 /* AppleTalk Control Protocol */ #define PPP_IPXCP 0x802b /* IPX Control Protocol */ +#define PPP_BCP 0x8031 /* Bridging Control Protocol */ #define PPP_IPV6CP 0x8057 /* IPv6 Control Protocol */ #define PPP_CCPFRAG 0x80fb /* CCP at link level (below MP bundle) */ #define PPP_CCP 0x80fd /* Compression Control Protocol */ diff -wbBurN pppd-2.4.1/include/net/ppp_defs.h pppd-ai/include/net/ppp_defs.h --- pppd-2.4.1/include/net/ppp_defs.h 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/include/net/ppp_defs.h 2004-02-25 08:34:47.000000000 -0500 @@ -72,11 +72,14 @@ #define PPP_IPX 0x2b /* IPX protocol */ #define PPP_VJC_COMP 0x2d /* VJ compressed TCP */ #define PPP_VJC_UNCOMP 0x2f /* VJ uncompressed TCP */ +#define PPP_BRIDGE 0x31 /* Bridged LAN traffic or BPDU */ #define PPP_IPV6 0x57 /* Internet Protocol Version 6 */ #define PPP_COMP 0xfd /* compressed packet */ +#define PPP_BPDU_IEEE 0x0201 /* IEEE 802.1 (D or G) bridge PDU */ #define PPP_IPCP 0x8021 /* IP Control Protocol */ #define PPP_ATCP 0x8029 /* AppleTalk Control Protocol */ #define PPP_IPXCP 0x802b /* IPX Control Protocol */ +#define PPP_BCP 0x8031 /* Bridging Control Protocol */ #define PPP_IPV6CP 0x8057 /* IPv6 Control Protocol */ #define PPP_CCP 0x80fd /* Compression Control Protocol */ #define PPP_LCP 0xc021 /* Link Control Protocol */ diff -wbBurN pppd-2.4.1/pppd/auth.c pppd-ai/pppd/auth.c --- pppd-2.4.1/pppd/auth.c 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/auth.c 2004-02-25 08:34:47.000000000 -0500 @@ -103,9 +103,31 @@ /* Extra options to apply, from the secrets file entry for the peer. */ static struct wordlist *extra_options; +/* Bits 0, 8, 14, and 15 are the same in all network protocol numbers, so + * remove them to save space in np_running[][]. */ +#define NP_BRIEF(np) ((int)((((np) & 0x3E00) >> 2) | (((np) & 0x00FE) >> 1))) +#define NP_ARRAY_BYTE(np) (NP_BRIEF(np) / 8) +#define NP_ARRAY_BIT(np) ((unsigned char)(1 << (NP_BRIEF(np) % 8))) + +/* Flags for running protocols. One bit per protocol per PPP unit. */ +static unsigned char np_running[NP_ARRAY_BYTE(0xBEFF)+1][NUM_PPP]; + /* Number of network protocols which we have opened. */ static int num_np_open; +#define NP_RUNNING(unit, np) \ + (np_running[unit][NP_ARRAY_BYTE(np)] & NP_ARRAY_BIT(np)) + +#define MARK_NP_RUNNING(unit, np) do { \ + np_running[unit][NP_ARRAY_BYTE(np)] |= NP_ARRAY_BIT(np); \ + ++num_np_open; \ + } while (0) + +#define MARK_NP_FINISHED(unit, np) do { \ + np_running[unit][NP_ARRAY_BYTE(np)] &= ~NP_ARRAY_BIT(np); \ + --num_np_open; \ + } while (0) + /* Number of network protocols which have come up. */ static int num_np_up; @@ -421,6 +443,8 @@ if (protp->protocol < 0xC000 && protp->close != NULL) (*protp->close)(unit, "LCP down"); } + + memset(np_running, 0, sizeof(np_running)); num_np_open = 0; num_np_up = 0; if (phase != PHASE_DEAD) @@ -565,7 +589,7 @@ && protp->open != NULL) { (*protp->open)(0); if (protp->protocol != PPP_CCP) - ++num_np_open; + MARK_NP_RUNNING(0, protp->protocol); } if (num_np_open == 0) @@ -732,17 +756,32 @@ } /* + * np_start - a network protocol is starting to use the link. + */ +void +np_start(unit, proto) + int unit, proto; +{ + if (!NP_RUNNING(unit, proto)) + MARK_NP_RUNNING(unit, proto); +} + +/* * np_finished - a network protocol has finished using the link. */ void np_finished(unit, proto) int unit, proto; { - if (--num_np_open <= 0) { + if (NP_RUNNING(unit, proto)) { + MARK_NP_FINISHED(unit, proto); + + if (num_np_open <= 0) { /* no further use for the link: shut up shop. */ lcp_close(0, "No network protocols running"); } } +} /* * check_idle - check whether the link has been idle for long diff -wbBurN pppd-2.4.1/pppd/bcp.c pppd-ai/pppd/bcp.c --- pppd-2.4.1/pppd/bcp.c 1969-12-31 19:00:00.000000000 -0500 +++ pppd-ai/pppd/bcp.c 2004-02-25 08:34:47.000000000 -0500 @@ -0,0 +1,1743 @@ +/* + * bcp.c - PPP Bridge Control Protocol. + * + * Copyright (c) 2001-2004 Applied Innovation Inc. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms. The name of Applied Innovation Inc. + * may not be used to endorse or promote products derived from this + * software without specific prior written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + */ + + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <netdb.h> +#include <sys/param.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> + +#include "pppd.h" +#include "fsm.h" +#include "bcp.h" +#include "pathnames.h" + +/* global vars */ +bcp_options bcp_wantoptions[NUM_PPP]; /* Options that we want to request */ +bcp_options bcp_gotoptions[NUM_PPP]; /* Options that peer ack'd */ +bcp_options bcp_allowoptions[NUM_PPP]; /* Options we allow peer to request */ +bcp_options bcp_hisoptions[NUM_PPP]; /* Options that we ack'd */ + +/* local vars */ +static int bcp_is_up; /* have called np_up() */ + +static bool bcp_maclocal_valid; +static u_char bcp_maclocal[ETH_ALEN]; +static char bcp_maclocal_str[3*ETH_ALEN]; /* string form of "maclocal" arg */ + +/* + * Callbacks for fsm code. (CI = Configuration Information) + */ +static void bcp_resetci __P((fsm *)); /* Reset our CI */ +static int bcp_cilen __P((fsm *)); /* Return length of our CI */ +static void bcp_addci __P((fsm *, u_char *, int *)); /* Add our CI */ +static int bcp_ackci __P((fsm *, u_char *, int)); /* Peer ack'd our CI */ +static int bcp_nakci __P((fsm *, u_char *, int)); /* Peer nak'd our CI */ +static int bcp_rejci __P((fsm *, u_char *, int)); /* Peer rej'd our CI */ +static int bcp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */ +static void bcp_up __P((fsm *)); /* We're UP */ +static void bcp_down __P((fsm *)); /* We're DOWN */ +static void bcp_start __P((fsm *)); /* Need lower layer */ +static void bcp_finished __P((fsm *)); /* Don't need lower layer */ + +fsm bcp_fsm[NUM_PPP]; /* BCP fsm structure */ + +static fsm_callbacks bcp_callbacks = { /* BCP callback routines */ + bcp_resetci, /* Reset our Configuration Information */ + bcp_cilen, /* Length of our Configuration Information */ + bcp_addci, /* Add our Configuration Information */ + bcp_ackci, /* ACK our Configuration Information */ + bcp_nakci, /* NAK our Configuration Information */ + bcp_rejci, /* Reject our Configuration Information */ + bcp_reqci, /* Request peer's Configuration Information */ + bcp_up, /* Called when fsm reaches OPENED state */ + bcp_down, /* Called when fsm leaves OPENED state */ + bcp_start, /* Called when we want the lower layer up */ + bcp_finished, /* Called when we want the lower layer down */ + NULL, /* Called when Protocol-Reject received */ + NULL, /* Retransmission is necessary */ + NULL, /* Called to handle protocol-specific codes */ + "BCP" /* String name of protocol */ +}; + +/* + * Command-line options. + */ +static int bcp_setmaclocal __P((char **)); + +static option_t bcp_option_list[] = { + { "nobcp", o_bool, &bcp_protent.enabled_flag, "Disable BCP" }, + { "maclocal", o_special, (void *)bcp_setmaclocal, "set local MAC address", + OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, bcp_maclocal_str }, + { NULL } /* terminating entry */ +}; +/* + * Protocol entry points from main code. + */ +static void bcp_init __P((int)); +static void bcp_open __P((int)); +static void bcp_close __P((int, char *)); +static void bcp_lowerup __P((int)); +static void bcp_lowerdown __P((int)); +static void bcp_input __P((int, u_char *, int)); +static void bcp_protrej __P((int)); +static int bcp_printpkt __P((u_char *, int, + void (*) __P((void *, char *, ...)), void *)); +static void bcp_check_options __P((void)); + +struct protent bcp_protent = { + PPP_BCP, + bcp_init, + bcp_input, + bcp_protrej, + bcp_lowerup, + bcp_lowerdown, + bcp_open, + bcp_close, + bcp_printpkt, + NULL, + 1, + "BCP", + "Bridging", + bcp_option_list, + bcp_check_options, + NULL, + NULL +}; + +static void bcp_script __P((fsm *, char *)); /* Run an up/down script */ +static void bcp_script_done __P((void *)); + +/* + * Lengths of configuration options. + */ +#define CILEN_VOID 2 +#define CILEN_BRIDGELINEID 4 +#define CILEN_MACSUPPORT 3 +#define CILEN_TINYGRAM 3 +#define CILEN_LANID 3 +#define CILEN_MACADDR 8 +#define CILEN_SPANTREE 3 +#define CILEN_IEEE_802_TAGGED_FRAME 3 +#define CILEN_MGMT_INLINE 2 + +#define CODENAME(x) ((x) == CONFACK ? "ACK" : \ + (x) == CONFNAK ? "NAK" : "REJ") + +/* + * This state variable is used to ensure that we don't + * run an bcp-up/down script while one is already running. + */ +static enum script_state { + s_down, + s_up, +} bcp_script_state; +static pid_t bcp_script_pid; + +/* + * Convert a MAC address from a string to an array of bytes. + */ +static int +mac_aton(const char *cp, u_char *mac) +{ + unsigned int args[ETH_ALEN]; + int n; + + if (sscanf(cp, "%2x:%2x:%2x:%2x:%2x:%2x%n", + &args[0], &args[1], &args[2], + &args[3], &args[4], &args[5], &n) >= ETH_ALEN) + { + if (!cp[n]) /* expect to have reached the end of the string */ + { + int i; + for (i = 0; i < ETH_ALEN; ++i) + { + mac[i] = args[i]; + } + return 1; + } + } + + return 0; +} + +/* + * Print a MAC address into a buffer and return the length. + */ +static int +slprintmac(char *buf, int buflen, const u_char *mac) +{ + return slprintf(buf, buflen, "%x:%x:%x:%x:%x:%x", + mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); +} + +/* + * bcp_setmaclocal - set the MAC address to be used on the local interface. + * Returns 0 on error, 1 on success. + */ +static int +bcp_setmaclocal(argv) + char **argv; +{ + bcp_maclocal_valid = mac_aton(argv[0], bcp_maclocal); + + if (bcp_maclocal_valid && (bcp_maclocal[0] & BCP_MULTICAST)) + bcp_maclocal_valid = 0; + + if (!bcp_maclocal_valid) + { + option_error("invalid maclocal value '%s'", argv[0]); + return 0; + } + + slprintmac(bcp_maclocal_str, sizeof(bcp_maclocal_str), bcp_maclocal); + return 1; +} + +/* + * bcp_init - Initialize BCP. + */ +static void +bcp_init(unit) + int unit; +{ + fsm *f = &bcp_fsm[unit]; + bcp_options *wo = &bcp_wantoptions[unit]; + bcp_options *ao = &bcp_allowoptions[unit]; + + f->unit = unit; + f->protocol = PPP_BCP; + f->callbacks = &bcp_callbacks; + fsm_init(&bcp_fsm[unit]); + + memset(wo, 0, sizeof(*wo)); + memset(ao, 0, sizeof(*ao)); + + wo->neg_macsupport = 1; + wo->macsupport[0] = MAC_IEEE_802_3; + + /* Try Management-Inline first, but prepare to fall back on + * Spanning-Tree-Protocol if it fails. */ + wo->neg_mgmt_inline = 1; + wo->neg_spantree = 0; + wo->spantree = SPAN_IEEE_802_1D; + + wo->neg_tinygram = 1; + wo->tinygram = 1; /* Linux can receive Tinygrams. */ + + ao->neg_macsupport = 1; + ao->neg_tinygram = 1; + ao->neg_macaddr = 1; + + ao->neg_mgmt_inline = 1; + ao->neg_spantree = 1; +} + + +/* + * bcp_open - BCP is allowed to come up. + */ +static void +bcp_open(unit) + int unit; +{ + fsm_open(&bcp_fsm[unit]); +} + + +/* + * bcp_close - Take BCP down. + */ +static void +bcp_close(unit, reason) + int unit; + char *reason; +{ + fsm_close(&bcp_fsm[unit], reason); +} + + +/* + * bcp_lowerup - The lower layer is up. + */ +static void +bcp_lowerup(unit) + int unit; +{ + fsm_lowerup(&bcp_fsm[unit]); +} + + +/* + * bcp_lowerdown - The lower layer is down. + */ +static void +bcp_lowerdown(unit) + int unit; +{ + fsm_lowerdown(&bcp_fsm[unit]); +} + + +/* + * bcp_input - Input BCP packet. + */ +static void +bcp_input(unit, p, len) + int unit; + u_char *p; + int len; +{ + fsm_input(&bcp_fsm[unit], p, len); +} + + +/* + * bcp_protrej - A Protocol-Reject was received for BCP. + * + * Pretend the lower layer went down, so we shut up. + */ +static void +bcp_protrej(unit) + int unit; +{ + fsm_lowerdown(&bcp_fsm[unit]); +} + + +/* + * bcp_resetci - Reset our CI. + * Called by fsm_sconfreq, Send Configure Request. + */ +static void +bcp_resetci(f) + fsm *f; +{ + bcp_options *wo = &bcp_wantoptions[f->unit]; + bcp_options *go = &bcp_gotoptions[f->unit]; + + /* Either announce our MAC address to the other side, or request one from + * the other side. (Another possibility is not to negotiate at all, but + * that seems useless.) */ + wo->neg_macaddr = 1; + if (bcp_maclocal_valid) + memcpy(wo->macaddr, bcp_maclocal, sizeof(wo->macaddr)); + else + memset(wo->macaddr, 0, sizeof(wo->macaddr)); + + *go = *wo; +} + + +/* + * bcp_cilen - Return length of our CI. + * Called by fsm_sconfreq, Send Configure Request. + */ +static int +bcp_cilen(f) + fsm *f; +{ + bcp_options *go = &bcp_gotoptions[f->unit]; + + int macsupport_len = 0; + int mac = 0; + for (mac=0; mac<ETH_ALEN; mac++) + { + if (go->macsupport[mac]) + { + macsupport_len += CILEN_MACSUPPORT; + } + } + +#define LENCIBRIDGELINEID(neg) ((neg) ? CILEN_BRIDGELINEID : 0) +#define LENCITINYGRAM(neg) ((neg) ? CILEN_TINYGRAM : 0) +#define LENCILANID(neg) ((neg) ? CILEN_LANID : 0) +#define LENCIMACADDR(neg) ((neg) ? CILEN_MACADDR : 0) +#define LENCISPANTREE(neg) ((neg) ? CILEN_SPANTREE : 0) +#define LENCIMGMTINLINE(neg) ((neg) ? CILEN_MGMT_INLINE : 0) + + + return (LENCIBRIDGELINEID(go->neg_bridgeid) + + LENCIBRIDGELINEID(go->neg_lineid) + + macsupport_len + + LENCITINYGRAM(go->neg_tinygram) + + LENCILANID(go->neg_lanid) + + LENCIMACADDR(go->neg_macaddr) + + LENCISPANTREE(go->neg_spantree) + + LENCIMGMTINLINE(go->neg_mgmt_inline)); +} + +/* + * bcp_addci - Add our desired CIs to a packet. + * Called by fsm_sconfreq, Send Configure Request. + */ +static void +bcp_addci(f, ucp, lenp) + fsm *f; + u_char *ucp; + int *lenp; +{ + bcp_options *go = &bcp_gotoptions[f->unit]; + int len = *lenp; + +#define ADDCIBRIDGELINEID(opt, neg, lan_bridge_segno) \ + if (neg) { \ + if (len >= CILEN_BRIDGELINEID) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_BRIDGELINEID, ucp); \ + PUTSHORT(lan_bridge_segno, ucp); \ + len -= CILEN_BRIDGELINEID; \ + } else \ + neg = 0; \ + } + +#define ADDCIMACSUPPORT(opt, neg, macsupport) \ + if (neg && macsupport) { \ + if (len >= CILEN_MACSUPPORT) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_MACSUPPORT, ucp); \ + PUTCHAR(macsupport, ucp); \ + len -= CILEN_MACSUPPORT; \ + } else \ + neg = 0; \ + } + +#define ADDCITINYGRAM(opt, neg, tinygram) \ + if (neg) { \ + if (len >= CILEN_TINYGRAM) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_TINYGRAM, ucp); \ + PUTCHAR(tinygram, ucp); \ + len -= CILEN_TINYGRAM; \ + } else \ + neg = 0; \ + } + +#define ADDCILANID(opt, neg, lanid) \ + if (neg) { \ + if (len >= CILEN_LANID) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_LANID, ucp); \ + PUTCHAR(lanid, ucp); \ + len -= CILEN_LANID; \ + } else \ + neg = 0; \ + } + +#define ADDCIMACADDR(opt, neg, macaddr) \ + if (neg) { \ + if (len >= CILEN_MACADDR) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_MACADDR, ucp); \ + PUTCHAR(macaddr[0], ucp); \ + PUTCHAR(macaddr[1], ucp); \ + PUTCHAR(macaddr[2], ucp); \ + PUTCHAR(macaddr[3], ucp); \ + PUTCHAR(macaddr[4], ucp); \ + PUTCHAR(macaddr[5], ucp); \ + len -= CILEN_MACADDR; \ + } else \ + neg = 0; \ + } + +#define ADDCISPANTREE(opt, neg, spantree) \ + if (neg) { \ + if (len >= CILEN_SPANTREE) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_SPANTREE, ucp); \ + PUTCHAR(spantree, ucp); \ + len -= CILEN_SPANTREE; \ + } else \ + neg = 0; \ + } + +#define ADDCIMGMTINLINE(opt, neg) \ + if (neg) { \ + if (len >= CILEN_MGMT_INLINE) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_MGMT_INLINE, ucp); \ + len -= CILEN_MGMT_INLINE; \ + } else \ + neg = 0; \ + } + + ADDCIBRIDGELINEID(CI_BRIDGE_IDENTIFICATION, go->neg_bridgeid, go->lan_bridge_segno); + + ADDCIBRIDGELINEID(CI_LINE_IDENTIFICATION, go->neg_lineid, go->lan_bridge_segno); + + ADDCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[0]); + ADDCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[1]); + ADDCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[2]); + ADDCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[3]); + ADDCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[4]); + ADDCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[5]); + + ADDCITINYGRAM(CI_TINYGRAM_COMPRESSION, go->neg_tinygram, go->tinygram); + + ADDCILANID(CI_LAN_IDENTIFICATION, go->neg_lanid, go->lanid); + + ADDCIMACADDR(CI_MAC_ADDRESS, go->neg_macaddr, go->macaddr); + + ADDCISPANTREE(CI_SPANNING_TREE_PROTOCOL, go->neg_spantree, go->spantree); + + ADDCIMGMTINLINE(CI_MANAGEMENT_INLINE, go->neg_mgmt_inline); + + *lenp -= len; +} + + +/* + * bcp_ackci - Ack our CIs. + * Called by fsm_rconfack, Receive Configure ACK. + * + * Returns: + * 0 - Ack was bad. + * 1 - Ack was good. + */ +static int +bcp_ackci(f, p, len) + fsm *f; + u_char *p; + int len; +{ + bcp_options *go = &bcp_gotoptions[f->unit]; + u_char cilen, citype, cichar; + u_short cishort; + + /* + * CIs must be in exactly the same order that we sent... + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define ACKCIBRIDGELINEID(opt, neg, lan_bridge_segno) \ + if (neg) { \ + if ((len -= CILEN_BRIDGELINEID) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_BRIDGELINEID || citype != opt) \ + goto bad; \ + GETSHORT(cishort, p); \ + if (lan_bridge_segno != cishort) \ + goto bad; \ + } + +#define ACKCIMACSUPPORT(opt, neg, macsupport) \ + if (neg && macsupport) { \ + if ((len -= CILEN_MACSUPPORT) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_MACSUPPORT || citype != opt) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macsupport != cichar) \ + goto bad; \ + } + +#define ACKCITINYGRAM(opt, neg, tinygram) \ + if (neg) { \ + if ((len -= CILEN_TINYGRAM) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_TINYGRAM || citype != opt) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (tinygram != cichar) \ + goto bad; \ + } + +#define ACKCILANID(opt, neg, lanid) \ + if (neg) { \ + if ((len -= CILEN_LANID) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_LANID || citype != opt) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (lanid != cichar) \ + goto bad; \ + } + +#define ACKCIMACADDR(opt, neg, macaddr) \ + if (neg) { \ + if ((len -= CILEN_MACADDR) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_MACADDR || citype != opt) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[0] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[1] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[2] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[3] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[4] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[5] != cichar) \ + goto bad; \ + } + +#define ACKCISPANTREE(opt, neg, spantree) \ + if (neg) { \ + if ((len -= CILEN_SPANTREE) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_SPANTREE || citype != opt) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (spantree != cichar) \ + goto bad; \ + } + +#define ACKMGMTINLINE(opt, neg) \ + if (neg) { \ + if ((len -= CILEN_MGMT_INLINE) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_MGMT_INLINE || citype != opt) \ + goto bad; \ + } + + + + ACKCIBRIDGELINEID(CI_BRIDGE_IDENTIFICATION, go->neg_bridgeid, go->lan_bridge_segno); + + ACKCIBRIDGELINEID(CI_LINE_IDENTIFICATION, go->neg_lineid, go->lan_bridge_segno); + + ACKCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[0]); + ACKCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[1]); + ACKCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[2]); + ACKCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[3]); + ACKCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[4]); + ACKCIMACSUPPORT(CI_MAC_SUPPORT, go->neg_macsupport, go->macsupport[5]); + + ACKCITINYGRAM(CI_TINYGRAM_COMPRESSION, go->neg_tinygram, go->tinygram); + + ACKCILANID(CI_LAN_IDENTIFICATION, go->neg_lanid, go->lanid); + + ACKCIMACADDR(CI_MAC_ADDRESS, go->neg_macaddr, go->macaddr); + + ACKCISPANTREE(CI_SPANNING_TREE_PROTOCOL, go->neg_spantree, go->spantree); + + ACKMGMTINLINE(CI_MANAGEMENT_INLINE, go->neg_mgmt_inline); + + /* + * If there are any remaining CIs, then this packet is bad. + */ + if (len != 0) + goto bad; + return (1); + +bad: + BCPDEBUG(("bcp_ackci: received bad Ack!")); + return (0); +} + +/* + * bcp_nakci - Peer has sent a NAK for some of our CIs. + * This should not modify any state if the Nak is bad + * or if BCP is in the OPENED state. + * Calback from fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject. + * + * Returns: + * 0 - Nak was bad. + * 1 - Nak was good. + */ +static int +bcp_nakci(f, p, len) + fsm *f; + u_char *p; + int len; +{ + bcp_options *go = &bcp_gotoptions[f->unit]; + u_char cichar; + u_char citype, cilen, *next; + u_short cishort; + bcp_options no; /* options we've seen Naks for */ + bcp_options try; /* options to request next time */ + u_char bridge_id; + u_short lan_segno; + u_char macaddr[ETH_ALEN]; + int mac; + + BZERO(&no, sizeof(no)); + try = *go; + + /* + * Any Nak'd CIs must be in exactly the same order that we sent. + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define NAKCIBRIDGELINEID(opt, neg, code) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_BRIDGELINEID) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + no.neg = 1; \ + code \ + } + +#define NAKCIMACADDR(opt, neg, code) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_MACADDR) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + no.neg = 1; \ + GETCHAR(macaddr[0], p); \ + GETCHAR(macaddr[1], p); \ + GETCHAR(macaddr[2], p); \ + GETCHAR(macaddr[3], p); \ + GETCHAR(macaddr[4], p); \ + GETCHAR(macaddr[5], p); \ + code \ + } + +#define NAKCISPANTREE(opt, neg, code) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_SPANTREE) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + no.neg = 1; \ + GETCHAR(cichar, p); \ + code \ + } + +#define NAKCIMGMTINLINE(opt, neg, code) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_MGMT_INLINE) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + no.neg = 1; \ + code \ + } + + /* + * Accept the peer's value of bridge_id provided that it + * is greater than what we asked for. + */ + NAKCIBRIDGELINEID(CI_BRIDGE_IDENTIFICATION, neg_bridgeid, + bridge_id = cishort & 0xf; + if (bridge_id > 0 && + bridge_id > (go->lan_bridge_segno & 0xf)) + { + try.lan_bridge_segno = cishort; + } + ); + + /* + * Accept the peer's value of lan_segno provided that it + * is greater than what we asked for. + */ + NAKCIBRIDGELINEID(CI_LINE_IDENTIFICATION, neg_lineid, + lan_segno = cishort >> 4; + if (lan_segno > 0 && + lan_segno > (go->lan_bridge_segno >> 4)) + { + try.lan_bridge_segno = cishort; + } + ); + + /* + * Peer is not supposed to send Mac-Support in a Configure-Nak. + */ + + /* + * Peer is not supposed to send TinyGram-Compression in a Configure-Nak + * if we already sent it in a Configure-Request already. + */ + + + /* + * Peer is not supposed to send LAN-Identification in a Configure-Nak. + */ + + /* + * Accept the peer's value of macaddr provided that we requested + * an address of 00-00-00-00-00-00 and the suggested address does + * NOT have the multicast bit set. + */ + NAKCIMACADDR(CI_MAC_ADDRESS, neg_macaddr, + for (mac=0; mac<ETH_ALEN; mac++) + { + if (go->macaddr[mac] != 0) + break; + } + if (mac == ETH_ALEN) + { + if (!(macaddr[0] & BCP_MULTICAST)) + { + try.macaddr[0] = macaddr[0]; + try.macaddr[1] = macaddr[1]; + try.macaddr[2] = macaddr[2]; + try.macaddr[3] = macaddr[3]; + try.macaddr[4] = macaddr[4]; + try.macaddr[5] = macaddr[5]; + } + } + ); + + /* + * Accept the peer's value of spantree provided it has a lower + * protocol Id than the one we requested. + */ + NAKCISPANTREE(CI_SPANNING_TREE_PROTOCOL, neg_spantree, + if (cichar < go->spantree) + { + try.spantree = cichar; + } + ); + + NAKCIMGMTINLINE(CI_MANAGEMENT_INLINE, neg_mgmt_inline, + do {} while(0); + ); + + /* + * There may be remaining CIs, if the peer is requesting negotiation + * on an option that we didn't include in our request packet. + * If we see an option that we requested, or one we've already seen + * in this packet, then this packet is bad. + * If we wanted to respond by starting to negotiate on the requested + * option(s), we could, but we don't, because if we are not negotiating + * an option, it is because we were told not to. + */ + while (len > CILEN_VOID) { + GETCHAR(citype, p); + GETCHAR(cilen, p); + if( (len -= cilen) < 0 ) + goto bad; + next = p + cilen - 2; + + switch (citype) { + case CI_BRIDGE_IDENTIFICATION: + if (go->neg_bridgeid || no.neg_bridgeid || cilen != CILEN_BRIDGELINEID) + goto bad; + break; + case CI_LINE_IDENTIFICATION: + if (go->neg_lineid || no.neg_lineid || cilen != CILEN_BRIDGELINEID) + goto bad; + break; + case CI_TINYGRAM_COMPRESSION: + if (go->neg_tinygram || cilen != CILEN_TINYGRAM) + goto bad; + break; + case CI_LAN_IDENTIFICATION: + if (go->neg_lanid || cilen != CILEN_LANID) + goto bad; + break; + case CI_MAC_ADDRESS: + if (go->neg_macaddr || cilen != CILEN_MACADDR) + goto bad; + break; + case CI_SPANNING_TREE_PROTOCOL: + if (go->neg_spantree || cilen != CILEN_SPANTREE) + goto bad; + break; + case CI_MANAGEMENT_INLINE: + if (go->neg_mgmt_inline || cilen != CILEN_MGMT_INLINE) + goto bad; + break; + } + p = next; + } + + /* + * OK, the Nak is good. Now we can update state. + * If there are any remaining options, we ignore them. + */ + if (f->state != OPENED) + *go = try; + + return 1; + +bad: + BCPDEBUG(("bcp_nakci: received bad Nak!")); + return 0; +} + + +/* + * bcp_rejci - Reject some of our CIs. + * Callback from fsm_rconfnakrej. + */ +static int +bcp_rejci(f, p, len) + fsm *f; + u_char *p; + int len; +{ + bcp_options *go = &bcp_gotoptions[f->unit]; + u_char cilen, cichar; + u_short cishort; + bcp_options try; /* options to request next time */ + + try = *go; + + /* + * Any Rejected CIs must be in exactly the same order that we sent. + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define REJCIBRIDGELINEID(opt, neg, lan_bridge_segno) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_BRIDGELINEID) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + /* Check rejected value. */ \ + if (cishort != lan_bridge_segno) \ + goto bad; \ + try.neg = 0; \ + } + +#define REJCIMACSUPPORT(opt, neg, macsupport) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_MACSUPPORT) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if (cichar != macsupport) \ + goto bad; \ + try.neg = 0; \ + } + +#define REJCITINYGRAM(opt, neg, tinygram) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_TINYGRAM) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if (cichar != tinygram) \ + goto bad; \ + try.neg = 0; \ + } + +#define REJCILANID(opt, neg, lanid) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_LANID) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if (cichar != lanid) \ + goto bad; \ + try.neg = 0; \ + } + +#define REJCIMACADDR(opt, neg, macaddr) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_MACADDR) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + /* Check rejected value. */ \ + GETCHAR(cichar, p); \ + if (macaddr[0] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[1] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[2] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[3] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[4] != cichar) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (macaddr[5] != cichar) \ + goto bad; \ + try.neg = 0; \ + } + +#define REJCISPANTREE(opt, neg, spantree) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_SPANTREE) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if (cichar != spantree) \ + goto bad; \ + try.neg = 0; \ + } + +#define REJCIMGMTINLINE(opt, neg) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_MGMT_INLINE) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + try.neg = 0; \ + } + + REJCIBRIDGELINEID(CI_BRIDGE_IDENTIFICATION, neg_bridgeid, go->lan_bridge_segno); + + REJCIBRIDGELINEID(CI_LINE_IDENTIFICATION, neg_lineid, go->lan_bridge_segno); + + REJCIMACSUPPORT(CI_MAC_SUPPORT, neg_macsupport, go->macsupport[0]); + REJCIMACSUPPORT(CI_MAC_SUPPORT, neg_macsupport, go->macsupport[1]); + REJCIMACSUPPORT(CI_MAC_SUPPORT, neg_macsupport, go->macsupport[2]); + REJCIMACSUPPORT(CI_MAC_SUPPORT, neg_macsupport, go->macsupport[3]); + REJCIMACSUPPORT(CI_MAC_SUPPORT, neg_macsupport, go->macsupport[4]); + REJCIMACSUPPORT(CI_MAC_SUPPORT, neg_macsupport, go->macsupport[5]); + + REJCITINYGRAM(CI_TINYGRAM_COMPRESSION, neg_tinygram, go->tinygram); + + REJCILANID(CI_LAN_IDENTIFICATION, neg_lanid, go->lanid); + + REJCIMACADDR(CI_MAC_ADDRESS, neg_macaddr, go->macaddr); + + REJCISPANTREE(CI_SPANNING_TREE_PROTOCOL, neg_spantree, go->spantree); + + REJCIMGMTINLINE(CI_MANAGEMENT_INLINE, neg_mgmt_inline); + + /* + * If there are any remaining CIs, then this packet is bad. + */ + if (len != 0) + goto bad; + + /* If Management-Inline was rejected, try to negotiate a + * Spanning-Tree-Protocol instead. */ + if (go->neg_mgmt_inline && !try.neg_mgmt_inline) + try.neg_spantree = 1; + + /* + * Now we can update state. + */ + if (f->state != OPENED) + *go = try; + return 1; + +bad: + BCPDEBUG(("bcp_rejci: received bad Reject!")); + return 0; +} + + +/* + * bcp_reqci - Check the peer's requested CIs and send appropriate response. + * Callback from fsm_rconfreq, Receive Configure Request + * + * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified + * appropriately. If reject_if_disagree is non-zero, doesn't return + * CONFNAK; returns CONFREJ if it can't return CONFACK. + */ +static int +bcp_reqci(f, inp, len, reject_if_disagree) + fsm *f; + u_char *inp; /* Requested CIs */ + int *len; /* Length of requested CIs */ + int reject_if_disagree; +{ + bcp_options *ho = &bcp_hisoptions[f->unit]; + bcp_options *ao = &bcp_allowoptions[f->unit]; + bcp_options *go = &bcp_gotoptions[f->unit]; + u_char *cip, *next; /* Pointer to current and next CIs */ + u_short cilen, citype; /* Parsed len, type */ + u_short cishort; /* Parsed short value */ + u_char cichar; /* Parsed char value */ + u_char bridge_id; + u_short lan_segno; + int mac; + u_char macaddr[ETH_ALEN]; + + int rc = CONFACK; /* Final packet return code */ + int orc; /* Individual option return code */ + u_char *p; /* Pointer to next char to parse */ + u_char *ucp = inp; /* Pointer to current output char */ + int l = *len; /* Length left */ + + /* + * Reset all his options. + */ + BZERO(ho, sizeof(*ho)); + + /* + * Process all his options. + */ + next = inp; + while (l) { + orc = CONFACK; /* Assume success */ + cip = p = next; /* Remember begining of CI */ + if (l < 2 || /* Not enough data for CI header or */ + p[1] < 2 || /* CI length too small or */ + p[1] > l) { /* CI length too big? */ + BCPDEBUG(("bcp_reqci: bad CI length!")); + orc = CONFREJ; /* Reject bad CI */ + cilen = l; /* Reject till end of packet */ + l = 0; /* Don't loop again */ + goto endswitch; + } + GETCHAR(citype, p); /* Parse CI type */ + GETCHAR(cilen, p); /* Parse CI length */ + l -= cilen; /* Adjust remaining length */ + next += cilen; /* Step to next CI */ + + switch (citype) { /* Check CI type */ + case CI_BRIDGE_IDENTIFICATION: + if (!ao->neg_bridgeid || /* Allow option? */ + cilen != CILEN_BRIDGELINEID) /* Check CI length */ + { + orc = CONFREJ; /* Reject CI */ + break; + } + GETSHORT(cishort, p); /* Parse lan_bridge_segno */ + + /* + * If we are also negotiating bridgeid, then + * both sides must agree on the higher bridgeid. + */ + bridge_id = cishort & 0xf; + if ((bridge_id < (go->lan_bridge_segno & 0xf)) && + go->neg_bridgeid) + { + orc = CONFNAK; /* Nak CI */ + DECPTR(sizeof(u_short), p); + PUTSHORT(go->lan_bridge_segno, p); /* Give him a hint */ + break; + } + ho->neg_bridgeid = 1; /* Remember he negotiated this item */ + ho->lan_bridge_segno = cishort; /* And remember value */ + break; + + case CI_LINE_IDENTIFICATION: + if (!ao->neg_lineid || /* Allow option? */ + cilen != CILEN_BRIDGELINEID) /* Check CI length */ + { + orc = CONFREJ; /* Reject CI */ + break; + } + GETSHORT(cishort, p); /* Parse lan_bridge_segno */ + + /* + * If we are also negotiating lineid, then + * both sides must agree on the higher lan_segno. + */ + lan_segno = cishort >> 4; + if ((lan_segno < (go->lan_bridge_segno >> 4)) && + go->neg_lineid) + { + orc = CONFNAK; /* Nak CI */ + DECPTR(sizeof(u_short), p); + PUTSHORT(go->lan_bridge_segno, p); /* Give him a hint */ + break; + } + ho->neg_lineid = 1; /* Remember he negotiated this item */ + ho->lan_bridge_segno = cishort; /* And remember value */ + break; + + case CI_MAC_SUPPORT: + if (!ao->neg_macsupport || /* Allow option? */ + cilen != CILEN_MACSUPPORT) /* Check CI length */ + { + orc = CONFREJ; /* Reject CI */ + break; + } + GETCHAR(cichar, p); /* Parse macsupport value */ + + /* + * Ensure a valid value, else reject. + */ + switch (cichar) + { + case MAC_IEEE_802_3: + case MAC_IEEE_802_4: + case MAC_IEEE_802_5_NON: + case MAC_FDDI_NON: + case MAC_IEEE_802_5: + case MAC_FDDI: + ho->neg_macsupport = 1; + for (mac=0; mac<ETH_ALEN; mac++) + { + if (ho->macsupport[mac] == 0) + ho->macsupport[mac] = cichar; + } + break; + default: + orc = CONFREJ; /* Reject CI */ + break; + } + break; + + case CI_TINYGRAM_COMPRESSION: + if (!ao->neg_tinygram || /* Allow option? */ + cilen != CILEN_TINYGRAM) /* Check CI length */ + { + orc = CONFREJ; /* Reject CI */ + break; + } + GETCHAR(cichar, p); /* Parse tinygram value */ + + /* + * Ensure a valid value, else reject. + */ + if (cichar != 1 && cichar !=2) + { + orc = CONFREJ; /* Reject CI */ + break; + } + ho->neg_tinygram = 1; /* Remember he negotiated this item */ + ho->tinygram = cichar; /* And remember value */ + break; + + case CI_LAN_IDENTIFICATION: + if (!ao->neg_lanid || /* Allow option? */ + cilen != CILEN_LANID) /* Check CI length */ + { + orc = CONFREJ; /* Reject CI */ + break; + } + GETCHAR(cichar, p); /* Parse lanid value */ + + /* + * Ensure a valid value, else reject. + */ + if (cichar != 1 && cichar !=2) + { + orc = CONFREJ; /* Reject CI */ + break; + } + ho->neg_lanid = 1; /* Remember he negotiated this item */ + ho->lanid = cichar; /* And remember value */ + break; + + + case CI_MAC_ADDRESS: + if (!ao->neg_macaddr || /* Allow option? */ + cilen != CILEN_MACADDR) /* Check CI length */ + { + orc = CONFREJ; /* Reject CI */ + break; + } + GETCHAR(macaddr[0], p); /* Parse macaddr value */ + GETCHAR(macaddr[1], p); + GETCHAR(macaddr[2], p); + GETCHAR(macaddr[3], p); + GETCHAR(macaddr[4], p); + GETCHAR(macaddr[5], p); + + /* + * Reject macaddr if it has the multicast bit set or + * if it is all zeroes. (All zeroes is a request for + * us to assign a MAC address, which we could do, but...) + */ + for (mac=0; mac<ETH_ALEN; mac++) + { + if (go->macaddr[mac] != 0) + break; + } + if ((mac == ETH_ALEN) || (macaddr[0] & BCP_MULTICAST)) + { + orc = CONFREJ; /* Reject CI */ + break; + } + + ho->neg_macaddr = 1; /* Remember he negotiated this item */ + ho->macaddr[0] = macaddr[0]; /* And remember value */ + ho->macaddr[1] = macaddr[1]; + ho->macaddr[2] = macaddr[2]; + ho->macaddr[3] = macaddr[3]; + ho->macaddr[4] = macaddr[4]; + ho->macaddr[5] = macaddr[5]; + break; + + case CI_SPANNING_TREE_PROTOCOL: + if (!ao->neg_spantree || /* Allow option? */ + cilen != CILEN_SPANTREE) /* Check CI length */ + { + orc = CONFREJ; /* Reject CI */ + break; + } + GETCHAR(cichar, p); /* Parse spantree value */ + + /* + * Ensure a valid value, else reject. + */ + if (cichar > MAX_SPANTREE) + { + orc = CONFREJ; /* Reject CI */ + break; + } + + if ((cichar > go->spantree) && go->neg_spantree) + { + orc = CONFNAK; /* Nak CI */ + DECPTR(sizeof(u_short), p); + PUTSHORT(go->spantree, p); /* Give him a hint */ + break; + } + + ho->neg_spantree = 1; /* Remember he negotiated this item */ + ho->spantree = cichar; /* And remember value */ + break; + + case CI_MANAGEMENT_INLINE: + if (!ao->neg_mgmt_inline || /* Allow option? */ + cilen != CILEN_MGMT_INLINE) /* Check CI length */ + { + orc = CONFREJ; /* Reject CI */ + break; + } + + ho->neg_mgmt_inline = 1; /* Remember he negotiated this item */ + break; + + default: + orc = CONFREJ; + break; + } +endswitch: + if (orc == CONFACK && /* Good CI */ + rc != CONFACK) /* but prior CI wasnt? */ + continue; /* Don't send this one */ + + if (orc == CONFNAK) { /* Nak this CI? */ + if (reject_if_disagree) /* Getting fed up with sending NAKs? */ + orc = CONFREJ; /* Get tough if so */ + else { + if (rc == CONFREJ) /* Rejecting prior CI? */ + continue; /* Don't send this one */ + if (rc == CONFACK) { /* Ack'd all prior CIs? */ + rc = CONFNAK; /* Not anymore... */ + ucp = inp; /* Backup */ + } + } + } + + if (orc == CONFREJ && /* Reject this CI */ + rc != CONFREJ) { /* but no prior ones? */ + rc = CONFREJ; + ucp = inp; /* Backup */ + } + + /* Need to move CI? */ + if (ucp != cip) + BCOPY(cip, ucp, cilen); /* Move it */ + + /* Update output pointer */ + INCPTR(cilen, ucp); + } + + *len = ucp - inp; /* Compute output length */ + BCPDEBUG(("bcp: returning Configure-%s", CODENAME(rc))); + return (rc); /* Return final code */ +} + + +/* + * bcp_up - BCP has come UP. + * + * Configure the IP network interface appropriately and bring it up. + */ +static void +bcp_up(f) + fsm *f; +{ + bcp_options *go = &bcp_gotoptions[f->unit]; + bcp_options *ho = &bcp_hisoptions[f->unit]; + bcp_options *wo = &bcp_wantoptions[f->unit]; + u_char *maclocal; + char buf[32]; + + BCPDEBUG(("bcp: up")); + + /* Choose which MAC address (if any) to assign to the interface. */ + if (go->neg_macaddr) + maclocal = go->macaddr; + else if (wo->neg_macaddr) { + int i; + + /* If the wanted MAC address is all zeroes, it means we wanted the peer + * to assign us one. Since we didn't get one, there's a problem. */ + for (i = 0; i < ETH_ALEN; ++i) { + if (wo->macaddr[i] != 0) + break; + } + + if (i == ETH_ALEN) { + error("Could not determine local MAC address"); + bcp_close(f->unit, "Could not determine local MAC address"); + return; + } + + maclocal = wo->macaddr; + } else + maclocal = NULL; + + /* If Management-Inline is not supported, tell the kernel to encapsulate + * bridge PDUs in the old RFC 1638 format. */ + if (!go->neg_mgmt_inline) + { + sifnpmode(ifunit, PPP_BPDU_IEEE, NPMODE_PASS); + } + + /* After this the "bcp%d" device will exist. */ + sifnpmode(ifunit, PPP_BRIDGE, NPMODE_PASS); + + if (maclocal) { + char eth_ifname[16]; + slprintf(eth_ifname, sizeof(eth_ifname), "bcp%d", ifunit); + if (set_if_hwaddr(maclocal, eth_ifname) < 0) { + if (debug) + warn("Failed to set hardware address"); + bcp_close(f->unit, "Interface configuration failed"); + return; + } + } + + /* + * Set up /etc/ppp/eth-up environment. + */ + + /* MACLOCAL contains the MAC address of the BCP interface, if it has one. + * Otherwise, MACLOCAL is defined as an empty string. */ + if (maclocal) + slprintmac(buf, sizeof(buf), maclocal); + else + buf[0] = '\0'; + script_setenv("MACLOCAL", buf, 0); + + /* MACREMOTE contains the MAC address of the peer's BCP interface, if the + * peer published it during negotiation. Otherwise, MACREMOTE is defined + * as an empty string. */ + if (ho->neg_macaddr) + slprintmac(buf, sizeof(buf), ho->macaddr); + else + buf[0] = '\0'; + script_setenv("MACREMOTE", buf, 0); + + np_up(f->unit, PPP_BRIDGE); + bcp_is_up = 1; + + /* + * Execute the eth-up script, like this: + * /etc/ppp/eth-up interface tty speed local-IP remote-IP + */ + if (bcp_script_state == s_down && bcp_script_pid == 0) { + bcp_script_state = s_up; + bcp_script(f, _PATH_ETHUP); + } +} + + +/* + * bcp_down - BCP has gone DOWN. + * + */ +static void +bcp_down(f) + fsm *f; +{ + /* Execute the eth-down script */ + if (bcp_script_state == s_up && bcp_script_pid == 0) { + bcp_script_state = s_down; + bcp_script(f, _PATH_ETHDOWN); + } + + /* After this the "bcp%d" device will not exist. */ + sifnpmode(ifunit, PPP_BRIDGE, NPMODE_DROP); + + sifnpmode(ifunit, PPP_BPDU_IEEE, NPMODE_DROP); + + BCPDEBUG(("bcp: down")); + if (bcp_is_up) + { + bcp_is_up = 0; + np_down(f->unit, PPP_BRIDGE); + } +} + + +/* + * bcp_start - called when we want the lower layer up. + */ +static void +bcp_start(f) + fsm *f; +{ + np_start(f->unit, PPP_BRIDGE); +} + + +/* + * bcp_finished - possibly shut down the lower layers. + */ +static void +bcp_finished(f) + fsm *f; +{ + np_finished(f->unit, PPP_BRIDGE); +} + + +/* + * bcp_script_done - called when the ip-up or ip-down script + * has finished. + */ +static void +bcp_script_done(vp_f) + void *vp_f; +{ + fsm *f = vp_f; + + bcp_script_pid = 0; + switch (bcp_script_state) { + case s_up: + if (f->state != OPENED) { + bcp_script_state = s_down; + bcp_script(f, _PATH_ETHDOWN); + } + break; + case s_down: + if (f->state == OPENED) { + bcp_script_state = s_up; + bcp_script(f, _PATH_ETHUP); + } + break; + } +} + + +/* + * bcp_script - Execute a script with arguments + * bcp-interface-name phys-interface-name + */ +static void +bcp_script(f, script) + fsm *f; + char *script; +{ + char eth_ifname[16]; + char *argv[8]; + + slprintf(eth_ifname, sizeof(eth_ifname), "bcp%d", ifunit); + + argv[0] = script; + argv[1] = eth_ifname; /* bridge device (e.g. bcp<N>) */ + argv[2] = devnam; /* physical device (e.g. hdlc<N>) */ + argv[3] = NULL; + argv[4] = NULL; + argv[5] = NULL; + argv[6] = NULL; + argv[7] = NULL; + bcp_script_pid = run_program(script, argv, 0, bcp_script_done, f); +} + +/* + * bcp_printpkt - print the contents of an BCP packet. + */ +static char *bcp_codenames[] = { + "ConfReq", "ConfAck", "ConfNak", "ConfRej", + "TermReq", "TermAck", "CodeRej" +}; + +static int +bcp_printpkt(p, plen, printer, arg) + u_char *p; + int plen; + void (*printer) __P((void *, char *, ...)); + void *arg; +{ + int code, id, len, olen; + u_char *pstart, *optend; + u_short cishort; + + if (plen < HEADERLEN) + return 0; + pstart = p; + GETCHAR(code, p); + GETCHAR(id, p); + GETSHORT(len, p); + if (len < HEADERLEN || len > plen) + return 0; + + if (code >= 1 && code <= sizeof(bcp_codenames) / sizeof(char *)) + printer(arg, " %s", bcp_codenames[code-1]); + else + printer(arg, " code=0x%x", code); + printer(arg, " id=0x%x", id); + len -= HEADERLEN; + switch (code) { + case CONFREQ: + case CONFACK: + case CONFNAK: + case CONFREJ: + /* print option list */ + while (len >= 2) { + GETCHAR(code, p); + GETCHAR(olen, p); + p -= 2; + if (olen < 2 || olen > len) { + break; + } + printer(arg, " <"); + len -= olen; + optend = p + olen; + switch (code) { + case CI_BRIDGE_IDENTIFICATION: + if (olen == CILEN_BRIDGELINEID) { + p += 2; + GETSHORT(cishort, p); + printer(arg, "Bridge-ID LAN=0x%03x Bridge=0x%X", + (cishort & 0xFFF0) >> 4, + cishort & 0x000F); + } + break; + + case CI_LINE_IDENTIFICATION: + if (olen == CILEN_BRIDGELINEID) { + p += 2; + GETSHORT(cishort, p); + printer(arg, "Line-ID LAN=0x%03x Bridge=0x%X", + (cishort & 0xFFF0) >> 4, + cishort & 0x000F); + } + break; + + case CI_MAC_SUPPORT: + if (olen == CILEN_MACSUPPORT) { + p += 2; + printer(arg, "MAC-Support"); + } + break; + + case CI_TINYGRAM_COMPRESSION: + if (olen == CILEN_TINYGRAM) { + p += 2; + printer(arg, "Tinygram-Compression"); + } + break; + + case CI_LAN_IDENTIFICATION: + if (olen == CILEN_LANID) { + p += 2; + printer(arg, "LAN-ID (obsolete)"); + } + break; + + case CI_MAC_ADDRESS: + if (olen == CILEN_MACADDR) { + p += 2; + printer(arg, "MAC-Address"); + } + break; + + case CI_SPANNING_TREE_PROTOCOL: + if (olen >= CILEN_SPANTREE) { + p += 2; + printer(arg, "Spanning-Tree-Protocol (old format)"); + } + break; + + case CI_IEEE_802_TAGGED_FRAME: + if (olen == CILEN_IEEE_802_TAGGED_FRAME) { + p += 2; + printer(arg, "IEEE-802-Tagged-Frame"); + } + break; + + case CI_MANAGEMENT_INLINE: + if (olen == CILEN_VOID) { + p += 2; + printer(arg, "Management-Inline"); + } + break; + + default: + break; + } + while (p < optend) { + GETCHAR(code, p); + printer(arg, " %.2x", code); + } + printer(arg, ">"); + } + break; + + case TERMACK: + case TERMREQ: + if (len > 0 && *p >= ' ' && *p < 0x7f) { + printer(arg, " "); + print_string((char *)p, len, printer, arg); + p += len; + len = 0; + } + break; + } + + /* print the rest of the bytes in the packet */ + for (; len > 0; --len) { + GETCHAR(code, p); + printer(arg, " %.2x", code); + } + + return p - pstart; +} + +/* + * bcp_check_options - check that any IP-related options are OK, + * and assign appropriate defaults. + */ +static void +bcp_check_options() +{ +} + + diff -wbBurN pppd-2.4.1/pppd/bcp.h pppd-ai/pppd/bcp.h --- pppd-2.4.1/pppd/bcp.h 1969-12-31 19:00:00.000000000 -0500 +++ pppd-ai/pppd/bcp.h 2004-02-25 08:34:47.000000000 -0500 @@ -0,0 +1,73 @@ +/* + * bcp.h - Bridge Control Protocol definitions. + * + * Copyright (c) 2001-2004 Applied Innovation Inc. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms. The name of Applied Innovation Inc. + * may not be used to endorse or promote products derived from this + * software without specific prior written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + */ + +/* + * Options. + */ +#define CI_BRIDGE_IDENTIFICATION 1 +#define CI_LINE_IDENTIFICATION 2 +#define CI_MAC_SUPPORT 3 +#define CI_TINYGRAM_COMPRESSION 4 +#define CI_LAN_IDENTIFICATION 5 /* obsolete (since RFC 2878) */ +#define CI_MAC_ADDRESS 6 +#define CI_SPANNING_TREE_PROTOCOL 7 /* old format (RFC 1638) */ +#define CI_IEEE_802_TAGGED_FRAME 8 +#define CI_MANAGEMENT_INLINE 9 /* new format (RFC 2878) */ + +/* values for MAC Support */ +#define MAC_IEEE_802_3 1 +#define MAC_IEEE_802_4 2 +#define MAC_IEEE_802_5_NON 3 +#define MAC_FDDI_NON 4 +#define MAC_IEEE_802_5 11 +#define MAC_FDDI 12 + +/* Multicast bit */ +#define BCP_MULTICAST 1 + +/* values for Spanning Tree protocol */ +#define SPAN_NONE 0 +#define SPAN_IEEE_802_1D 1 +#define SPAN_IEEE_802_1G 2 +#define SPAN_IBM 3 +#define SPAN_DEC 4 +#define MAX_SPANTREE SPAN_DEC + +#define ETH_ALEN 6 /* ethernet address length */ + +typedef struct bcp_options { + u_int16_t lan_bridge_segno; + u_char macsupport[6]; /* MAC support */ + u_char tinygram; /* Tinygram Compression 1=enable, 2=disable */ + u_char lanid; /* Lan ID 1=enable, 2=disable*/ + u_char macaddr[ETH_ALEN]; /* MAC Address */ + u_char spantree; /* Spanning Tree Protocol */ + bool neg_bridgeid; + bool neg_lineid; + bool neg_macsupport; + bool neg_tinygram; + bool neg_lanid; + bool neg_macaddr; + bool neg_spantree; + bool neg_mgmt_inline; +} bcp_options; + +extern fsm bcp_fsm[]; +extern bcp_options bcp_wantoptions[]; +extern bcp_options bcp_gotoptions[]; +extern bcp_options bcp_allowoptions[]; +extern bcp_options bcp_hisoptions[]; + +extern struct protent bcp_protent; diff -wbBurN pppd-2.4.1/pppd/fsm.c pppd-ai/pppd/fsm.c --- pppd-2.4.1/pppd/fsm.c 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/fsm.c 2004-02-25 08:34:48.000000000 -0500 @@ -195,6 +195,8 @@ switch( f->state ){ case STARTING: f->state = INITIAL; + if( f->callbacks->finished ) + (*f->callbacks->finished)(f); break; case STOPPED: f->state = CLOSED; diff -wbBurN pppd-2.4.1/pppd/ipcp.c pppd-ai/pppd/ipcp.c --- pppd-2.4.1/pppd/ipcp.c 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/ipcp.c 2004-02-25 08:34:48.000000000 -0500 @@ -80,6 +80,7 @@ static int ipcp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */ static void ipcp_up __P((fsm *)); /* We're UP */ static void ipcp_down __P((fsm *)); /* We're DOWN */ +static void ipcp_start __P((fsm *)); /* Need lower layer */ static void ipcp_finished __P((fsm *)); /* Don't need lower layer */ fsm ipcp_fsm[NUM_PPP]; /* IPCP fsm structure */ @@ -94,7 +95,7 @@ ipcp_reqci, /* Request peer's Configuration Information */ ipcp_up, /* Called when fsm reaches OPENED state */ ipcp_down, /* Called when fsm leaves OPENED state */ - NULL, /* Called when we want the lower layer up */ + ipcp_start, /* Called when we want the lower layer up */ ipcp_finished, /* Called when we want the lower layer down */ NULL, /* Called when Protocol-Reject received */ NULL, /* Retransmission is necessary */ @@ -1789,6 +1790,17 @@ /* + * ipcp_start - called when we want the lower layer up. + */ +static void +ipcp_start(f) + fsm *f; +{ + np_start(f->unit, PPP_IP); +} + + +/* * ipcp_finished - possibly shut down the lower layers. */ static void diff -wbBurN pppd-2.4.1/pppd/ipv6cp.c pppd-ai/pppd/ipv6cp.c --- pppd-2.4.1/pppd/ipv6cp.c 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/ipv6cp.c 2004-02-25 08:34:48.000000000 -0500 @@ -146,6 +146,7 @@ static int ipv6cp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */ static void ipv6cp_up __P((fsm *)); /* We're UP */ static void ipv6cp_down __P((fsm *)); /* We're DOWN */ +static void ipv6cp_start __P((fsm *)); /* Need lower layer */ static void ipv6cp_finished __P((fsm *)); /* Don't need lower layer */ fsm ipv6cp_fsm[NUM_PPP]; /* IPV6CP fsm structure */ @@ -160,7 +161,7 @@ ipv6cp_reqci, /* Request peer's Configuration Information */ ipv6cp_up, /* Called when fsm reaches OPENED state */ ipv6cp_down, /* Called when fsm leaves OPENED state */ - NULL, /* Called when we want the lower layer up */ + ipv6cp_start, /* Called when we want the lower layer up */ ipv6cp_finished, /* Called when we want the lower layer down */ NULL, /* Called when Protocol-Reject received */ NULL, /* Retransmission is necessary */ @@ -1309,6 +1310,17 @@ /* + * ipv6cp_start - called when we want the lower layer up. + */ +static void +ipv6cp_start(f) + fsm *f; +{ + np_start(f->unit, PPP_IPV6); +} + + +/* * ipv6cp_finished - possibly shut down the lower layers. */ static void diff -wbBurN pppd-2.4.1/pppd/ipxcp.c pppd-ai/pppd/ipxcp.c --- pppd-2.4.1/pppd/ipxcp.c 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/ipxcp.c 2004-02-25 08:34:48.000000000 -0500 @@ -64,6 +64,7 @@ static int ipxcp_reqci __P((fsm *, u_char *, int *, int)); /* Rcv CI */ static void ipxcp_up __P((fsm *)); /* We're UP */ static void ipxcp_down __P((fsm *)); /* We're DOWN */ +static void ipxcp_start __P((fsm *)); /* Need lower layer */ static void ipxcp_finished __P((fsm *)); /* Don't need lower layer */ static void ipxcp_script __P((fsm *, char *)); /* Run an up/down script */ @@ -79,7 +80,7 @@ ipxcp_reqci, /* Request peer's Configuration Information */ ipxcp_up, /* Called when fsm reaches OPENED state */ ipxcp_down, /* Called when fsm leaves OPENED state */ - NULL, /* Called when we want the lower layer up */ + ipxcp_start, /* Called when we want the lower layer up */ ipxcp_finished, /* Called when we want the lower layer down */ NULL, /* Called when Protocol-Reject received */ NULL, /* Retransmission is necessary */ @@ -1358,6 +1359,17 @@ /* + * ipxcp_start - called when we want the lower layer up. + */ +static void +ipxcp_start(f) + fsm *f; +{ + np_start(f->unit, PPP_IPX); +} + + +/* * ipxcp_finished - possibly shut down the lower layers. */ static void diff -wbBurN pppd-2.4.1/pppd/main.c pppd-ai/pppd/main.c --- pppd-2.4.1/pppd/main.c 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/main.c 2004-02-25 08:34:48.000000000 -0500 @@ -45,6 +45,7 @@ #include "pppd.h" #include "magic.h" #include "fsm.h" +#include "bcp.h" #include "lcp.h" #include "ipcp.h" #ifdef INET6 @@ -212,6 +213,7 @@ #ifdef AT_CHANGE &atcp_protent, #endif + &bcp_protent, NULL }; diff -wbBurN pppd-2.4.1/pppd/Makefile.linux pppd-ai/pppd/Makefile.linux --- pppd-2.4.1/pppd/Makefile.linux 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/Makefile.linux 2004-02-25 08:34:47.000000000 -0500 @@ -7,13 +7,13 @@ BINDIR = /usr/sbin MANDIR = /usr/man -PPPDSRCS = main.c magic.c fsm.c lcp.c ipcp.c upap.c chap.c md5.c ccp.c \ +PPPDSRCS = main.c magic.c fsm.c bcp.c lcp.c ipcp.c upap.c chap.c md5.c ccp.c \ ipxcp.c auth.c options.c sys-linux.c md4.c chap_ms.c cbcp.c \ demand.c utils.c multilink.c tdb.c tty.c HEADERS = callout.h pathnames.h patchlevel.h chap.h md5.h chap_ms.h md4.h \ ipxcp.h cbcp.h tdb.h MANPAGES = pppd.8 -PPPDOBJS = main.o magic.o fsm.o lcp.o ipcp.o upap.o chap.o md5.o ccp.o \ +PPPDOBJS = main.o magic.o fsm.o bcp.o lcp.o ipcp.o upap.o chap.o md5.o ccp.o \ auth.o options.o demand.o utils.o sys-linux.o ipxcp.o multilink.o \ tdb.o tty.o diff -wbBurN pppd-2.4.1/pppd/pathnames.h pppd-ai/pppd/pathnames.h --- pppd-2.4.1/pppd/pathnames.h 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/pathnames.h 2004-02-25 08:34:48.000000000 -0500 @@ -29,6 +29,8 @@ #define _PATH_CONNERRS _ROOT_PATH "/etc/ppp/connect-errors" #define _PATH_PEERFILES _ROOT_PATH "/etc/ppp/peers/" #define _PATH_RESOLV _ROOT_PATH "/etc/ppp/resolv.conf" +#define _PATH_ETHUP _ROOT_PATH "/etc/ppp/eth-up" +#define _PATH_ETHDOWN _ROOT_PATH "/etc/ppp/eth-down" #define _PATH_USEROPT ".ppprc" diff -wbBurN pppd-2.4.1/pppd/pppd.h pppd-ai/pppd/pppd.h --- pppd-2.4.1/pppd/pppd.h 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/pppd.h 2004-02-25 08:34:48.000000000 -0500 @@ -450,6 +450,7 @@ void start_networks __P((void)); /* start all the network control protos */ void np_up __P((int, int)); /* a network protocol has come up */ void np_down __P((int, int)); /* a network protocol has gone down */ +void np_start __P((int, int)); /* a network protocol needs link */ void np_finished __P((int, int)); /* a network protocol no longer needs link */ void auth_peer_fail __P((int, int)); /* peer failed to authenticate itself */ @@ -496,6 +497,8 @@ int open_ppp_loopback __P((void)); /* Open loopback for demand-dialling */ int tty_establish_ppp __P((int)); /* Turn serial port into a ppp interface */ void tty_disestablish_ppp __P((int)); /* Restore port to normal operation */ +void generic_disestablish_ppp __P((int dev_fd)); /* Restore device setting */ +int generic_establish_ppp __P((int dev_fd, int chindex)); /* Make a ppp interface */ void make_new_bundle __P((int, int, int, int)); /* Create new bundle */ int bundle_attach __P((int)); /* Attach link to existing bundle */ void cfg_bundle __P((int, int, int, int)); /* Configure existing bundle */ @@ -566,6 +569,7 @@ int sipxfaddr __P((int, unsigned long, unsigned char *)); int cipxfaddr __P((int)); #endif +int set_if_hwaddr __P((const u_char *addr, const char *name)); int get_if_hwaddr __P((u_char *addr, char *name)); char *get_first_ethernet __P((void)); @@ -700,6 +704,7 @@ #ifdef DEBUGALL #define DEBUGMAIN 1 #define DEBUGFSM 1 +#define DEBUGBCP 1 #define DEBUGLCP 1 #define DEBUGIPCP 1 #define DEBUGIPV6CP 1 @@ -735,6 +740,12 @@ #define FSMDEBUG(x) #endif +#ifdef DEBUGBCP +#define BCPDEBUG(x) if (debug) dbglog x +#else +#define BCPDEBUG(x) +#endif + #ifdef DEBUGLCP #define LCPDEBUG(x) if (debug) dbglog x #else diff -wbBurN pppd-2.4.1/pppd/sys-linux.c pppd-ai/pppd/sys-linux.c --- pppd-2.4.1/pppd/sys-linux.c 2004-02-25 08:27:34.000000000 -0500 +++ pppd-ai/pppd/sys-linux.c 2004-02-25 08:34:48.000000000 -0500 @@ -128,7 +128,6 @@ static int sock6_fd = -1; #endif /* INET6 */ static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */ -static int chindex; /* channel index (new style driver) */ static fd_set in_fds; /* set of fds that wait_input waits for */ static int max_in_fd; /* highest fd set in in_fds */ @@ -141,7 +140,7 @@ static int restore_term = 0; /* 1 => we've munged the terminal */ static struct termios inittermios; /* Initial TTY termios */ -static int new_style_driver = 0; +int new_style_driver = 0; static char loop_name[20]; static unsigned char inbuf[512]; /* buffer for chars read from loopback */ @@ -359,9 +359,7 @@ int tty_establish_ppp (int tty_fd) { - int x; - int fd = -1; - + int ret_fd; /* * Ensure that the tty device is in exclusive mode. */ @@ -370,14 +368,6 @@ warn("Couldn't make tty exclusive: %m"); } /* - * Demand mode - prime the old ppp device to relinquish the unit. - */ - if (!new_style_driver && looped - && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) { - error("ioctl(transfer ppp unit): %m"); - return -1; - } -/* * Set the current tty to the PPP discpline */ @@ -393,21 +383,62 @@ } if (new_style_driver) { - /* Open another instance of /dev/ppp and connect the channel to it */ - int flags; - + int chindex; if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) { error("Couldn't get channel number: %m"); - goto err; + ret_fd = -1; + } else { + ret_fd = generic_establish_ppp(tty_fd, chindex); + } + } else { + ret_fd = generic_establish_ppp(tty_fd, -1); + } + + if (ret_fd < 0) { + if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno)) + warn("Couldn't reset tty to normal line discipline: %m"); + } + else + { +#define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP) +#define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \ + | SC_LOG_FLUSH) + + set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB)) + | ((kdebugflag * SC_DEBUG) & SC_LOGB))); + } + + return ret_fd; +} + +/******************************************************************** + * + * generic_establish_ppp - Turn the fd into a ppp interface. + */ +int generic_establish_ppp (int fd, int channel) +{ + int x; +/* + * Demand mode - prime the old ppp device to relinquish the unit. + */ + if (!new_style_driver && looped + && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) { + error("ioctl(transfer ppp unit): %m"); + return -1; } - dbglog("using channel %d", chindex); + + if (new_style_driver) { + /* Open another instance of /dev/ppp and connect the channel to it */ + int flags; + + dbglog("using channel %d", channel); fd = open("/dev/ppp", O_RDWR); if (fd < 0) { error("Couldn't reopen /dev/ppp: %m"); goto err; } - if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) { - error("Couldn't attach to channel %d: %m", chindex); + if (ioctl(fd, PPPIOCATTCHAN, &channel) < 0) { + error("Couldn't attach to channel %d: %m", channel); goto err_close; } flags = fcntl(fd, F_GETFL); @@ -440,8 +472,8 @@ /* * Old-style driver: find out which interface we were given. */ - set_ppp_fd (tty_fd); - if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) { + set_ppp_fd (fd); + if (ioctl(fd, PPPIOCGUNIT, &x) < 0) { if (ok_error (errno)) goto err; fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno); @@ -454,9 +486,9 @@ /* * Fetch the initial file flags and reset blocking mode on the file. */ - initfdflags = fcntl(tty_fd, F_GETFL); + initfdflags = fcntl(fd, F_GETFL); if (initfdflags == -1 || - fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) { + fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) { if ( ! ok_error (errno)) warn("Couldn't set device to non-blocking mode: %m"); } @@ -470,13 +503,6 @@ if (!looped) set_kdebugflag (kdebugflag); -#define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP) -#define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \ - | SC_LOG_FLUSH) - - set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB)) - | ((kdebugflag * SC_DEBUG) & SC_LOGB))); - SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver", driver_version, driver_modification, driver_patch)); @@ -485,22 +511,19 @@ err_close: close(fd); err: - if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno)) - warn("Couldn't reset tty to normal line discipline: %m"); return -1; } /******************************************************************** * - * tty_disestablish_ppp - Restore the serial port to normal operation, - * and reconnect the ppp unit to the loopback if in demand mode. + * tty_disestablish_ppp - Restore the serial port to normal operation. * This shouldn't call die() because it's called from die(). */ void tty_disestablish_ppp(int tty_fd) { - if (demand) - restore_loop(); + generic_disestablish_ppp(tty_fd); + if (!hungup) { /* * Flush the tty output buffer so that the TIOCSETD doesn't hang. @@ -526,13 +549,47 @@ warn("Couldn't restore device fd flags: %m"); } } +} + +/******************************************************************** + * + * generic_disestablish_ppp - Restore device components to normal + * operation, and reconnect the ppp unit to the loopback if in demand + * mode. This shouldn't call die() because it's called from die(). +*/ +void generic_disestablish_ppp(int dev_fd){ + + /* Restore loop if needed */ + if(demand) + restore_loop(); + + /* Finally detach the device */ initfdflags = -1; if (new_style_driver) { + if (!multilink && ioctl(ppp_fd, PPPIOCDISCONN) < 0) + error("Couldn't detach from PPP unit %d: %m", ifunit); + close(ppp_fd); ppp_fd = -1; - if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0) + + if (!looped && ifunit >= 0) { + if (ioctl(ppp_dev_fd, PPPIOCDETACH) < 0) { + /* linux/Documentation/networking/ppp_generic.txt says, + * + * This ioctl is deprecated since the same effect can be + * achieved by closing the instance. In order to prevent + * possible races this ioctl will fail with an EINVAL error + * if more than one file descriptor refers to this instance + * (i.e. as a result of dup(), dup2() or fork()). + * + * Testers report seeing this message, therefore I have quelled + * the error when EINVAL is returned. -- Dan Eble + */ + if (errno != EINVAL) error("Couldn't release PPP unit: %m"); + } + } if (!multilink) remove_fd(ppp_dev_fd); } @@ -1712,6 +1771,30 @@ } /* + * set_if_hwaddr - set the hardware address for the specified + * network interface device. + */ +int +set_if_hwaddr(const u_char *addr, const char *name) +{ + struct ifreq ifreq; + int ret, sock_fd; + + sock_fd = socket(AF_INET, SOCK_DGRAM, 0); + if (sock_fd < 0) + return 0; + memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr)); + strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name)); + ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq); + if (ret >= 0) { + memcpy(ifreq.ifr_hwaddr.sa_data, addr, 6); + ret = ioctl(sock_fd, SIOCSIFHWADDR, &ifreq); + } + close(sock_fd); + return ret; +} + +/* * get_if_hwaddr - get the hardware address for the specified * network interface device. */ @@ -2567,7 +2650,7 @@ * Just to be sure, set the real serial port to the normal discipline. */ -static void +void restore_loop(void) { looped = 1;
