1af57ed9fSAtsushi Murai /* 2af57ed9fSAtsushi Murai * PPP High Level Link Control (HDLC) Module 3af57ed9fSAtsushi Murai * 4af57ed9fSAtsushi Murai * Written by Toshiharu OHNO (tony-o@iij.ad.jp) 5af57ed9fSAtsushi Murai * 6af57ed9fSAtsushi Murai * Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd. 7af57ed9fSAtsushi Murai * 8af57ed9fSAtsushi Murai * Redistribution and use in source and binary forms are permitted 9af57ed9fSAtsushi Murai * provided that the above copyright notice and this paragraph are 10af57ed9fSAtsushi Murai * duplicated in all such forms and that any documentation, 11af57ed9fSAtsushi Murai * advertising materials, and other materials related to such 12af57ed9fSAtsushi Murai * distribution and use acknowledge that the software was developed 13af57ed9fSAtsushi Murai * by the Internet Initiative Japan, Inc. The name of the 14af57ed9fSAtsushi Murai * IIJ may not be used to endorse or promote products derived 15af57ed9fSAtsushi Murai * from this software without specific prior written permission. 16af57ed9fSAtsushi Murai * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 17af57ed9fSAtsushi Murai * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 18af57ed9fSAtsushi Murai * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. 19af57ed9fSAtsushi Murai * 20e3044845SBrian Somers * $Id: hdlc.c,v 1.40 1999/03/29 08:21:26 brian Exp $ 21af57ed9fSAtsushi Murai * 22af57ed9fSAtsushi Murai * TODO: 23af57ed9fSAtsushi Murai */ 24972a1bcfSBrian Somers #include <sys/param.h> 2575240ed1SBrian Somers #include <netinet/in.h> 26eaa4df37SBrian Somers #include <netinet/in_systm.h> 27eaa4df37SBrian Somers #include <netinet/ip.h> 281fa665f5SBrian Somers #include <sys/un.h> 2975240ed1SBrian Somers 3075240ed1SBrian Somers #include <stdio.h> 3175240ed1SBrian Somers #include <string.h> 3275240ed1SBrian Somers #include <termios.h> 3375240ed1SBrian Somers 34c9e11a11SBrian Somers #include "defs.h" 35b6e82f33SBrian Somers #include "command.h" 3675240ed1SBrian Somers #include "mbuf.h" 3775240ed1SBrian Somers #include "log.h" 3875240ed1SBrian Somers #include "timer.h" 39af57ed9fSAtsushi Murai #include "fsm.h" 40879ed6faSBrian Somers #include "lqr.h" 41af57ed9fSAtsushi Murai #include "hdlc.h" 42af57ed9fSAtsushi Murai #include "lcpproto.h" 4329e275ceSBrian Somers #include "iplist.h" 4429e275ceSBrian Somers #include "throughput.h" 45eaa4df37SBrian Somers #include "slcompress.h" 466eaa6ac5SBrian Somers #include "ipcp.h" 476eaa6ac5SBrian Somers #include "ip.h" 486eaa6ac5SBrian Somers #include "vjcomp.h" 49e2ebb036SBrian Somers #include "auth.h" 506eaa6ac5SBrian Somers #include "pap.h" 51af57ed9fSAtsushi Murai #include "lcp.h" 52b6e82f33SBrian Somers #include "async.h" 53ed6a16c1SPoul-Henning Kamp #include "ccp.h" 548c07a7b2SBrian Somers #include "link.h" 5542d4d396SBrian Somers #include "descriptor.h" 5658330d7bSBrian Somers #include "chap.h" 5763b73463SBrian Somers #include "physical.h" 5885b542cfSBrian Somers #include "prompt.h" 5963258dccSBrian Somers #include "chat.h" 603b0f8d2eSBrian Somers #include "mp.h" 6192b09558SBrian Somers #include "cbcp.h" 6263258dccSBrian Somers #include "datalink.h" 635ca5389aSBrian Somers #include "filter.h" 64972a1bcfSBrian Somers #ifndef NORADIUS 65972a1bcfSBrian Somers #include "radius.h" 66972a1bcfSBrian Somers #endif 67503a7782SBrian Somers #include "bundle.h" 68af57ed9fSAtsushi Murai 693a2e4f62SBrian Somers static u_int16_t const fcstab[256] = { 70af57ed9fSAtsushi Murai /* 00 */ 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 71af57ed9fSAtsushi Murai /* 08 */ 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 72af57ed9fSAtsushi Murai /* 10 */ 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 73af57ed9fSAtsushi Murai /* 18 */ 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 74af57ed9fSAtsushi Murai /* 20 */ 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 75af57ed9fSAtsushi Murai /* 28 */ 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 76af57ed9fSAtsushi Murai /* 30 */ 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 77af57ed9fSAtsushi Murai /* 38 */ 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 78af57ed9fSAtsushi Murai /* 40 */ 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 79af57ed9fSAtsushi Murai /* 48 */ 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 80af57ed9fSAtsushi Murai /* 50 */ 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, 81af57ed9fSAtsushi Murai /* 58 */ 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, 82af57ed9fSAtsushi Murai /* 60 */ 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 83af57ed9fSAtsushi Murai /* 68 */ 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 84af57ed9fSAtsushi Murai /* 70 */ 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 85af57ed9fSAtsushi Murai /* 78 */ 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 86af57ed9fSAtsushi Murai /* 80 */ 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 87af57ed9fSAtsushi Murai /* 88 */ 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, 88af57ed9fSAtsushi Murai /* 90 */ 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 89af57ed9fSAtsushi Murai /* 98 */ 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 90af57ed9fSAtsushi Murai /* a0 */ 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, 91af57ed9fSAtsushi Murai /* a8 */ 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 92af57ed9fSAtsushi Murai /* b0 */ 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, 93af57ed9fSAtsushi Murai /* b8 */ 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 94af57ed9fSAtsushi Murai /* c0 */ 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 95af57ed9fSAtsushi Murai /* c8 */ 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 96af57ed9fSAtsushi Murai /* d0 */ 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 97af57ed9fSAtsushi Murai /* d8 */ 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 98af57ed9fSAtsushi Murai /* e0 */ 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 99af57ed9fSAtsushi Murai /* e8 */ 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, 100af57ed9fSAtsushi Murai /* f0 */ 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 101af57ed9fSAtsushi Murai /* f8 */ 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 102af57ed9fSAtsushi Murai }; 103af57ed9fSAtsushi Murai 104af57ed9fSAtsushi Murai void 105643f4904SBrian Somers hdlc_Init(struct hdlc *hdlc, struct lcp *lcp) 106af57ed9fSAtsushi Murai { 10763258dccSBrian Somers memset(hdlc, '\0', sizeof(struct hdlc)); 108643f4904SBrian Somers hdlc->lqm.owner = lcp; 109af57ed9fSAtsushi Murai } 110af57ed9fSAtsushi Murai 111af57ed9fSAtsushi Murai /* 112af57ed9fSAtsushi Murai * HDLC FCS computation. Read RFC 1171 Appendix B and CCITT X.25 section 113af57ed9fSAtsushi Murai * 2.27 for further details. 114af57ed9fSAtsushi Murai */ 115e53374eaSPoul-Henning Kamp inline u_short 116dd7e2610SBrian Somers hdlc_Fcs(u_short fcs, u_char * cp, int len) 117af57ed9fSAtsushi Murai { 118af57ed9fSAtsushi Murai while (len--) 119af57ed9fSAtsushi Murai fcs = (fcs >> 8) ^ fcstab[(fcs ^ *cp++) & 0xff]; 120af57ed9fSAtsushi Murai return (fcs); 121af57ed9fSAtsushi Murai } 122af57ed9fSAtsushi Murai 123aa8e0519SBrian Somers static inline u_short 1240053cc58SBrian Somers HdlcFcsBuf(u_short fcs, struct mbuf *m) 1250053cc58SBrian Somers { 1260053cc58SBrian Somers int len; 1270053cc58SBrian Somers u_char *pos, *end; 1280053cc58SBrian Somers 129dd7e2610SBrian Somers len = mbuf_Length(m); 1300053cc58SBrian Somers pos = MBUF_CTOP(m); 1310053cc58SBrian Somers end = pos + m->cnt; 1320053cc58SBrian Somers while (len--) { 1330053cc58SBrian Somers fcs = (fcs >> 8) ^ fcstab[(fcs ^ *pos++) & 0xff]; 1340053cc58SBrian Somers if (pos == end && len) { 1350053cc58SBrian Somers m = m->next; 1360053cc58SBrian Somers pos = MBUF_CTOP(m); 1370053cc58SBrian Somers end = pos + m->cnt; 1380053cc58SBrian Somers } 1390053cc58SBrian Somers } 1400053cc58SBrian Somers return (fcs); 1410053cc58SBrian Somers } 1420053cc58SBrian Somers 143af57ed9fSAtsushi Murai void 144dd7e2610SBrian Somers hdlc_Output(struct link *l, int pri, u_short proto, struct mbuf *bp) 145af57ed9fSAtsushi Murai { 1468c07a7b2SBrian Somers struct physical *p = link2physical(l); 147af57ed9fSAtsushi Murai struct mbuf *mhp, *mfcs; 148af57ed9fSAtsushi Murai u_char *cp; 149af57ed9fSAtsushi Murai u_short fcs; 150af57ed9fSAtsushi Murai 151dd7e2610SBrian Somers if (!p || physical_IsSync(p)) 152aa8e0519SBrian Somers mfcs = NULL; 15353c9f6c0SAtsushi Murai else 154dd7e2610SBrian Somers mfcs = mbuf_Alloc(2, MB_HDLCOUT); 1550053cc58SBrian Somers 156dd7e2610SBrian Somers mhp = mbuf_Alloc(4, MB_HDLCOUT); 157af57ed9fSAtsushi Murai mhp->cnt = 0; 158af57ed9fSAtsushi Murai cp = MBUF_CTOP(mhp); 159673903ecSBrian Somers if (p && (proto == PROTO_LCP || l->lcp.his_acfcomp == 0)) { 160af57ed9fSAtsushi Murai *cp++ = HDLC_ADDR; 161af57ed9fSAtsushi Murai *cp++ = HDLC_UI; 162af57ed9fSAtsushi Murai mhp->cnt += 2; 163af57ed9fSAtsushi Murai } 164944f7098SBrian Somers 165af57ed9fSAtsushi Murai /* 166af57ed9fSAtsushi Murai * If possible, compress protocol field. 167af57ed9fSAtsushi Murai */ 168673903ecSBrian Somers if (l->lcp.his_protocomp && (proto & 0xff00) == 0) { 169af57ed9fSAtsushi Murai *cp++ = proto; 170af57ed9fSAtsushi Murai mhp->cnt++; 171af57ed9fSAtsushi Murai } else { 172af57ed9fSAtsushi Murai *cp++ = proto >> 8; 173af57ed9fSAtsushi Murai *cp = proto & 0377; 174af57ed9fSAtsushi Murai mhp->cnt += 2; 175af57ed9fSAtsushi Murai } 1768c07a7b2SBrian Somers 177aad80d9fSBrian Somers mhp->next = bp = mbuf_Contiguous(bp); 178673903ecSBrian Somers 179673903ecSBrian Somers if (!p) { 180673903ecSBrian Somers /* 181673903ecSBrian Somers * This is where we multiplex the data over our available physical 182673903ecSBrian Somers * links. We don't frame our logical link data. Instead we wait 183673903ecSBrian Somers * for the logical link implementation to chop our data up and pile 184673903ecSBrian Somers * it into the physical links by re-calling this function with the 185673903ecSBrian Somers * encapsulated fragments. 186673903ecSBrian Somers */ 187673903ecSBrian Somers link_Output(l, pri, mhp); 188673903ecSBrian Somers return; 189673903ecSBrian Somers } 190673903ecSBrian Somers 191aad80d9fSBrian Somers bp->next = mfcs; /* Tack mfcs onto the end */ 192af57ed9fSAtsushi Murai 193dd7e2610SBrian Somers p->hdlc.lqm.OutOctets += mbuf_Length(mhp) + 1; 194879ed6faSBrian Somers p->hdlc.lqm.OutPackets++; 195af57ed9fSAtsushi Murai 196af57ed9fSAtsushi Murai if (proto == PROTO_LQR) { 197879ed6faSBrian Somers /* Overwrite the entire packet */ 198879ed6faSBrian Somers struct lqrdata lqr; 199879ed6faSBrian Somers 2003b0f8d2eSBrian Somers lqr.MagicNumber = p->link.lcp.want_magic; 201879ed6faSBrian Somers lqr.LastOutLQRs = p->hdlc.lqm.lqr.peer.PeerOutLQRs; 202879ed6faSBrian Somers lqr.LastOutPackets = p->hdlc.lqm.lqr.peer.PeerOutPackets; 203879ed6faSBrian Somers lqr.LastOutOctets = p->hdlc.lqm.lqr.peer.PeerOutOctets; 204879ed6faSBrian Somers lqr.PeerInLQRs = p->hdlc.lqm.lqr.SaveInLQRs; 205879ed6faSBrian Somers lqr.PeerInPackets = p->hdlc.lqm.SaveInPackets; 206879ed6faSBrian Somers lqr.PeerInDiscards = p->hdlc.lqm.SaveInDiscards; 207879ed6faSBrian Somers lqr.PeerInErrors = p->hdlc.lqm.SaveInErrors; 208879ed6faSBrian Somers lqr.PeerInOctets = p->hdlc.lqm.SaveInOctets; 209879ed6faSBrian Somers lqr.PeerOutPackets = p->hdlc.lqm.OutPackets; 210879ed6faSBrian Somers lqr.PeerOutOctets = p->hdlc.lqm.OutOctets; 211879ed6faSBrian Somers if (p->hdlc.lqm.lqr.peer.LastOutLQRs == p->hdlc.lqm.lqr.OutLQRs) { 212f830032fSBrian Somers /* 213f830032fSBrian Somers * only increment if it's the first time or we've got a reply 214f830032fSBrian Somers * from the last one 215f830032fSBrian Somers */ 216879ed6faSBrian Somers lqr.PeerOutLQRs = ++p->hdlc.lqm.lqr.OutLQRs; 217dd7e2610SBrian Somers lqr_Dump(l->name, "Output", &lqr); 218f830032fSBrian Somers } else { 219879ed6faSBrian Somers lqr.PeerOutLQRs = p->hdlc.lqm.lqr.OutLQRs; 220dd7e2610SBrian Somers lqr_Dump(l->name, "Output (again)", &lqr); 221f830032fSBrian Somers } 222dd7e2610SBrian Somers lqr_ChangeOrder(&lqr, (struct lqrdata *)MBUF_CTOP(bp)); 223af57ed9fSAtsushi Murai } 2248c07a7b2SBrian Somers 2258c07a7b2SBrian Somers if (mfcs) { 22698baf7c8SBrian Somers mfcs->cnt = 0; 22798baf7c8SBrian Somers fcs = HdlcFcsBuf(INITFCS, mhp); 228af57ed9fSAtsushi Murai fcs = ~fcs; 229af57ed9fSAtsushi Murai cp = MBUF_CTOP(mfcs); 230af57ed9fSAtsushi Murai *cp++ = fcs & 0377; /* Low byte first!! */ 231af57ed9fSAtsushi Murai *cp++ = fcs >> 8; 23298baf7c8SBrian Somers mfcs->cnt = 2; 23353c9f6c0SAtsushi Murai } 2340053cc58SBrian Somers 235dd7e2610SBrian Somers log_DumpBp(LogHDLC, "hdlc_Output", mhp); 2360053cc58SBrian Somers 2378c07a7b2SBrian Somers link_ProtocolRecord(l, proto, PROTO_OUT); 238dd7e2610SBrian Somers log_Printf(LogDEBUG, "hdlc_Output: proto = 0x%04x\n", proto); 2391ae349f5Scvs2svn 240dd7e2610SBrian Somers if (physical_IsSync(p)) 2418c07a7b2SBrian Somers link_Output(l, pri, mhp); /* Send it raw */ 24253c9f6c0SAtsushi Murai else 2436140ba11SBrian Somers async_Output(pri, mhp, proto, p); 244af57ed9fSAtsushi Murai } 245af57ed9fSAtsushi Murai 246774326edSBrian Somers /* Check out the latest ``Assigned numbers'' rfc (rfc1700.txt) */ 247774326edSBrian Somers static struct { 248774326edSBrian Somers u_short from; 249774326edSBrian Somers u_short to; 250774326edSBrian Somers const char *name; 251774326edSBrian Somers } protocols[] = { 252774326edSBrian Somers { 0x0001, 0x0001, "Padding Protocol" }, 253774326edSBrian Somers { 0x0003, 0x001f, "reserved (transparency inefficient)" }, 254774326edSBrian Somers { 0x0021, 0x0021, "Internet Protocol" }, 255774326edSBrian Somers { 0x0023, 0x0023, "OSI Network Layer" }, 256774326edSBrian Somers { 0x0025, 0x0025, "Xerox NS IDP" }, 257774326edSBrian Somers { 0x0027, 0x0027, "DECnet Phase IV" }, 258774326edSBrian Somers { 0x0029, 0x0029, "Appletalk" }, 259774326edSBrian Somers { 0x002b, 0x002b, "Novell IPX" }, 260774326edSBrian Somers { 0x002d, 0x002d, "Van Jacobson Compressed TCP/IP" }, 261774326edSBrian Somers { 0x002f, 0x002f, "Van Jacobson Uncompressed TCP/IP" }, 262774326edSBrian Somers { 0x0031, 0x0031, "Bridging PDU" }, 263774326edSBrian Somers { 0x0033, 0x0033, "Stream Protocol (ST-II)" }, 264774326edSBrian Somers { 0x0035, 0x0035, "Banyan Vines" }, 265774326edSBrian Somers { 0x0037, 0x0037, "reserved (until 1993)" }, 266774326edSBrian Somers { 0x0039, 0x0039, "AppleTalk EDDP" }, 267774326edSBrian Somers { 0x003b, 0x003b, "AppleTalk SmartBuffered" }, 268774326edSBrian Somers { 0x003d, 0x003d, "Multi-Link" }, 269774326edSBrian Somers { 0x003f, 0x003f, "NETBIOS Framing" }, 270774326edSBrian Somers { 0x0041, 0x0041, "Cisco Systems" }, 271774326edSBrian Somers { 0x0043, 0x0043, "Ascom Timeplex" }, 272774326edSBrian Somers { 0x0045, 0x0045, "Fujitsu Link Backup and Load Balancing (LBLB)" }, 273774326edSBrian Somers { 0x0047, 0x0047, "DCA Remote Lan" }, 274774326edSBrian Somers { 0x0049, 0x0049, "Serial Data Transport Protocol (PPP-SDTP)" }, 275774326edSBrian Somers { 0x004b, 0x004b, "SNA over 802.2" }, 276774326edSBrian Somers { 0x004d, 0x004d, "SNA" }, 277774326edSBrian Somers { 0x004f, 0x004f, "IP6 Header Compression" }, 278774326edSBrian Somers { 0x0051, 0x0051, "KNX Bridging Data" }, 279774326edSBrian Somers { 0x0053, 0x0053, "Encryption" }, 280774326edSBrian Somers { 0x0055, 0x0055, "Individual Link Encryption" }, 281774326edSBrian Somers { 0x006f, 0x006f, "Stampede Bridging" }, 282774326edSBrian Somers { 0x0071, 0x0071, "BAP Bandwidth Allocation Protocol" }, 283774326edSBrian Somers { 0x0073, 0x0073, "MP+ Protocol" }, 284774326edSBrian Somers { 0x007d, 0x007d, "reserved (Control Escape)" }, 285774326edSBrian Somers { 0x007f, 0x007f, "reserved (compression inefficient)" }, 286774326edSBrian Somers { 0x00cf, 0x00cf, "reserved (PPP NLPID)" }, 287774326edSBrian Somers { 0x00fb, 0x00fb, "compression on single link in multilink group" }, 288774326edSBrian Somers { 0x00fd, 0x00fd, "1st choice compression" }, 289774326edSBrian Somers { 0x00ff, 0x00ff, "reserved (compression inefficient)" }, 290774326edSBrian Somers { 0x0200, 0x02ff, "(compression inefficient)" }, 291774326edSBrian Somers { 0x0201, 0x0201, "802.1d Hello Packets" }, 292774326edSBrian Somers { 0x0203, 0x0203, "IBM Source Routing BPDU" }, 293774326edSBrian Somers { 0x0205, 0x0205, "DEC LANBridge100 Spanning Tree" }, 294774326edSBrian Somers { 0x0207, 0x0207, "Cisco Discovery Protocol" }, 295774326edSBrian Somers { 0x0209, 0x0209, "Netcs Twin Routing" }, 296774326edSBrian Somers { 0x0231, 0x0231, "Luxcom" }, 297774326edSBrian Somers { 0x0233, 0x0233, "Sigma Network Systems" }, 298774326edSBrian Somers { 0x0235, 0x0235, "Apple Client Server Protocol" }, 299774326edSBrian Somers { 0x1e00, 0x1eff, "(compression inefficient)" }, 300774326edSBrian Somers { 0x4001, 0x4001, "Cray Communications Control Protocol" }, 301774326edSBrian Somers { 0x4003, 0x4003, "CDPD Mobile Network Registration Protocol" }, 302774326edSBrian Somers { 0x4021, 0x4021, "Stacker LZS" }, 303774326edSBrian Somers { 0x8001, 0x801f, "Not Used - reserved" }, 304774326edSBrian Somers { 0x8021, 0x8021, "Internet Protocol Control Protocol" }, 305774326edSBrian Somers { 0x8023, 0x8023, "OSI Network Layer Control Protocol" }, 306774326edSBrian Somers { 0x8025, 0x8025, "Xerox NS IDP Control Protocol" }, 307774326edSBrian Somers { 0x8027, 0x8027, "DECnet Phase IV Control Protocol" }, 308774326edSBrian Somers { 0x8029, 0x8029, "Appletalk Control Protocol" }, 309774326edSBrian Somers { 0x802b, 0x802b, "Novell IPX Control Protocol" }, 310774326edSBrian Somers { 0x802d, 0x802d, "reserved" }, 311774326edSBrian Somers { 0x802f, 0x802f, "reserved" }, 312774326edSBrian Somers { 0x8031, 0x8031, "Bridging NCP" }, 313774326edSBrian Somers { 0x8033, 0x8033, "Stream Protocol Control Protocol" }, 314774326edSBrian Somers { 0x8035, 0x8035, "Banyan Vines Control Protocol" }, 315774326edSBrian Somers { 0x8037, 0x8037, "reserved till 1993" }, 316774326edSBrian Somers { 0x8039, 0x8039, "reserved" }, 317774326edSBrian Somers { 0x803b, 0x803b, "reserved" }, 318774326edSBrian Somers { 0x803d, 0x803d, "Multi-Link Control Protocol" }, 319774326edSBrian Somers { 0x803f, 0x803f, "NETBIOS Framing Control Protocol" }, 320774326edSBrian Somers { 0x8041, 0x8041, "Cisco Systems Control Protocol" }, 321774326edSBrian Somers { 0x8043, 0x8043, "Ascom Timeplex" }, 322774326edSBrian Somers { 0x8045, 0x8045, "Fujitsu LBLB Control Protocol" }, 323774326edSBrian Somers { 0x8047, 0x8047, "DCA Remote Lan Network Control Protocol (RLNCP)" }, 324774326edSBrian Somers { 0x8049, 0x8049, "Serial Data Control Protocol (PPP-SDCP)" }, 325774326edSBrian Somers { 0x804b, 0x804b, "SNA over 802.2 Control Protocol" }, 326774326edSBrian Somers { 0x804d, 0x804d, "SNA Control Protocol" }, 327774326edSBrian Somers { 0x804f, 0x804f, "IP6 Header Compression Control Protocol" }, 328774326edSBrian Somers { 0x8051, 0x8051, "KNX Bridging Control Protocol" }, 329774326edSBrian Somers { 0x8053, 0x8053, "Encryption Control Protocol" }, 330774326edSBrian Somers { 0x8055, 0x8055, "Individual Link Encryption Control Protocol" }, 331774326edSBrian Somers { 0x806f, 0x806f, "Stampede Bridging Control Protocol" }, 332774326edSBrian Somers { 0x8073, 0x8073, "MP+ Control Protocol" }, 333774326edSBrian Somers { 0x8071, 0x8071, "BACP Bandwidth Allocation Control Protocol" }, 334774326edSBrian Somers { 0x807d, 0x807d, "Not Used - reserved" }, 335774326edSBrian Somers { 0x80cf, 0x80cf, "Not Used - reserved" }, 336774326edSBrian Somers { 0x80fb, 0x80fb, "compression on single link in multilink group control" }, 337774326edSBrian Somers { 0x80fd, 0x80fd, "Compression Control Protocol" }, 338774326edSBrian Somers { 0x80ff, 0x80ff, "Not Used - reserved" }, 339774326edSBrian Somers { 0x8207, 0x8207, "Cisco Discovery Protocol Control" }, 340774326edSBrian Somers { 0x8209, 0x8209, "Netcs Twin Routing" }, 341774326edSBrian Somers { 0x8235, 0x8235, "Apple Client Server Protocol Control" }, 342774326edSBrian Somers { 0xc021, 0xc021, "Link Control Protocol" }, 343774326edSBrian Somers { 0xc023, 0xc023, "Password Authentication Protocol" }, 344774326edSBrian Somers { 0xc025, 0xc025, "Link Quality Report" }, 345774326edSBrian Somers { 0xc027, 0xc027, "Shiva Password Authentication Protocol" }, 346774326edSBrian Somers { 0xc029, 0xc029, "CallBack Control Protocol (CBCP)" }, 347774326edSBrian Somers { 0xc081, 0xc081, "Container Control Protocol" }, 348774326edSBrian Somers { 0xc223, 0xc223, "Challenge Handshake Authentication Protocol" }, 349774326edSBrian Somers { 0xc225, 0xc225, "RSA Authentication Protocol" }, 350774326edSBrian Somers { 0xc227, 0xc227, "Extensible Authentication Protocol" }, 351774326edSBrian Somers { 0xc26f, 0xc26f, "Stampede Bridging Authorization Protocol" }, 352774326edSBrian Somers { 0xc281, 0xc281, "Proprietary Authentication Protocol" }, 353774326edSBrian Somers { 0xc283, 0xc283, "Proprietary Authentication Protocol" }, 354774326edSBrian Somers { 0xc481, 0xc481, "Proprietary Node ID Authentication Protocol" } 355774326edSBrian Somers }; 356774326edSBrian Somers 35770ee81ffSBrian Somers #define NPROTOCOLS (sizeof protocols/sizeof protocols[0]) 358774326edSBrian Somers 35963258dccSBrian Somers const char * 36063258dccSBrian Somers hdlc_Protocol2Nam(u_short proto) 361774326edSBrian Somers { 362774326edSBrian Somers int f; 363774326edSBrian Somers 364774326edSBrian Somers for (f = 0; f < NPROTOCOLS; f++) 365774326edSBrian Somers if (proto >= protocols[f].from && proto <= protocols[f].to) 366774326edSBrian Somers return protocols[f].name; 367774326edSBrian Somers else if (proto < protocols[f].from) 368774326edSBrian Somers break; 369774326edSBrian Somers return "unrecognised protocol"; 370774326edSBrian Somers } 371774326edSBrian Somers 3723b0f8d2eSBrian Somers void 3733b0f8d2eSBrian Somers hdlc_DecodePacket(struct bundle *bundle, u_short proto, struct mbuf * bp, 3747a6f8720SBrian Somers struct link *l) 375af57ed9fSAtsushi Murai { 3768c07a7b2SBrian Somers struct physical *p = link2physical(l); 37760e218e4SAtsushi Murai u_char *cp; 378cff2b1c9SBrian Somers const char *type; 37960e218e4SAtsushi Murai 380dd7e2610SBrian Somers log_Printf(LogDEBUG, "DecodePacket: proto = 0x%04x\n", proto); 3810053cc58SBrian Somers 382ee6c193fSBrian Somers /* decompress everything. CCP needs uncompressed data too */ 3833b0f8d2eSBrian Somers if ((bp = ccp_Decompress(&l->ccp, &proto, bp)) == NULL) 3840053cc58SBrian Somers return; 385927145beSBrian Somers 386af57ed9fSAtsushi Murai switch (proto) { 387af57ed9fSAtsushi Murai case PROTO_LCP: 388dd7e2610SBrian Somers lcp_Input(&l->lcp, bp); 389af57ed9fSAtsushi Murai break; 390af57ed9fSAtsushi Murai case PROTO_PAP: 3918c07a7b2SBrian Somers if (p) 392f0cdd9c0SBrian Somers pap_Input(p, bp); 3938c07a7b2SBrian Somers else { 394dd7e2610SBrian Somers log_Printf(LogERROR, "DecodePacket: PAP: Not a physical link !\n"); 395dd7e2610SBrian Somers mbuf_Free(bp); 3968c07a7b2SBrian Somers } 397af57ed9fSAtsushi Murai break; 39892b09558SBrian Somers case PROTO_CBCP: 39992b09558SBrian Somers if (p) 40092b09558SBrian Somers cbcp_Input(p, bp); 40192b09558SBrian Somers else { 40292b09558SBrian Somers log_Printf(LogERROR, "DecodePacket: CBCP: Not a physical link !\n"); 40392b09558SBrian Somers mbuf_Free(bp); 40492b09558SBrian Somers } 40592b09558SBrian Somers break; 406af57ed9fSAtsushi Murai case PROTO_LQR: 407879ed6faSBrian Somers if (p) { 408879ed6faSBrian Somers p->hdlc.lqm.lqr.SaveInLQRs++; 409dd7e2610SBrian Somers lqr_Input(p, bp); 410879ed6faSBrian Somers } else { 411dd7e2610SBrian Somers log_Printf(LogERROR, "DecodePacket: LQR: Not a physical link !\n"); 412dd7e2610SBrian Somers mbuf_Free(bp); 4138c07a7b2SBrian Somers } 414af57ed9fSAtsushi Murai break; 415af57ed9fSAtsushi Murai case PROTO_CHAP: 4168c07a7b2SBrian Somers if (p) 417f0cdd9c0SBrian Somers chap_Input(p, bp); 4188c07a7b2SBrian Somers else { 419dd7e2610SBrian Somers log_Printf(LogERROR, "DecodePacket: CHAP: Not a physical link !\n"); 420dd7e2610SBrian Somers mbuf_Free(bp); 4218c07a7b2SBrian Somers } 422af57ed9fSAtsushi Murai break; 423af57ed9fSAtsushi Murai case PROTO_VJUNCOMP: 424af57ed9fSAtsushi Murai case PROTO_VJCOMP: 425dd7e2610SBrian Somers bp = vj_Input(&bundle->ncp.ipcp, bp, proto); 4268c07a7b2SBrian Somers if (bp == NULL) 42753c9f6c0SAtsushi Murai break; 428af57ed9fSAtsushi Murai /* fall down */ 429af57ed9fSAtsushi Murai case PROTO_IP: 430dd7e2610SBrian Somers ip_Input(bundle, bp); 431af57ed9fSAtsushi Murai break; 432af57ed9fSAtsushi Murai case PROTO_IPCP: 433641684cdSBrian Somers ipcp_Input(&bundle->ncp.ipcp, bundle, bp); 434af57ed9fSAtsushi Murai break; 435af57ed9fSAtsushi Murai case PROTO_CCP: 436dd7e2610SBrian Somers ccp_Input(&l->ccp, bundle, bp); 437af57ed9fSAtsushi Murai break; 4383b0f8d2eSBrian Somers case PROTO_MP: 4393b0f8d2eSBrian Somers if (bundle->ncp.mp.active) { 4403b0f8d2eSBrian Somers if (p) 4413b0f8d2eSBrian Somers mp_Input(&bundle->ncp.mp, bp, p); 4423b0f8d2eSBrian Somers else { 443a33b2ef7SBrian Somers log_Printf(LogWARN, "DecodePacket: Can't do MP inside MP !\n"); 444dd7e2610SBrian Somers mbuf_Free(bp); 4453b0f8d2eSBrian Somers } 4463b0f8d2eSBrian Somers break; 4473b0f8d2eSBrian Somers } 4483b0f8d2eSBrian Somers /* Fall through */ 449af57ed9fSAtsushi Murai default: 450cff2b1c9SBrian Somers switch (proto) { 451cff2b1c9SBrian Somers case PROTO_MP: 452cff2b1c9SBrian Somers case PROTO_COMPD: 453cff2b1c9SBrian Somers case PROTO_ICOMPD: 454cff2b1c9SBrian Somers type = "Unexpected"; 455cff2b1c9SBrian Somers break; 456cff2b1c9SBrian Somers default: 457cff2b1c9SBrian Somers type = "Unknown"; 458cff2b1c9SBrian Somers break; 459cff2b1c9SBrian Somers } 460cff2b1c9SBrian Somers log_Printf(LogPHASE, "%s protocol 0x%04x (%s)\n", type, proto, 461cff2b1c9SBrian Somers hdlc_Protocol2Nam(proto)); 46260e218e4SAtsushi Murai bp->offset -= 2; 46360e218e4SAtsushi Murai bp->cnt += 2; 46460e218e4SAtsushi Murai cp = MBUF_CTOP(bp); 4653b0f8d2eSBrian Somers lcp_SendProtoRej(&l->lcp, cp, bp->cnt); 4663b0f8d2eSBrian Somers if (p) { 467879ed6faSBrian Somers p->hdlc.lqm.SaveInDiscards++; 46863258dccSBrian Somers p->hdlc.stats.unknownproto++; 4693b0f8d2eSBrian Somers } 470dd7e2610SBrian Somers mbuf_Free(bp); 471af57ed9fSAtsushi Murai break; 472af57ed9fSAtsushi Murai } 473af57ed9fSAtsushi Murai } 474af57ed9fSAtsushi Murai 4750a1b5c9dSBrian Somers static int 4760a1b5c9dSBrian Somers hdlc_GetProto(const u_char *cp, u_short *proto) 477af57ed9fSAtsushi Murai { 4780a1b5c9dSBrian Somers *proto = *cp; 4790a1b5c9dSBrian Somers if (!(*proto & 1)) { 4800a1b5c9dSBrian Somers *proto = (*proto << 8) | cp[1]; 4810a1b5c9dSBrian Somers return 2; 482af57ed9fSAtsushi Murai } 4830a1b5c9dSBrian Somers return 1; 484af57ed9fSAtsushi Murai } 485af57ed9fSAtsushi Murai 486af57ed9fSAtsushi Murai void 487dd7e2610SBrian Somers hdlc_Input(struct bundle *bundle, struct mbuf * bp, struct physical *physical) 488af57ed9fSAtsushi Murai { 489af57ed9fSAtsushi Murai u_short fcs, proto; 490af57ed9fSAtsushi Murai u_char *cp, addr, ctrl; 4910a1b5c9dSBrian Somers int n; 492af57ed9fSAtsushi Murai 493dd7e2610SBrian Somers log_DumpBp(LogHDLC, "hdlc_Input:", bp); 494dd7e2610SBrian Somers if (physical_IsSync(physical)) 49553c9f6c0SAtsushi Murai fcs = GOODFCS; 49653c9f6c0SAtsushi Murai else 497dd7e2610SBrian Somers fcs = hdlc_Fcs(INITFCS, MBUF_CTOP(bp), bp->cnt); 498879ed6faSBrian Somers physical->hdlc.lqm.SaveInOctets += bp->cnt + 1; 499af57ed9fSAtsushi Murai 50066f634b6SBrian Somers log_Printf(LogDEBUG, "%s: hdlc_Input: fcs = %04x (%s)\n", 50166f634b6SBrian Somers physical->link.name, fcs, (fcs == GOODFCS) ? "good" : "BAD!"); 502af57ed9fSAtsushi Murai if (fcs != GOODFCS) { 503879ed6faSBrian Somers physical->hdlc.lqm.SaveInErrors++; 50463258dccSBrian Somers physical->hdlc.stats.badfcs++; 505dd7e2610SBrian Somers mbuf_Free(bp); 506af57ed9fSAtsushi Murai return; 507af57ed9fSAtsushi Murai } 508dd7e2610SBrian Somers if (!physical_IsSync(physical)) 509af57ed9fSAtsushi Murai bp->cnt -= 2; /* discard FCS part */ 5106b5f0ac2SPoul-Henning Kamp 5116b5f0ac2SPoul-Henning Kamp if (bp->cnt < 2) { /* XXX: raise this bar ? */ 512dd7e2610SBrian Somers mbuf_Free(bp); 5136b5f0ac2SPoul-Henning Kamp return; 5146b5f0ac2SPoul-Henning Kamp } 515af57ed9fSAtsushi Murai cp = MBUF_CTOP(bp); 516af57ed9fSAtsushi Murai 5173b0f8d2eSBrian Somers if (!physical->link.lcp.want_acfcomp) { 5180a1b5c9dSBrian Somers /* We expect the packet not to be compressed */ 519af57ed9fSAtsushi Murai addr = *cp++; 520af57ed9fSAtsushi Murai if (addr != HDLC_ADDR) { 521879ed6faSBrian Somers physical->hdlc.lqm.SaveInErrors++; 52263258dccSBrian Somers physical->hdlc.stats.badaddr++; 523dd7e2610SBrian Somers log_Printf(LogDEBUG, "hdlc_Input: addr %02x\n", *cp); 524dd7e2610SBrian Somers mbuf_Free(bp); 525af57ed9fSAtsushi Murai return; 526af57ed9fSAtsushi Murai } 527af57ed9fSAtsushi Murai ctrl = *cp++; 528af57ed9fSAtsushi Murai if (ctrl != HDLC_UI) { 529879ed6faSBrian Somers physical->hdlc.lqm.SaveInErrors++; 53063258dccSBrian Somers physical->hdlc.stats.badcommand++; 531dd7e2610SBrian Somers log_Printf(LogDEBUG, "hdlc_Input: %02x\n", *cp); 532dd7e2610SBrian Somers mbuf_Free(bp); 533af57ed9fSAtsushi Murai return; 534af57ed9fSAtsushi Murai } 535af57ed9fSAtsushi Murai bp->offset += 2; 536af57ed9fSAtsushi Murai bp->cnt -= 2; 537af57ed9fSAtsushi Murai } else if (cp[0] == HDLC_ADDR && cp[1] == HDLC_UI) { 538af57ed9fSAtsushi Murai /* 5390a1b5c9dSBrian Somers * We can receive compressed packets, but the peer still sends 5400a1b5c9dSBrian Somers * uncompressed packets ! 541af57ed9fSAtsushi Murai */ 542af57ed9fSAtsushi Murai cp += 2; 543af57ed9fSAtsushi Murai bp->offset += 2; 544af57ed9fSAtsushi Murai bp->cnt -= 2; 545af57ed9fSAtsushi Murai } 5460a1b5c9dSBrian Somers 5470a1b5c9dSBrian Somers n = hdlc_GetProto(cp, &proto); 5480a1b5c9dSBrian Somers bp->offset += n; 5490a1b5c9dSBrian Somers bp->cnt -= n; 5500a1b5c9dSBrian Somers if (!physical->link.lcp.want_protocomp && n == 1) 5510a1b5c9dSBrian Somers log_Printf(LogHDLC, "%s: Warning: received a proto-compressed packet !\n", 5520a1b5c9dSBrian Somers physical->link.name); 5531ae349f5Scvs2svn 554dd7e2610SBrian Somers link_ProtocolRecord(&physical->link, proto, PROTO_IN); 555879ed6faSBrian Somers physical->hdlc.lqm.SaveInPackets++; 5561ae349f5Scvs2svn 557dd7e2610SBrian Somers hdlc_DecodePacket(bundle, proto, bp, &physical->link); 558af57ed9fSAtsushi Murai } 559af57ed9fSAtsushi Murai 56042d4d396SBrian Somers /* 56142d4d396SBrian Somers * Detect a HDLC frame 56242d4d396SBrian Somers */ 563af57ed9fSAtsushi Murai 564e3044845SBrian Somers static const struct frameheader { 565e3044845SBrian Somers const u_char *data; 566e3044845SBrian Somers int len; 567e3044845SBrian Somers } FrameHeaders[] = { 568e3044845SBrian Somers { "\176\377\003\300\041", 5 }, 569e3044845SBrian Somers { "\176\377\175\043\300\041", 6 }, 570e3044845SBrian Somers { "\176\177\175\043\100\041", 6 }, 571e3044845SBrian Somers { "\176\175\337\175\043\300\041", 7 }, 572e3044845SBrian Somers { "\176\175\137\175\043\100\041", 7 }, 573e3044845SBrian Somers { NULL, 0 } 57442d4d396SBrian Somers }; 57542d4d396SBrian Somers 576e3044845SBrian Somers int 577e3044845SBrian Somers hdlc_Detect(u_char const **cp, int n, int issync) 57842d4d396SBrian Somers { 579e3044845SBrian Somers const struct frameheader *fh; 580e3044845SBrian Somers const u_char *h; 581e3044845SBrian Somers size_t len, cmp; 58242d4d396SBrian Somers 583e3044845SBrian Somers while (n) { 584e3044845SBrian Somers for (fh = FrameHeaders; fh->len; fh++) { 585e3044845SBrian Somers h = issync ? fh->data + 1 : fh->data; 586e3044845SBrian Somers len = issync ? fh->len - 1 : fh->len; 587e3044845SBrian Somers cmp = n >= len ? len : n; 588e3044845SBrian Somers if (memcmp(*cp, h, cmp) == 0) 589e3044845SBrian Somers return cmp == len; 59042d4d396SBrian Somers } 591e3044845SBrian Somers n--; 592e3044845SBrian Somers (*cp)++; 593e3044845SBrian Somers } 594e3044845SBrian Somers 595e3044845SBrian Somers return 0; 59642d4d396SBrian Somers } 59763258dccSBrian Somers 59863258dccSBrian Somers int 59963258dccSBrian Somers hdlc_ReportStatus(struct cmdargs const *arg) 60063258dccSBrian Somers { 601b6217683SBrian Somers struct hdlc *hdlc = &arg->cx->physical->hdlc; 602b6217683SBrian Somers 6036e7cdde1SBrian Somers prompt_Printf(arg->prompt, "%s HDLC level errors:\n", arg->cx->name); 604b6217683SBrian Somers prompt_Printf(arg->prompt, " Bad Frame Check Sequence fields: %u\n", 605b6217683SBrian Somers hdlc->stats.badfcs); 606b6217683SBrian Somers prompt_Printf(arg->prompt, " Bad address (!= 0x%02x) fields: %u\n", 607b6217683SBrian Somers HDLC_ADDR, hdlc->stats.badaddr); 608b6217683SBrian Somers prompt_Printf(arg->prompt, " Bad command (!= 0x%02x) fields: %u\n", 609b6217683SBrian Somers HDLC_UI, hdlc->stats.badcommand); 610b6217683SBrian Somers prompt_Printf(arg->prompt, " Unrecognised protocol fields: %u\n", 611b6217683SBrian Somers hdlc->stats.unknownproto); 61263258dccSBrian Somers return 0; 61363258dccSBrian Somers } 61463258dccSBrian Somers 61563258dccSBrian Somers static void 61663258dccSBrian Somers hdlc_ReportTime(void *v) 61763258dccSBrian Somers { 61863258dccSBrian Somers /* Moan about HDLC errors */ 61963258dccSBrian Somers struct hdlc *hdlc = (struct hdlc *)v; 62063258dccSBrian Somers 621dd7e2610SBrian Somers timer_Stop(&hdlc->ReportTimer); 62263258dccSBrian Somers 62363258dccSBrian Somers if (memcmp(&hdlc->laststats, &hdlc->stats, sizeof hdlc->stats)) { 624dd7e2610SBrian Somers log_Printf(LogPHASE, 625147613eaSBrian Somers "%s: HDLC errors -> FCS: %u, ADDR: %u, COMD: %u, PROTO: %u\n", 626147613eaSBrian Somers hdlc->lqm.owner->fsm.link->name, 62763258dccSBrian Somers hdlc->stats.badfcs - hdlc->laststats.badfcs, 62863258dccSBrian Somers hdlc->stats.badaddr - hdlc->laststats.badaddr, 62963258dccSBrian Somers hdlc->stats.badcommand - hdlc->laststats.badcommand, 63063258dccSBrian Somers hdlc->stats.unknownproto - hdlc->laststats.unknownproto); 63163258dccSBrian Somers hdlc->laststats = hdlc->stats; 63263258dccSBrian Somers } 63363258dccSBrian Somers 634dd7e2610SBrian Somers timer_Start(&hdlc->ReportTimer); 63563258dccSBrian Somers } 63663258dccSBrian Somers 63763258dccSBrian Somers void 63863258dccSBrian Somers hdlc_StartTimer(struct hdlc *hdlc) 63963258dccSBrian Somers { 640dd7e2610SBrian Somers timer_Stop(&hdlc->ReportTimer); 64163258dccSBrian Somers hdlc->ReportTimer.load = 60 * SECTICKS; 64263258dccSBrian Somers hdlc->ReportTimer.arg = hdlc; 64363258dccSBrian Somers hdlc->ReportTimer.func = hdlc_ReportTime; 6443b0f8d2eSBrian Somers hdlc->ReportTimer.name = "hdlc"; 645dd7e2610SBrian Somers timer_Start(&hdlc->ReportTimer); 64663258dccSBrian Somers } 64763258dccSBrian Somers 64863258dccSBrian Somers void 64963258dccSBrian Somers hdlc_StopTimer(struct hdlc *hdlc) 65063258dccSBrian Somers { 651dd7e2610SBrian Somers timer_Stop(&hdlc->ReportTimer); 652af57ed9fSAtsushi Murai } 653