136379Ssklower /*********************************************************** 236379Ssklower Copyright IBM Corporation 1987 336379Ssklower 436379Ssklower All Rights Reserved 536379Ssklower 636379Ssklower Permission to use, copy, modify, and distribute this software and its 736379Ssklower documentation for any purpose and without fee is hereby granted, 836379Ssklower provided that the above copyright notice appear in all copies and that 936379Ssklower both that copyright notice and this permission notice appear in 1036379Ssklower supporting documentation, and that the name of IBM not be 1136379Ssklower used in advertising or publicity pertaining to distribution of the 1236379Ssklower software without specific, written prior permission. 1336379Ssklower 1436379Ssklower IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING 1536379Ssklower ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL 1636379Ssklower IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR 1736379Ssklower ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 1836379Ssklower WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, 1936379Ssklower ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 2036379Ssklower SOFTWARE. 2136379Ssklower 2236379Ssklower ******************************************************************/ 2336379Ssklower 2436379Ssklower /* 2536379Ssklower * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison 2636379Ssklower */ 27*43430Ssklower /* @(#)esis.c 7.10 (Berkeley) 06/22/90 */ 2836379Ssklower #ifndef lint 2936379Ssklower static char *rcsid = "$Header: esis.c,v 4.10 88/09/15 18:57:03 hagens Exp $"; 3036379Ssklower #endif 3136379Ssklower 3236379Ssklower #ifdef ISO 3336379Ssklower 3437469Ssklower #include "types.h" 3537469Ssklower #include "param.h" 3637469Ssklower #include "mbuf.h" 3737469Ssklower #include "domain.h" 3837469Ssklower #include "protosw.h" 3937469Ssklower #include "user.h" 4037469Ssklower #include "socket.h" 4137469Ssklower #include "socketvar.h" 4237469Ssklower #include "errno.h" 4337469Ssklower #include "kernel.h" 4436379Ssklower 4536379Ssklower #include "../net/if.h" 4643332Ssklower #include "../net/if_dl.h" 4736379Ssklower #include "../net/route.h" 4843421Ssklower #include "../net/raw_cb.h" 4936379Ssklower 5037469Ssklower #include "iso.h" 5137469Ssklower #include "iso_pcb.h" 5237469Ssklower #include "iso_var.h" 5337469Ssklower #include "iso_snpac.h" 5437469Ssklower #include "clnl.h" 5537469Ssklower #include "clnp.h" 5637469Ssklower #include "clnp_stat.h" 5738841Ssklower #include "esis.h" 5837469Ssklower #include "argo_debug.h" 5936379Ssklower 6036379Ssklower /* 6136379Ssklower * Global variables to esis implementation 6236379Ssklower * 6336379Ssklower * esis_holding_time - the holding time (sec) parameter for outgoing pdus 6436379Ssklower * esis_config_time - the frequency (sec) that hellos are generated 6543421Ssklower * esis_esconfig_time - suggested es configuration time placed in the 6643421Ssklower * ish. 6736379Ssklower * 6836379Ssklower */ 6943421Ssklower struct rawcb esis_pcb; 7036379Ssklower int esis_sendspace = 2048; 7136379Ssklower int esis_recvspace = 2048; 7236379Ssklower short esis_holding_time = ESIS_HT; 7336379Ssklower short esis_config_time = ESIS_CONFIG; 7443421Ssklower short esis_esconfig_time = ESIS_CONFIG; 7536379Ssklower extern int iso_systype; 7643421Ssklower struct sockaddr_dl esis_dl = { sizeof(esis_dl), AF_LINK }; 7743332Ssklower extern char all_es_snpa[], all_is_snpa[]; 7836379Ssklower 7937469Ssklower #define EXTEND_PACKET(m, mhdr, cp)\ 8036379Ssklower if (((m)->m_next = m_getclr(M_DONTWAIT, MT_HEADER)) == NULL) {\ 8136379Ssklower esis_stat.es_nomem++;\ 8236379Ssklower m_freem(mhdr);\ 8336379Ssklower return;\ 8436379Ssklower } else {\ 8536379Ssklower (m) = (m)->m_next;\ 8636379Ssklower (cp) = mtod((m), caddr_t);\ 8736379Ssklower } 8836379Ssklower /* 8936379Ssklower * FUNCTION: esis_init 9036379Ssklower * 9136379Ssklower * PURPOSE: Initialize the kernel portion of esis protocol 9236379Ssklower * 9336379Ssklower * RETURNS: nothing 9436379Ssklower * 9536379Ssklower * SIDE EFFECTS: 9636379Ssklower * 9736379Ssklower * NOTES: 9836379Ssklower */ 9936379Ssklower esis_init() 10036379Ssklower { 10136379Ssklower extern struct clnl_protosw clnl_protox[256]; 10236379Ssklower int esis_input(); 10343421Ssklower int esis_config(); 10436379Ssklower int snpac_age(); 10536379Ssklower #ifdef ISO_X25ESIS 10636379Ssklower x25esis_input(); 10736379Ssklower #endif ISO_X25ESIS 10836379Ssklower 10943421Ssklower esis_pcb.rcb_next = esis_pcb.rcb_prev = &esis_pcb; 11043421Ssklower llinfo_llc.lc_next = llinfo_llc.lc_prev = &llinfo_llc; 11136379Ssklower 11236379Ssklower clnl_protox[ISO9542_ESIS].clnl_input = esis_input; 11336379Ssklower timeout(snpac_age, (caddr_t)0, hz); 11436379Ssklower timeout(esis_config, (caddr_t)0, hz); 11536379Ssklower 11636379Ssklower #ifdef ISO_X25ESIS 11736379Ssklower clnl_protox[ISO9542X25_ESIS].clnl_input = x25esis_input; 11836379Ssklower #endif ISO_X25ESIS 11936379Ssklower } 12036379Ssklower 12136379Ssklower /* 12236379Ssklower * FUNCTION: esis_usrreq 12336379Ssklower * 12436379Ssklower * PURPOSE: Handle user level esis requests 12536379Ssklower * 12636379Ssklower * RETURNS: 0 or appropriate errno 12736379Ssklower * 12836379Ssklower * SIDE EFFECTS: 12936379Ssklower * 13036379Ssklower */ 13137469Ssklower /*ARGSUSED*/ 13240775Ssklower esis_usrreq(so, req, m, nam, control) 13336379Ssklower struct socket *so; /* socket: used only to get to this code */ 13436379Ssklower int req; /* request */ 13536379Ssklower struct mbuf *m; /* data for request */ 13636379Ssklower struct mbuf *nam; /* optional name */ 13740775Ssklower struct mbuf *control; /* optional control */ 13836379Ssklower { 13943421Ssklower struct rawcb *rp = sotorawcb(so); 14043421Ssklower int error = 0; 14143421Ssklower 14243421Ssklower if (suser(u.u_cred, &u.u_acflag)) { 14343421Ssklower error = EACCES; 14443421Ssklower goto release; 14543421Ssklower } 14643421Ssklower if (rp == NULL && req != PRU_ATTACH) { 14743421Ssklower error = EINVAL; 14843421Ssklower goto release; 14943421Ssklower } 15043421Ssklower 15143421Ssklower switch (req) { 15243421Ssklower case PRU_ATTACH: 15343421Ssklower if (rp != NULL) { 15443421Ssklower error = EINVAL; 15543421Ssklower break; 15643421Ssklower } 15743421Ssklower MALLOC(rp, struct rawcb *, sizeof(*rp), M_PCB, M_WAITOK); 15843421Ssklower if (so->so_pcb = (caddr_t)rp) { 15943421Ssklower bzero(so->so_pcb, sizeof(*rp)); 16043421Ssklower insque(rp, &esis_pcb); 16143421Ssklower error = soreserve(so, esis_sendspace, esis_recvspace); 16243421Ssklower } else 16343421Ssklower error = ENOBUFS; 16443421Ssklower break; 16543421Ssklower 16643421Ssklower case PRU_SEND: 16743421Ssklower if (nam == NULL) { 16843421Ssklower error = EINVAL; 16943421Ssklower break; 17043421Ssklower } 17143421Ssklower /* error checking here */ 17243421Ssklower error = isis_output(mtod(nam,struct sockaddr_dl *), m); 17343421Ssklower m = NULL; 17443421Ssklower break; 17543421Ssklower 17643421Ssklower case PRU_DETACH: 17743421Ssklower raw_detach(rp); 17843421Ssklower break; 17943421Ssklower 18043421Ssklower case PRU_SHUTDOWN: 18143421Ssklower socantsendmore(so); 18243421Ssklower break; 18343421Ssklower 18443421Ssklower case PRU_ABORT: 18543421Ssklower soisdisconnected(so); 18643421Ssklower raw_detach(rp); 18743421Ssklower break; 18843421Ssklower 18943421Ssklower case PRU_SENSE: 19043421Ssklower return (0); 19143421Ssklower 19243421Ssklower default: 19343421Ssklower return (EOPNOTSUPP); 19443421Ssklower } 19543421Ssklower release: 19636379Ssklower if (m != NULL) 19736379Ssklower m_freem(m); 19836379Ssklower 19943421Ssklower return (error); 20036379Ssklower } 20136379Ssklower 20236379Ssklower /* 20336379Ssklower * FUNCTION: esis_input 20436379Ssklower * 20536379Ssklower * PURPOSE: Process an incoming esis packet 20636379Ssklower * 20736379Ssklower * RETURNS: nothing 20836379Ssklower * 20936379Ssklower * SIDE EFFECTS: 21036379Ssklower * 21136379Ssklower * NOTES: 21236379Ssklower */ 21336379Ssklower esis_input(m0, shp) 21436379Ssklower struct mbuf *m0; /* ptr to first mbuf of pkt */ 21536379Ssklower struct snpa_hdr *shp; /* subnetwork header */ 21636379Ssklower { 21743421Ssklower register struct esis_fixed *pdu = mtod(m0, struct esis_fixed *); 21837469Ssklower register int type; 21936379Ssklower 22036379Ssklower /* 22136379Ssklower * check checksum if necessary 22236379Ssklower */ 22337469Ssklower if (ESIS_CKSUM_REQUIRED(pdu) && iso_check_csum(m0, (int)pdu->esis_hdr_len)) { 22436379Ssklower esis_stat.es_badcsum++; 22536379Ssklower goto bad; 22636379Ssklower } 22736379Ssklower 22836379Ssklower /* check version */ 22936379Ssklower if (pdu->esis_vers != ESIS_VERSION) { 23036379Ssklower esis_stat.es_badvers++; 23136379Ssklower goto bad; 23236379Ssklower } 23337469Ssklower type = pdu->esis_type & 0x1f; 23437469Ssklower switch (type) { 23536379Ssklower case ESIS_ESH: 23636379Ssklower esis_eshinput(m0, shp); 23743421Ssklower break; 23836379Ssklower 23936379Ssklower case ESIS_ISH: 24036379Ssklower esis_ishinput(m0, shp); 24143421Ssklower break; 24236379Ssklower 24336379Ssklower case ESIS_RD: 24436379Ssklower esis_rdinput(m0, shp); 24543421Ssklower break; 24636379Ssklower 24743421Ssklower default: 24836379Ssklower esis_stat.es_badtype++; 24936379Ssklower } 25036379Ssklower 25136379Ssklower bad: 25243421Ssklower if (esis_pcb.rcb_next != &esis_pcb) 25343421Ssklower isis_input(m0, shp); 25443421Ssklower else 25543421Ssklower m_freem(m0); 25636379Ssklower } 25736379Ssklower 25836379Ssklower /* 25936379Ssklower * FUNCTION: esis_rdoutput 26036379Ssklower * 26136379Ssklower * PURPOSE: Transmit a redirect pdu 26236379Ssklower * 26336379Ssklower * RETURNS: nothing 26436379Ssklower * 26536379Ssklower * SIDE EFFECTS: 26636379Ssklower * 26736379Ssklower * NOTES: Assumes there is enough space for fixed part of header, 26836379Ssklower * DA, BSNPA and NET in first mbuf. 26936379Ssklower */ 27043332Ssklower esis_rdoutput(inbound_shp, inbound_m, inbound_oidx, rd_dstnsap, rt) 27136379Ssklower struct snpa_hdr *inbound_shp; /* snpa hdr from incoming packet */ 27236379Ssklower struct mbuf *inbound_m; /* incoming pkt itself */ 27336379Ssklower struct clnp_optidx *inbound_oidx; /* clnp options assoc with incoming pkt */ 27436379Ssklower struct iso_addr *rd_dstnsap; /* ultimate destination of pkt */ 27543332Ssklower struct rtentry *rt; /* snpa cache info regarding next hop of 27636379Ssklower pkt */ 27736379Ssklower { 27836379Ssklower struct mbuf *m, *m0; 27936379Ssklower caddr_t cp; 28036379Ssklower struct esis_fixed *pdu; 28136379Ssklower int len, total_len = 0; 28236379Ssklower struct sockaddr_iso siso; 28336379Ssklower struct ifnet *ifp = inbound_shp->snh_ifp; 28443332Ssklower struct sockaddr_dl *sdl; 28543332Ssklower struct iso_addr *rd_gwnsap; 28636379Ssklower 28743332Ssklower if (rt->rt_flags & RTF_GATEWAY) { 28843332Ssklower rd_gwnsap = &((struct sockaddr_iso *)rt->rt_gateway)->siso_addr; 28943332Ssklower rt = rtalloc1(rt->rt_gateway, 0); 29043332Ssklower } else 29143332Ssklower rd_gwnsap = &((struct sockaddr_iso *)rt_key(rt))->siso_addr; 29243332Ssklower if (rt == 0 || (sdl = (struct sockaddr_dl *)rt->rt_gateway) == 0 || 29343332Ssklower sdl->sdl_family != AF_LINK) { 29443332Ssklower /* maybe we should have a function that you 29543332Ssklower could put in the iso_ifaddr structure 29643332Ssklower which could translate iso_addrs into snpa's 29743332Ssklower where there is a known mapping for that address type */ 29843332Ssklower esis_stat.es_badtype++; 29943332Ssklower return; 30043332Ssklower } 30136379Ssklower esis_stat.es_rdsent++; 30236379Ssklower IFDEBUG(D_ESISOUTPUT) 30336379Ssklower printf("esis_rdoutput: ifp x%x (%s%d), ht %d, m x%x, oidx x%x\n", 30436379Ssklower ifp, ifp->if_name, ifp->if_unit, esis_holding_time, inbound_m, 30536379Ssklower inbound_oidx); 30636379Ssklower printf("\tdestination: %s\n", clnp_iso_addrp(rd_dstnsap)); 30743332Ssklower printf("\tredirected toward:%s\n", clnp_iso_addrp(rd_gwnsap)); 30836379Ssklower ENDDEBUG 30936379Ssklower 31037469Ssklower if ((m0 = m = m_gethdr(M_DONTWAIT, MT_HEADER)) == NULL) { 31136379Ssklower esis_stat.es_nomem++; 31236379Ssklower return; 31336379Ssklower } 31437469Ssklower bzero(mtod(m, caddr_t), MHLEN); 31536379Ssklower 31636379Ssklower pdu = mtod(m, struct esis_fixed *); 31737469Ssklower cp = (caddr_t)(pdu + 1); /*pointer arith.; 1st byte after header */ 31836379Ssklower len = sizeof(struct esis_fixed); 31936379Ssklower 32036379Ssklower /* 32136379Ssklower * Build fixed part of header 32236379Ssklower */ 32336379Ssklower pdu->esis_proto_id = ISO9542_ESIS; 32436379Ssklower pdu->esis_vers = ESIS_VERSION; 32536379Ssklower pdu->esis_type = ESIS_RD; 32636379Ssklower HTOC(pdu->esis_ht_msb, pdu->esis_ht_lsb, esis_holding_time); 32736379Ssklower 32836379Ssklower /* Insert destination address */ 32943072Ssklower (void) esis_insert_addr(&cp, &len, rd_dstnsap, m, 0); 33036379Ssklower 33136379Ssklower /* Insert the snpa of better next hop */ 33243332Ssklower *cp++ = sdl->sdl_alen; 33343332Ssklower bcopy(LLADDR(sdl), cp, sdl->sdl_alen); 33443332Ssklower cp += sdl->sdl_alen; 33543332Ssklower len += (sdl->sdl_alen + 1); 33636379Ssklower 33736379Ssklower /* 33836379Ssklower * If the next hop is not the destination, then it ought to be 33936379Ssklower * an IS and it should be inserted next. Else, set the 34036379Ssklower * NETL to 0 34136379Ssklower */ 34236379Ssklower /* PHASE2 use mask from ifp of outgoing interface */ 34343332Ssklower if (!iso_addrmatch1(rd_dstnsap, rd_gwnsap)) { 34443332Ssklower /* this should not happen: 34536379Ssklower if ((nhop_sc->sc_flags & SNPA_IS) == 0) { 34636379Ssklower printf("esis_rdoutput: next hop is not dst and not an IS\n"); 34736379Ssklower m_freem(m0); 34836379Ssklower return; 34943332Ssklower } */ 35043332Ssklower (void) esis_insert_addr(&cp, &len, rd_gwnsap, m, 0); 35136379Ssklower } else { 35236379Ssklower *cp++ = 0; /* NETL */ 35336379Ssklower len++; 35436379Ssklower } 35537469Ssklower m->m_len = len; 35636379Ssklower 35736379Ssklower /* 35836379Ssklower * PHASE2 35936379Ssklower * If redirect is to an IS, add an address mask. The mask to be 36036379Ssklower * used should be the mask present in the routing entry used to 36136379Ssklower * forward the original data packet. 36236379Ssklower */ 36336379Ssklower 36436379Ssklower /* 36536379Ssklower * Copy Qos, priority, or security options present in original npdu 36636379Ssklower */ 36736379Ssklower if (inbound_oidx) { 36843332Ssklower /* THIS CODE IS CURRENTLY (mostly) UNTESTED */ 36936379Ssklower int optlen = 0; 37036379Ssklower if (inbound_oidx->cni_qos_formatp) 37136379Ssklower optlen += (inbound_oidx->cni_qos_len + 2); 37236379Ssklower if (inbound_oidx->cni_priorp) /* priority option is 1 byte long */ 37336379Ssklower optlen += 3; 37436379Ssklower if (inbound_oidx->cni_securep) 37536379Ssklower optlen += (inbound_oidx->cni_secure_len + 2); 37637469Ssklower if (M_TRAILINGSPACE(m) < optlen) { 37737469Ssklower EXTEND_PACKET(m, m0, cp); 37837469Ssklower m->m_len = 0; 37936379Ssklower /* assumes MLEN > optlen */ 38036379Ssklower } 38136379Ssklower /* assume MLEN-len > optlen */ 38236379Ssklower /* 38336379Ssklower * When copying options, copy from ptr - 2 in order to grab 38436379Ssklower * the option code and length 38536379Ssklower */ 38636379Ssklower if (inbound_oidx->cni_qos_formatp) { 38743332Ssklower bcopy(mtod(inbound_m, caddr_t) + inbound_oidx->cni_qos_formatp - 2, 38843332Ssklower cp, (unsigned)(inbound_oidx->cni_qos_len + 2)); 38943332Ssklower cp += inbound_oidx->cni_qos_len + 2; 39036379Ssklower } 39136379Ssklower if (inbound_oidx->cni_priorp) { 39243332Ssklower bcopy(mtod(inbound_m, caddr_t) + inbound_oidx->cni_priorp - 2, 39343332Ssklower cp, 3); 39443332Ssklower cp += 3; 39536379Ssklower } 39636379Ssklower if (inbound_oidx->cni_securep) { 39743332Ssklower bcopy(mtod(inbound_m, caddr_t) + inbound_oidx->cni_securep - 2, cp, 39837469Ssklower (unsigned)(inbound_oidx->cni_secure_len + 2)); 39943332Ssklower cp += inbound_oidx->cni_secure_len + 2; 40036379Ssklower } 40137469Ssklower m->m_len += optlen; 40243332Ssklower len += optlen; 40336379Ssklower } 40436379Ssklower 40537469Ssklower pdu->esis_hdr_len = m0->m_pkthdr.len = len; 40636379Ssklower iso_gen_csum(m0, ESIS_CKSUM_OFF, (int)pdu->esis_hdr_len); 40736379Ssklower 40837469Ssklower bzero((caddr_t)&siso, sizeof(siso)); 40936379Ssklower siso.siso_family = AF_ISO; 41037469Ssklower siso.siso_data[0] = AFI_SNA; 41137469Ssklower siso.siso_nlen = 6 + 1; /* should be taken from snpa_hdr */ 41236379Ssklower /* +1 is for AFI */ 41337469Ssklower bcopy(inbound_shp->snh_shost, siso.siso_data + 1, 6); 41440775Ssklower (ifp->if_output)(ifp, m0, &siso, 0); 41536379Ssklower } 41636379Ssklower 41736379Ssklower /* 41836379Ssklower * FUNCTION: esis_insert_addr 41936379Ssklower * 42036379Ssklower * PURPOSE: Insert an iso_addr into a buffer 42136379Ssklower * 42236379Ssklower * RETURNS: true if buffer was big enough, else false 42336379Ssklower * 42436379Ssklower * SIDE EFFECTS: Increment buf & len according to size of iso_addr 42536379Ssklower * 42636379Ssklower * NOTES: Plus 1 here is for length byte 42736379Ssklower */ 42843072Ssklower esis_insert_addr(buf, len, isoa, m, nsellen) 42943332Ssklower register caddr_t *buf; /* ptr to buffer to put address into */ 43043332Ssklower int *len; /* ptr to length of buffer so far */ 43143332Ssklower register struct iso_addr *isoa; /* ptr to address */ 43243332Ssklower register struct mbuf *m; /* determine if there remains space */ 43343332Ssklower int nsellen; 43436379Ssklower { 43543332Ssklower register int newlen, result = 0; 43636379Ssklower 43743332Ssklower isoa->isoa_len -= nsellen; 43843332Ssklower newlen = isoa->isoa_len + 1; 43943332Ssklower if (newlen <= M_TRAILINGSPACE(m)) { 44043332Ssklower bcopy((caddr_t)isoa, *buf, newlen); 44143332Ssklower *len += newlen; 44243332Ssklower *buf += newlen; 44343332Ssklower m->m_len += newlen; 44443332Ssklower result = 1; 44543332Ssklower } 44643332Ssklower isoa->isoa_len += nsellen; 44743332Ssklower return (result); 44836379Ssklower } 44936379Ssklower 45039950Ssklower #define ESIS_EXTRACT_ADDR(d, b) { d = (struct iso_addr *)(b); b += (1 + *b); \ 45139950Ssklower if (b > buflim) {esis_stat.es_toosmall++; goto bad;}} 45239950Ssklower #define ESIS_NEXT_OPTION(b) { b += (2 + b[1]); \ 45339950Ssklower if (b > buflim) {esis_stat.es_toosmall++; goto bad;}} 454*43430Ssklower int ESHonly = 0; 45536379Ssklower /* 45636379Ssklower 45736379Ssklower /* 45836379Ssklower * FUNCTION: esis_eshinput 45936379Ssklower * 46036379Ssklower * PURPOSE: Process an incoming ESH pdu 46136379Ssklower * 46236379Ssklower * RETURNS: nothing 46336379Ssklower * 46436379Ssklower * SIDE EFFECTS: 46536379Ssklower * 46636379Ssklower * NOTES: 46736379Ssklower */ 46836379Ssklower esis_eshinput(m, shp) 46936379Ssklower struct mbuf *m; /* esh pdu */ 47036379Ssklower struct snpa_hdr *shp; /* subnetwork header */ 47136379Ssklower { 47243072Ssklower struct esis_fixed *pdu = mtod(m, struct esis_fixed *); 47336379Ssklower u_short ht; /* holding time */ 47443072Ssklower struct iso_addr *nsap; 47539950Ssklower int naddr; 47637469Ssklower u_char *buf = (u_char *)(pdu + 1); 47739950Ssklower u_char *buflim = pdu->esis_hdr_len + (u_char *)pdu; 47843332Ssklower int new_entry = 0; 47936379Ssklower 48036379Ssklower esis_stat.es_eshrcvd++; 48136379Ssklower 48236379Ssklower CTOH(pdu->esis_ht_msb, pdu->esis_ht_lsb, ht); 48336379Ssklower 48439950Ssklower naddr = *buf++; 48539950Ssklower if (buf >= buflim) 48636379Ssklower goto bad; 48743332Ssklower if (naddr == 1) { 48839950Ssklower ESIS_EXTRACT_ADDR(nsap, buf); 48943332Ssklower new_entry = snpac_add(shp->snh_ifp, 49043332Ssklower nsap, shp->snh_shost, SNPA_ES, ht, 0); 49143332Ssklower } else { 49243332Ssklower int nsellength = 0, nlen = 0; 49343332Ssklower { 49443332Ssklower /* See if we want to compress out multiple nsaps differing 49543332Ssklower only by nsel */ 49643332Ssklower register struct ifaddr *ifa = shp->snh_ifp->if_addrlist; 49743332Ssklower for (; ifa; ifa = ifa->ifa_next) 49843332Ssklower if (ifa->ifa_addr->sa_family == AF_ISO) { 49943332Ssklower nsellength = ((struct iso_ifaddr *)ifa)->ia_addr.siso_tlen; 50043332Ssklower break; 50143332Ssklower } 50243332Ssklower } 50339950Ssklower IFDEBUG(D_ESISINPUT) 50443332Ssklower printf("esis_eshinput: esh: ht %d, naddr %d nsellength %d\n", 50543332Ssklower ht, naddr, nsellength); 50639950Ssklower ENDDEBUG 50743332Ssklower while (naddr-- > 0) { 50843332Ssklower struct iso_addr *nsap2; u_char *buf2; 50943332Ssklower ESIS_EXTRACT_ADDR(nsap, buf); 51043332Ssklower /* see if there is at least one more nsap in ESH differing 51143332Ssklower only by nsel */ 51243332Ssklower if (nsellength != 0) for (buf2 = buf; buf2 < buflim;) { 51343332Ssklower ESIS_EXTRACT_ADDR(nsap2, buf2); 51443332Ssklower IFDEBUG(D_ESISINPUT) 51543332Ssklower printf("esis_eshinput: comparing %s ", 51643332Ssklower clnp_iso_addrp(nsap)); 51743332Ssklower printf("and %s\n", clnp_iso_addrp(nsap2)); 51843332Ssklower ENDDEBUG 51943332Ssklower if (Bcmp(nsap->isoa_genaddr, nsap2->isoa_genaddr, 52043332Ssklower nsap->isoa_len - nsellength) == 0) { 52143332Ssklower nlen = nsellength; 52243332Ssklower break; 52343332Ssklower } 52443332Ssklower } 52543332Ssklower new_entry |= snpac_add(shp->snh_ifp, 52643332Ssklower nsap, shp->snh_shost, SNPA_ES, ht, nlen); 52743332Ssklower nlen = 0; 52843332Ssklower } 52939950Ssklower } 53043332Ssklower IFDEBUG(D_ESISINPUT) 53143332Ssklower printf("esis_eshinput: nsap %s is %s\n", 53243332Ssklower clnp_iso_addrp(nsap), new_entry ? "new" : "old"); 53343332Ssklower ENDDEBUG 53443332Ssklower if (new_entry && (iso_systype & SNPA_IS)) 53543332Ssklower esis_shoutput(shp->snh_ifp, ESIS_ISH, esis_holding_time, 53643332Ssklower shp->snh_shost, 6, (struct iso_addr *)0); 53737469Ssklower bad: 53839950Ssklower return; 53936379Ssklower } 54036379Ssklower 54136379Ssklower /* 54236379Ssklower * FUNCTION: esis_ishinput 54336379Ssklower * 54436379Ssklower * PURPOSE: process an incoming ISH pdu 54536379Ssklower * 54636379Ssklower * RETURNS: 54736379Ssklower * 54836379Ssklower * SIDE EFFECTS: 54936379Ssklower * 55036379Ssklower * NOTES: 55136379Ssklower */ 55236379Ssklower esis_ishinput(m, shp) 55336379Ssklower struct mbuf *m; /* esh pdu */ 55436379Ssklower struct snpa_hdr *shp; /* subnetwork header */ 55536379Ssklower { 55636379Ssklower struct esis_fixed *pdu = mtod(m, struct esis_fixed *); 557*43430Ssklower u_short ht, newct; /* holding time */ 55839950Ssklower struct iso_addr *nsap; /* Network Entity Title */ 55939950Ssklower register u_char *buf = (u_char *) (pdu + 1); 56039950Ssklower register u_char *buflim = pdu->esis_hdr_len + (u_char *)pdu; 56139950Ssklower int new_entry; 56236379Ssklower 56336379Ssklower esis_stat.es_ishrcvd++; 56436379Ssklower CTOH(pdu->esis_ht_msb, pdu->esis_ht_lsb, ht); 56536379Ssklower 56636379Ssklower IFDEBUG(D_ESISINPUT) 56736379Ssklower printf("esis_ishinput: ish: ht %d\n", ht); 56836379Ssklower ENDDEBUG 56939950Ssklower if (ESHonly) 57037469Ssklower goto bad; 57136379Ssklower 57239950Ssklower ESIS_EXTRACT_ADDR(nsap, buf); 57339950Ssklower 57439950Ssklower while (buf < buflim) { 57539950Ssklower switch (*buf) { 57637469Ssklower case ESISOVAL_ESCT: 57739950Ssklower if (buf[1] != 2) 57837469Ssklower goto bad; 579*43430Ssklower CTOH(buf[2], buf[3], newct); 580*43430Ssklower if (esis_config_time != newct) { 581*43430Ssklower untimeout(esis_config,0); 582*43430Ssklower esis_config_time = newct; 583*43430Ssklower esis_config(); 584*43430Ssklower } 58539950Ssklower break; 58639950Ssklower 58739950Ssklower default: 58839950Ssklower printf("Unknown ISH option: %x\n", *buf); 58937469Ssklower } 59039950Ssklower ESIS_NEXT_OPTION(buf); 59137469Ssklower } 59243332Ssklower new_entry = snpac_add(shp->snh_ifp, nsap, shp->snh_shost, SNPA_IS, ht, 0); 59337469Ssklower IFDEBUG(D_ESISINPUT) 59437469Ssklower printf("esis_ishinput: nsap %s is %s\n", 59537469Ssklower clnp_iso_addrp(nsap), new_entry ? "new" : "old"); 59637469Ssklower ENDDEBUG 59737469Ssklower 59837469Ssklower if (new_entry) 59937469Ssklower esis_shoutput(shp->snh_ifp, 60037469Ssklower iso_systype & SNPA_ES ? ESIS_ESH : ESIS_ISH, 60143332Ssklower esis_holding_time, shp->snh_shost, 6, (struct iso_addr *)0); 60239950Ssklower bad: 60339950Ssklower return; 60436379Ssklower } 60536379Ssklower 60636379Ssklower /* 60736379Ssklower * FUNCTION: esis_rdinput 60836379Ssklower * 60936379Ssklower * PURPOSE: Process an incoming RD pdu 61036379Ssklower * 61136379Ssklower * RETURNS: 61236379Ssklower * 61336379Ssklower * SIDE EFFECTS: 61436379Ssklower * 61536379Ssklower * NOTES: 61636379Ssklower */ 61736379Ssklower esis_rdinput(m0, shp) 61836379Ssklower struct mbuf *m0; /* esh pdu */ 61936379Ssklower struct snpa_hdr *shp; /* subnetwork header */ 62036379Ssklower { 62136379Ssklower struct esis_fixed *pdu = mtod(m0, struct esis_fixed *); 62236379Ssklower u_short ht; /* holding time */ 62339950Ssklower struct iso_addr *da, *net = 0, *netmask = 0, *snpamask = 0; 62439950Ssklower register struct iso_addr *bsnpa; 62539950Ssklower register u_char *buf = (u_char *)(pdu + 1); 62639950Ssklower register u_char *buflim = pdu->esis_hdr_len + (u_char *)pdu; 62736379Ssklower 62836379Ssklower esis_stat.es_rdrcvd++; 62936379Ssklower 63036379Ssklower /* intermediate systems ignore redirects */ 63136379Ssklower if (iso_systype & SNPA_IS) 63243421Ssklower return; 63339950Ssklower if (ESHonly) 63443421Ssklower return; 63536379Ssklower 63636379Ssklower CTOH(pdu->esis_ht_msb, pdu->esis_ht_lsb, ht); 63739950Ssklower if (buf >= buflim) 63843421Ssklower return; 63936379Ssklower 64036379Ssklower /* Extract DA */ 64139950Ssklower ESIS_EXTRACT_ADDR(da, buf); 64237469Ssklower 64336379Ssklower /* Extract better snpa */ 64439950Ssklower ESIS_EXTRACT_ADDR(bsnpa, buf); 64539950Ssklower 64637469Ssklower /* Extract NET if present */ 64739950Ssklower if (buf < buflim) { 64843332Ssklower if (*buf == 0) 64943332Ssklower buf++; /* no NET present, skip NETL anyway */ 65043332Ssklower else 65143332Ssklower ESIS_EXTRACT_ADDR(net, buf); 65236379Ssklower } 65336379Ssklower 65437469Ssklower /* process options */ 65539950Ssklower while (buf < buflim) { 65639950Ssklower switch (*buf) { 65737469Ssklower case ESISOVAL_SNPAMASK: 65837469Ssklower if (snpamask) /* duplicate */ 65943421Ssklower return; 66039950Ssklower snpamask = (struct iso_addr *)(buf + 1); 66137469Ssklower break; 66237469Ssklower 66337469Ssklower case ESISOVAL_NETMASK: 66437469Ssklower if (netmask) /* duplicate */ 66543421Ssklower return; 66639950Ssklower netmask = (struct iso_addr *)(buf + 1); 66739950Ssklower break; 66839950Ssklower 66939950Ssklower default: 67039950Ssklower printf("Unknown option in ESIS RD (0x%x)\n", buf[-1]); 67137469Ssklower } 67239950Ssklower ESIS_NEXT_OPTION(buf); 67336379Ssklower } 67436379Ssklower 67536379Ssklower IFDEBUG(D_ESISINPUT) 67637469Ssklower printf("esis_rdinput: rd: ht %d, da %s\n", ht, clnp_iso_addrp(da)); 67737469Ssklower if (net) 67837469Ssklower printf("\t: net %s\n", clnp_iso_addrp(net)); 67936379Ssklower ENDDEBUG 68036379Ssklower /* 68136379Ssklower * If netl is zero, then redirect is to an ES. We need to add an entry 68236379Ssklower * to the snpa cache for (destination, better snpa). 68336379Ssklower * If netl is not zero, then the redirect is to an IS. In this 68436379Ssklower * case, add an snpa cache entry for (net, better snpa). 68536379Ssklower * 68636379Ssklower * If the redirect is to an IS, add a route entry towards that 68736379Ssklower * IS. 68836379Ssklower */ 68939950Ssklower if (net == 0 || net->isoa_len == 0 || snpamask) { 69036379Ssklower /* redirect to an ES */ 69139950Ssklower snpac_add(shp->snh_ifp, da, 69243332Ssklower bsnpa->isoa_genaddr, SNPA_ES, ht, 0); 69336379Ssklower } else { 69439950Ssklower snpac_add(shp->snh_ifp, net, 69543332Ssklower bsnpa->isoa_genaddr, SNPA_IS, ht, 0); 69639950Ssklower snpac_addrt(shp->snh_ifp, da, net, netmask); 69736379Ssklower } 69843421Ssklower bad: ; /* Needed by ESIS_NEXT_OPTION */ 69936379Ssklower } 70036379Ssklower 70136379Ssklower /* 70236379Ssklower * FUNCTION: esis_config 70336379Ssklower * 70436379Ssklower * PURPOSE: Report configuration 70536379Ssklower * 70636379Ssklower * RETURNS: 70736379Ssklower * 70836379Ssklower * SIDE EFFECTS: 70936379Ssklower * 71036379Ssklower * NOTES: Called every esis_config_time seconds 71136379Ssklower */ 71236379Ssklower esis_config() 71336379Ssklower { 71436379Ssklower register struct ifnet *ifp; 71536379Ssklower 71636379Ssklower timeout(esis_config, (caddr_t)0, hz * esis_config_time); 71736379Ssklower 71836379Ssklower /* 71936379Ssklower * Report configuration for each interface that 72036379Ssklower * - is UP 72136379Ssklower * - is not loopback 72236379Ssklower * - has an ISO address 72336379Ssklower */ 72436379Ssklower 72536379Ssklower for (ifp = ifnet; ifp; ifp = ifp->if_next) { 72636379Ssklower if ((ifp->if_flags & IFF_UP) && 72736379Ssklower ((ifp->if_flags & IFF_LOOPBACK) == 0)) { 72836379Ssklower /* search for an ISO address family */ 72936379Ssklower struct ifaddr *ia; 73036379Ssklower 73136379Ssklower for (ia = ifp->if_addrlist; ia; ia = ia->ifa_next) { 73237469Ssklower if (ia->ifa_addr->sa_family == AF_ISO) { 73336379Ssklower esis_shoutput(ifp, 73436379Ssklower iso_systype & SNPA_ES ? ESIS_ESH : ESIS_ISH, 73536379Ssklower esis_holding_time, 73643332Ssklower (caddr_t)(iso_systype & SNPA_ES ? all_is_snpa : 73743332Ssklower all_es_snpa), 6, (struct iso_addr *)0); 73836379Ssklower break; 73936379Ssklower } 74036379Ssklower } 74136379Ssklower } 74236379Ssklower } 74336379Ssklower } 74436379Ssklower 74536379Ssklower /* 74636379Ssklower * FUNCTION: esis_shoutput 74736379Ssklower * 74836379Ssklower * PURPOSE: Transmit an esh or ish pdu 74936379Ssklower * 75036379Ssklower * RETURNS: nothing 75136379Ssklower * 75236379Ssklower * SIDE EFFECTS: 75336379Ssklower * 75436379Ssklower * NOTES: 75536379Ssklower */ 75643332Ssklower esis_shoutput(ifp, type, ht, sn_addr, sn_len, isoa) 75736379Ssklower struct ifnet *ifp; 75836379Ssklower int type; 75936379Ssklower short ht; 76036379Ssklower caddr_t sn_addr; 76136379Ssklower int sn_len; 76243332Ssklower struct iso_addr *isoa; 76336379Ssklower { 76436379Ssklower struct mbuf *m, *m0; 76536379Ssklower caddr_t cp, naddrp; 76636379Ssklower int naddr = 0; 76736379Ssklower struct esis_fixed *pdu; 76843332Ssklower struct iso_ifaddr *ia; 76937469Ssklower int len; 77036379Ssklower struct sockaddr_iso siso; 77136379Ssklower 77236379Ssklower if (type == ESIS_ESH) 77336379Ssklower esis_stat.es_eshsent++; 77436379Ssklower else if (type == ESIS_ISH) 77536379Ssklower esis_stat.es_ishsent++; 77636379Ssklower else { 77736379Ssklower printf("esis_shoutput: bad pdu type\n"); 77836379Ssklower return; 77936379Ssklower } 78036379Ssklower 78136379Ssklower IFDEBUG(D_ESISOUTPUT) 78236379Ssklower int i; 78336379Ssklower printf("esis_shoutput: ifp x%x (%s%d), %s, ht %d, to: [%d] ", 78436379Ssklower ifp, ifp->if_name, ifp->if_unit, type == ESIS_ESH ? "esh" : "ish", 78536379Ssklower ht, sn_len); 78636379Ssklower for (i=0; i<sn_len; i++) 78736379Ssklower printf("%x%c", *(sn_addr+i), i < (sn_len-1) ? ':' : ' '); 78836379Ssklower printf("\n"); 78936379Ssklower ENDDEBUG 79036379Ssklower 79137469Ssklower if ((m0 = m = m_gethdr(M_DONTWAIT, MT_HEADER)) == NULL) { 79236379Ssklower esis_stat.es_nomem++; 79336379Ssklower return; 79436379Ssklower } 79537469Ssklower bzero(mtod(m, caddr_t), MHLEN); 79636379Ssklower 79736379Ssklower pdu = mtod(m, struct esis_fixed *); 79837469Ssklower naddrp = cp = (caddr_t)(pdu + 1); 79936379Ssklower len = sizeof(struct esis_fixed); 80036379Ssklower 80136379Ssklower /* 80236379Ssklower * Build fixed part of header 80336379Ssklower */ 80436379Ssklower pdu->esis_proto_id = ISO9542_ESIS; 80536379Ssklower pdu->esis_vers = ESIS_VERSION; 80636379Ssklower pdu->esis_type = type; 80736379Ssklower HTOC(pdu->esis_ht_msb, pdu->esis_ht_lsb, ht); 80836379Ssklower 80936379Ssklower if (type == ESIS_ESH) { 81036379Ssklower cp++; 81136379Ssklower len++; 81236379Ssklower } 81336379Ssklower 81437469Ssklower m->m_len = len; 81543332Ssklower if (isoa) { 81643332Ssklower /* 81743332Ssklower * Here we are responding to a clnp packet sent to an NSAP 81843332Ssklower * that is ours which was sent to the MAC addr all_es's. 81943332Ssklower * It is possible that we did not specifically advertise this 82043332Ssklower * NSAP, even though it is ours, so we will respond 82143332Ssklower * directly to the sender that we are here. If we do have 82243332Ssklower * multiple NSEL's we'll tack them on so he can compress them out. 82343332Ssklower */ 82443332Ssklower (void) esis_insert_addr(&cp, &len, isoa, m, 0); 82543332Ssklower naddr = 1; 82643332Ssklower } 82743332Ssklower for (ia = iso_ifaddr; ia; ia = ia->ia_next) { 82843332Ssklower int nsellen = (type == ESIS_ISH ? ia->ia_addr.siso_tlen : 0); 82943332Ssklower int n = ia->ia_addr.siso_nlen; 83043332Ssklower register struct iso_ifaddr *ia2; 83143332Ssklower 83243332Ssklower if (type == ESIS_ISH && naddr > 0) 83343332Ssklower break; 83443332Ssklower for (ia2 = iso_ifaddr; ia2 != ia; ia2 = ia2->ia_next) 83543332Ssklower if (Bcmp(ia->ia_addr.siso_data, ia2->ia_addr.siso_data, n) == 0) 83643332Ssklower break; 83743332Ssklower if (ia2 != ia) 83843332Ssklower continue; /* Means we have previously copied this nsap */ 83943332Ssklower if (isoa && Bcmp(ia->ia_addr.siso_data, isoa->isoa_genaddr, n) == 0) { 84043332Ssklower isoa = 0; 84143332Ssklower continue; /* Ditto */ 84236379Ssklower } 84343332Ssklower IFDEBUG(D_ESISOUTPUT) 84443332Ssklower printf("esis_shoutput: adding NSAP %s\n", 84543332Ssklower clnp_iso_addrp(&ia->ia_addr.siso_addr)); 84643332Ssklower ENDDEBUG 84743332Ssklower if (!esis_insert_addr(&cp, &len, 84843332Ssklower &ia->ia_addr.siso_addr, m, nsellen)) { 84943332Ssklower EXTEND_PACKET(m, m0, cp); 85043332Ssklower (void) esis_insert_addr(&cp, &len, &ia->ia_addr.siso_addr, m, 85143332Ssklower nsellen); 85243332Ssklower } 85343332Ssklower naddr++; 85436379Ssklower } 85536379Ssklower 85636379Ssklower if (type == ESIS_ESH) 85736379Ssklower *naddrp = naddr; 85836379Ssklower 85937469Ssklower m0->m_pkthdr.len = len; 86037469Ssklower pdu->esis_hdr_len = len; 86136379Ssklower iso_gen_csum(m0, ESIS_CKSUM_OFF, (int)pdu->esis_hdr_len); 86236379Ssklower 86337469Ssklower bzero((caddr_t)&siso, sizeof(siso)); 86436379Ssklower siso.siso_family = AF_ISO; 86537469Ssklower siso.siso_data[0] = AFI_SNA; 86637469Ssklower siso.siso_nlen = sn_len + 1; 86737469Ssklower bcopy(sn_addr, siso.siso_data + 1, (unsigned)sn_len); 86840775Ssklower (ifp->if_output)(ifp, m0, &siso, 0); 86936379Ssklower } 87036379Ssklower 87136379Ssklower /* 87243421Ssklower * FUNCTION: isis_input 87343421Ssklower * 87443421Ssklower * PURPOSE: Process an incoming isis packet 87543421Ssklower * 87643421Ssklower * RETURNS: nothing 87743421Ssklower * 87843421Ssklower * SIDE EFFECTS: 87943421Ssklower * 88043421Ssklower * NOTES: 88143421Ssklower */ 88243421Ssklower isis_input(m0, shp) 88343421Ssklower struct mbuf *m0; /* ptr to first mbuf of pkt */ 88443421Ssklower struct snpa_hdr *shp; /* subnetwork header */ 88543421Ssklower { 88643421Ssklower register int type; 88743421Ssklower struct rawcb *rp; 88843421Ssklower struct ifnet *ifp = shp->snh_ifp; 88943421Ssklower struct sockbuf *sb = 0; 89043421Ssklower char workbuf[16]; 89143421Ssklower struct mbuf *mm; 89243421Ssklower 89343421Ssklower IFDEBUG(D_ISISINPUT) 89443421Ssklower int i; 89543421Ssklower 89643421Ssklower printf("isis_input: pkt on ifp x%x (%s%d): from:", ifp, 89743421Ssklower ifp->if_name, ifp->if_unit); 89843421Ssklower for (i=0; i<6; i++) 89943421Ssklower printf("%x%c", shp->snh_shost[i]&0xff, (i<5) ? ':' : ' '); 90043421Ssklower printf(" to:"); 90143421Ssklower for (i=0; i<6; i++) 90243421Ssklower printf("%x%c", shp->snh_dhost[i]&0xff, (i<5) ? ':' : ' '); 90343421Ssklower printf("\n"); 90443421Ssklower ENDDEBUG 90543421Ssklower esis_dl.sdl_alen = ifp->if_addrlen; 90643421Ssklower esis_dl.sdl_index = ifp->if_index; 90743421Ssklower bcopy(shp->snh_shost, (caddr_t)esis_dl.sdl_data, esis_dl.sdl_alen); 90843421Ssklower for (rp = esis_pcb.rcb_next; rp != &esis_pcb; rp = rp->rcb_next) { 90943421Ssklower if (sb == 0) { 91043421Ssklower sb = &rp->rcb_socket->so_rcv; 91143421Ssklower continue; 91243421Ssklower } 91343421Ssklower if (mm = m_copy(m0, 0, M_COPYALL)) { /*can't block at interrupt level */ 91443421Ssklower if (sbappendaddr(&rp->rcb_socket->so_rcv, 91543421Ssklower &esis_dl, mm, (struct mbuf *)0) != 0) 91643421Ssklower sorwakeup(rp->rcb_socket); 91743421Ssklower else { 91843421Ssklower IFDEBUG(D_ISISINPUT) 91943421Ssklower printf("Error in sbappenaddr, mm = 0x%x\n", mm); 92043421Ssklower ENDDEBUG 92143421Ssklower m_freem(mm); 92243421Ssklower } 92343421Ssklower } 92443421Ssklower } 92543421Ssklower if (sb) { 92643421Ssklower if (sbappendaddr(&rp->rcb_socket->so_rcv, 92743421Ssklower &esis_dl, mm, (struct mbuf *)0) != 0) 92843421Ssklower sorwakeup(rp->rcb_socket); 92943421Ssklower else 93043421Ssklower m_freem(m0); 93143421Ssklower } 93243421Ssklower } 93343421Ssklower 93443421Ssklower isis_output(sdl, m) 93543421Ssklower register struct sockaddr_dl *sdl; 93643421Ssklower struct mbuf *m; 93743421Ssklower { 93843421Ssklower register struct ifnet *ifp; 93943421Ssklower struct ifaddr *ifa, *ifa_ifwithnet(); 94043421Ssklower struct sockaddr_iso siso; 94143421Ssklower int error = 0; 94243421Ssklower unsigned sn_len; 94343421Ssklower 94443421Ssklower ifa = ifa_ifwithnet(sdl); /* extract ifp from sockaddr_dl */ 94543421Ssklower if (ifa == 0) { 94643421Ssklower IFDEBUG(D_ISISOUTPUT) 94743421Ssklower printf("isis_output: interface not found\n"); 94843421Ssklower ENDDEBUG 94943421Ssklower error = EINVAL; 95043421Ssklower goto release; 95143421Ssklower } 95243421Ssklower ifp = ifa->ifa_ifp; 95343421Ssklower sn_len = ifp->if_addrlen; 95443421Ssklower IFDEBUG(D_ISISOUTPUT) 95543421Ssklower u_char *cp = (u_char *)LLADDR(sdl), *cplim = cp + sn_len; 95643421Ssklower printf("isis_output: ifp 0x%x (%s%d), to: ", 95743421Ssklower ifp, ifp->if_name, ifp->if_unit); 95843421Ssklower while (cp < cplim) { 95943421Ssklower printf("%x", *cp++); 96043421Ssklower printf("%c", (cp < cplim) ? ':' : ' '); 96143421Ssklower } 96243421Ssklower printf("\n"); 96343421Ssklower ENDDEBUG 96443421Ssklower bzero((caddr_t)&siso, sizeof(siso)); 96543421Ssklower siso.siso_family = AF_ISO; /* This convention may be useful for X.25 */ 96643421Ssklower siso.siso_data[0] = AFI_SNA; 96743421Ssklower siso.siso_nlen = sn_len + 1; 96843421Ssklower bcopy(LLADDR(sdl), siso.siso_data + 1, sn_len); 96943421Ssklower error = (ifp->if_output)(ifp, m, (struct sockaddr *)&siso, 0); 97043421Ssklower if (error) { 97143421Ssklower IFDEBUG(D_ISISOUTPUT) 97243421Ssklower printf("isis_output: error from ether_output is %d\n", error); 97343421Ssklower ENDDEBUG 97443421Ssklower } 97543421Ssklower return (error); 97643421Ssklower 97743421Ssklower release: 97843421Ssklower if (m != NULL) 97943421Ssklower m_freem(m); 98043421Ssklower return(error); 98143421Ssklower } 98243421Ssklower 98343421Ssklower 98443421Ssklower /* 98536379Ssklower * FUNCTION: esis_ctlinput 98636379Ssklower * 98736379Ssklower * PURPOSE: Handle the PRC_IFDOWN transition 98836379Ssklower * 98936379Ssklower * RETURNS: nothing 99036379Ssklower * 99136379Ssklower * SIDE EFFECTS: 99236379Ssklower * 99336379Ssklower * NOTES: Calls snpac_flush for interface specified. 99436379Ssklower * The loop through iso_ifaddr is stupid because 99536379Ssklower * back in if_down, we knew the ifp... 99636379Ssklower */ 99736379Ssklower esis_ctlinput(req, siso) 99836379Ssklower int req; /* request: we handle only PRC_IFDOWN */ 99936379Ssklower struct sockaddr_iso *siso; /* address of ifp */ 100036379Ssklower { 100136379Ssklower register struct iso_ifaddr *ia; /* scan through interface addresses */ 100236379Ssklower 100337469Ssklower if (req == PRC_IFDOWN) 100437469Ssklower for (ia = iso_ifaddr; ia; ia = ia->ia_next) { 100537469Ssklower if (iso_addrmatch(IA_SIS(ia), siso)) 100637469Ssklower snpac_flushifp(ia->ia_ifp); 100737469Ssklower } 100836379Ssklower } 100936379Ssklower 101036379Ssklower #endif ISO 1011