开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
if_sl.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：44k
源码类别：

VxWorks

开发平台：

C/C++

if_sl.c：源码内容
  1. /* if_sl.c - Serial Line IP (SLIP) network interface driver */
  3. /* Copyright 1989 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /* $NetBSD: if_sl.c,v 1.33 1994/12/11 21:39:05 mycroft Exp $ */
  8. /*
  9.  * Copyright (c) 1987, 1989, 1992, 1993
  10.  * The Regents of the University of California.  All rights reserved.
  11.  *
  12.  * Redistribution and use in source and binary forms, with or without
  13.  * modification, are permitted provided that the following conditions
  14.  * are met:
  15.  * 1. Redistributions of source code must retain the above copyright
  16.  *    notice, this list of conditions and the following disclaimer.
  17.  * 2. Redistributions in binary form must reproduce the above copyright
  18.  *    notice, this list of conditions and the following disclaimer in the
  19.  *    documentation and/or other materials provided with the distribution.
  20.  * 3. All advertising materials mentioning features or use of this software
  21.  *    must display the following acknowledgement:
  22.  * This product includes software developed by the University of
  23.  * California, Berkeley and its contributors.
  24.  * 4. Neither the name of the University nor the names of its contributors
  25.  *    may be used to endorse or promote products derived from this software
  26.  *    without specific prior written permission.
  27.  *
  28.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  29.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  32.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  34.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  37.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  38.  * SUCH DAMAGE.
  39.  *
  40.  * @(#)if_sl.c 8.6 (Berkeley) 2/1/94
  41.  */
  43. /*
  44. modification history
  45. --------------------
  46. 02e,16may02,vvv  replaced schednetisr with direct call to ipintr;
  47.  fixed compilation warnings
  48. 02d,17oct00,spm  merged from version 02e of tor2_0_x branch (base version 02c):
  49.                  updated for new if_attach: reports memory allocation failures
  50. 02c,08may97,vin  switched the order of ifDstAddrSet and ifAddrSet, fixed
  51.  SIOCSIFDSTADDR in slioctl, SPR 8531, added slRtRequest().
  52. 02b,01aug97,jmb  Reduce number of slread netJobs by a factor of two
  53.  when FRAME_END character used to begin a new frame.
  54. 02a,16jul97,jmb  Added code to discard packets at interrupt level if
  55.  the input ring buffer is full.
  56. 01z,04dec96,vin  replaced MFREE with m_free (..)
  57. 01y,18jul96,vin  upgraded to BSD4.4, removed call to in_ifaddr_remove as it 
  58.  is being done in if_dettach now. 
  59. 01x,07mar96,gnn  Added code to handle user selectable MTUs for the SLIP
  60.          link.  (SPR #4652)
  61. 01w,14mar95,dzb  make sure to flush the wrt task's queue on close (SPR #4111).
  62. 01v,13mar95,dzb  added call to in_ifaddr_remove when deleting if (SPR #4109).
  63. 01u,13mar95,dzb  changed to use free() instead of cfree() (SPR #4113).
  64. 01t,24jan95,jdi  doc cleanup.
  65. 01s,08dec94,dzb  return ENOBUFS when dropping packet in sloutput() (SPR #3844).
  66. 01r,11nov94,dzb  added CSLIP enhancements.  decreased SLMTU size.  doc tweaks.
  67.  implemented buffer loaning, and removed extra data copies.
  68.  replaced calls to sl_btom() with copy_to_mbufs().
  69. 01q,22apr93,caf  ansification: added cast to ioctl() parameter.
  70. 01p,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  71. 01o,19feb93,jdi  documentation cleanup.
  72. 01n,22sep92,gae  documentation tweaks.
  73. 01m,18jul92,smb  Changed errno.h to errnoLib.h.
  74. 01l,26may92,rrr  the tree shuffle
  75.   -changed includes to have absolute path from h/
  76. 01k,07nov91,jpb  made slipWrtTask global for task TCB "ENTRY" status.
  77. 01j,04oct91,rrr  passed through the ansification filter
  78.                   -changed functions to ansi style
  79.   -changed includes to have absolute path from h/
  80.   -changed VOID to void
  81.   -changed copyright notice
  82. 01i,10apr91,jdi  documentation cleanup; removed stray close-quote in example;
  83.  doc review by elh.
  84. 01h,10aug90,dnw  corrected forward declarations for void functions.
  85. 01g,26jun90,hjb  SLBUFSIZE increased to fix a bug in ESC handling.
  86. 01f,26jun90,jcf  changed semaphore initialization to 5.0.
  87. 01e,07may90,hjb  changed MIN,MAX to min,max; de-linted.
  88. 01d,19apr90,hjb  deleted param.h, de-linted.
  89. 01c,20mar90,jcf  changed semaphores to binary.
  90. 01b,18mar90,hjb  minor cleanup.
  91. 01a,11apr89,hjb  first vxWorks version.
  92. */
  94. /*
  95. DESCRIPTION
  96. This module implements the VxWorks Serial Line IP (SLIP) network 
  97. interface driver.  Support for compressed TCP/IP headers (CSLIP) is included.
  99. The SLIP driver enables VxWorks to talk to other machines over serial
  100. connections by encapsulating IP packets into streams of bytes suitable
  101. for serial transmission.
  103. USER-CALLABLE ROUTINES
  104. SLIP devices are initialized using slipInit().  Its parameters specify 
  105. the Internet address for both sides of the SLIP point-to-point link,
  106. the name of the tty device on the local host, and options to enable CSLIP
  107. header compression.  The slipInit() routine calls slattach() to attach the
  108. SLIP interface to the network.  The slipDelete() routine deletes a specified
  109. SLIP interface.
  111. LINK-LEVEL PROTOCOL
  112. SLIP is a simple protocol that uses four token characters
  113. to delimit each packet:
  115.     - END (0300)
  116.     - ESC (0333)
  117.     - TRANS_END (0334)
  118.     - TRANS_ESC (0335)
  120. The END character denotes the end of an IP packet.  The ESC character is used
  121. with TRANS_END and TRANS_ESC to circumvent potential occurrences of END or ESC
  122. within a packet.  If the END character is to be embedded, SLIP sends 
  123. "ESC TRANS_END" to avoid confusion between a SLIP-specific END and actual
  124. data whose value is END.  If the ESC character is to be embedded, then
  125. SLIP sends "ESC TRANS_ESC" to avoid confusion.  (Note that the SLIP ESC is
  126. not the same as the ASCII ESC.)
  128. On the receiving side of the connection, SLIP uses the opposite actions to
  129. decode the SLIP packets.  Whenever an END character is received, SLIP
  130. assumes a full IP packet has been received and sends it up to the IP layer.
  132. TARGET-SPECIFIC PARAMETERS
  133. The global flag slipLoopBack is set to 1 by default. This flag enables
  134. the packets to be sent to the loopback interface if they are destined to
  135. to a local slip interface address. By setting this flag, any packets
  136. sent to a local slip interface address will not be seen on the actual serial
  137. link. Set this flag to 0 to turn off this facility. If this flag is not set
  138. any packets sent to the local slip interface address will actually be sent
  139. out on the link and it is the peer's responsibility to loop the packet back.
  141. IMPLEMENTATION
  142. The write side of a SLIP connection is an independent task.  Each SLIP
  143. interface has its own output task that sends SLIP packets over a
  144. particular tty device channel.  Whenever a packet is ready to be sent out,
  145. the SLIP driver activates this task by giving a semaphore.  When the
  146. semaphore is available, the output task performs packetization
  147. (as explained above) and writes the packet to the tty device.
  149. The receiving side is implemented as a "hook" into the tty driver.  A tty
  150. ioctl() request, FIOPROTOHOOK, informs the tty driver to call the SLIP
  151. interrupt routine every time a character is received from a serial port.
  152. By tracking the number of characters and watching for the END character,
  153. the number of calls to read() and context switching time have been
  154. reduced.  The SLIP interrupt routine will queue a call to the SLIP read
  155. routine only when it knows that a packet is ready in the tty driver's ring
  156. buffer.  The SLIP read routine will read a whole SLIP packet at a time and
  157. process it according to the SLIP framing rules.  When a full IP packet is
  158. decoded out of a SLIP packet, it is queued to IP's input queue.
  160. CSLIP compression is implemented to decrease the size of the TCP/IP
  161. header information, thereby improving the data to header size ratio.
  162. CSLIP manipulates header information just before a
  163. packet is sent and just after a packet is received.  Only TCP/IP 
  164. headers are compressed and uncompressed; other protocol types are
  165. sent and received normally.  A functioning CSLIP driver is required
  166. on the peer (destination) end of the physical link in order to carry
  167. out a CSLIP "conversation."
  169. Multiple units are supported by this driver.  Each individual unit may
  170. have CSLIP support disabled or enabled, independent of the state of
  171. other units.
  173. INTERNAL
  174. The write side of a SLIP connection is an independent task.  Each SLIP
  175. interface will have its own output task that will send SLIP packets over a
  176. particular tty device channel.  Whenever a packet is ready to be sent out,
  177. sloutput() will activate this task by giving a semaphore.  When the
  178. semaphore is available, the output task will perform packetization
  179. (as explained above) and write the packet to the tty device.
  181. The receiving side is implemented as a "hook" into the tty driver.  A tty
  182. ioctl() request, FIOPROTOHOOK, informs the tty driver to call slintr() every
  183. time a character is received from a serial port.  By tracking the number
  184. of characters and watching for the END character, the number of calls to
  185. read() and context switching time have been reduced.  The slintr() routine
  186. will queue a call to slread() only when it knows that a packet is ready in
  187. the tty driver's ring buffer.  slread() will read a whole SLIP packet at a
  188. time and process it according to the SLIP framing rules.  When a full IP
  189. packet is decoded out of a SLIP packet, it is enqueued to IP's input queue.
  191. The CSLIP compressed header format is only implemented for TCP/IP packets.
  192. The slcompress.c:sl_compress_tcp routine is called from sloutput() to
  193. compress the header while the outgoing packet is still in an mbuf chain.
  194. The slcompress.c:sl_uncompress_tcp routine is called from slRecv() to
  195. uncompress the header before the packet is copied to an mbuf chain (i.e.,
  196. the incoming packet is in a contiguous buffer).
  197. The CSLIP header's first octet contains the packet type (top 3 bits), TCP
  198. 'push' bit, and flags that indicate which of the 4 TCP sequence
  199. numbers have changed (bottom 5 bits).  The next octet is a
  200. conversation number that associates a saved IP/TCP header with
  201. the compressed packet.  The next two octets are the TCP checksum
  202. from the original datagram.  The next 0 to 15 octets are
  203. sequence number changes, one change per bit set in the header
  204. (there may be no changes and there are two special cases where
  205. the receiver implicitly knows what changed).
  206. There are 5 numbers which can change (they are always inserted
  207. in the following order): TCP urgent pointer, window,
  208. acknowlegement, sequence number and IP ID.  (The urgent pointer
  209. is different from the others in that its value is sent, not the
  210. change in value.)  Since typical use of SLIP links is biased
  211. toward small packets, changes use a variable length coding with
  212. one octet for numbers in the range 1 - 255 and 3 octets (0, MSB,
  213. LSB) for numbers in the range 256 - 65535 or 0.  (If the change
  214. in sequence number or ack is more than 65535, an uncompressed
  215. packet is sent.)
  217. BOARD LAYOUT
  218. No hardware is directly associated with this driver; therefore, a jumpering
  219. diagram is not applicable.
  221. SEE ALSO
  222. ifLib, tyLib,
  223. John Romkey: RFC-1055,
  224. .I "A Nonstandard for Transmission of IP Datagrams Over Serial Lines: SLIP,"
  225. Van Jacobson: RFC-1144, entitled
  226. .I "Compressing TCP/IP Headers for Low-Speed Serial Links"
  228. ACKNOWLEDGEMENT
  229. This program is based on original work done by Rick Adams of The Center for
  230. Seismic Studies and Chris Torek of The University of Maryland.
  231. The CSLIP enhancements are based on work done by Van Jacobson of
  232. University of California, Berkeley for the "cslip-2.7" release.
  234. INTERNAL
  236. .CS
  237.         slipInit   sloutput    slipDelete   slipBaudSet   slintr   slioctl
  238.            /          |              |                     |
  239.           /           |semaphore     |                     |
  240.          /            |              |                     |
  241.         /             |--|           |                     |
  242.  slattach slipWrtTask <-  |           |                   slread
  243.       |                   |           |                     |
  244.       |          sl_compress_tcp      |  sl_uncompress_tcp  |
  245.       |                               |         |           |
  246.   slSoftcFree <-----------------------+         ---------slRecv
  247. .CE
  248. */
  250. /* includes */
  252. #include "vxWorks.h"
  253. #include "sys/socket.h"
  254. #include "sys/ioctl.h"
  255. #include "stdio.h"
  256. #include "errnoLib.h"
  257. #include "ioLib.h"
  258. #include "semLib.h"
  259. #include "memLib.h"
  260. #include "taskLib.h"
  261. #include "tickLib.h"
  262. #include "logLib.h"
  263. #include "ifLib.h"
  264. #include "routeLib.h"
  265. #include "netLib.h"
  266. #include "etherLib.h"
  267. #include "net/if.h"
  268. #include "net/if_types.h"
  269. #include "net/if_subr.h"
  270. #include "net/route.h"
  271. #include "net/mbuf.h"
  272. #include "net/unixLib.h"
  273. #include "netinet/in.h"
  274. #include "netinet/in_systm.h"
  275. #include "netinet/in_var.h"
  276. #include "netinet/ip.h"
  277. #include "netinet/ip_var.h"
  278. #include "netinet/sl_compress.h"
  279. #include "if_sl.h"
  280. #include "drv/netif/netifDev.h"
  281. #include "rngLib.h"
  282. #include "tyLib.h"
  284. /* defines */
  286. /*
  287.  * SLMTU is now a hard limit on input packet size.  SLMTU must be <= MCLBYTES
  288.  * to take advantage of buffer loaning.  Additionally, it has been shown
  289.  * that a smaller MTU works well with SLIP, so that echo traffic does
  290.  * not have to wait for larger, bulk data packets.  With an MTU that is
  291.  * 10 to 20 times that TCP/IP header, a reasonable line efficiency is
  292.  * achieved.  For SLIP, this dictates an MTU of 400 to 800 bytes.
  293.  * CSLIP could do well with an MTU as low as 100 to 400 bytes.
  294.  */
  297. #define SLMTU 576 /* max Tx/Rx size in bytes */
  298. #define L_POOL 6 /* Rx loaner buffer pool */
  299. #define NSLIP 20 /* max. number of SLIP interfaces */
  300. #define SLBUF_OFF (sizeof(struct ifnet *) + 128)
  301. #define SLBUF_HI ((SLMTU*2) - 1) /* Rx character threshold */
  302. #define SLBUFSIZE ((SLMTU*2) + SLBUF_OFF)
  303.                                         /* leave room for CSLIP uncompress */
  305. /* SLIP protocol characters */
  307. #define FRAME_END   0300 /* Frame End */
  308. #define FRAME_ESCAPE 0333 /* Frame Esc */
  309. #define TRANS_FRAME_END   0334 /* transposed frame end */
  310. #define TRANS_FRAME_ESCAPE  0335 /* transposed frame esc */
  312. /* SLIP control flags */
  314. #define SL_COMPRESS 0x01 /* enable CSLIP compression */
  315. #define SL_COMPRESS_RX 0x02 /* enable compression on Rx of compress pkt */
  316. #define SL_INTR_PACKET_DISCARD 0x04  /* discard current packet at int. level */
  318. #define SIN(s) ((struct sockaddr_in *)s)
  319.     
  320. /* typedefs */
  322. typedef struct /* SL_SOFTC */
  323.     {
  324.     struct ifnet      sc_if; /* network-visible interface */
  325.     u_char            sc_flags; /* SLIP interface control flags */
  326.     short       sc_ilen; /* chars in current Rx packet */
  327.     short       sc_qlen; /* num of chars in tty input queue */
  328.     char *       sc_buf; /* input buffer */
  329.     char *            sc_orig; /* pointer to malloc'ed buffer space */
  330.     int         sc_fd; /* file descriptor for slip device */
  331.     SEM_ID       sc_wrtSem; /* write semaphore */
  332.     int       sc_wrtTaskId; /* write task ID */
  333.     struct slcompress sc_comp; /* TCP/IP compression info */
  334.     int       sc_nLoanRxBuf; /* number of Rx buffers left to loan */
  335.     char *            sc_lPool[L_POOL]; /* receive buffer loaner pool */
  336.     UINT8 *           sc_pRefC[L_POOL]; /* stack of reference count pointers */
  337.     UINT8       sc_refC[L_POOL]; /* actual reference count values */
  338.     } SL_SOFTC;
  340. /* globals */
  342. int slipTaskPriority = 55; /* netTask priority +5 */
  343. int slipTaskOptions = VX_SUPERVISOR_MODE | VX_UNBREAKABLE;
  344. int slipTaskStackSize = 2000;
  345. int slipLoopBack  = 1;
  347. IMPORT void if_dettach (struct ifnet *ifp);
  348. IMPORT void if_down (struct ifnet *ifp);
  350. IMPORT struct  ifqueue ipintrq; 
  351. IMPORT struct  ifnet loif;
  353. /* locals */
  355. LOCAL SL_SOFTC *sl_softc [NSLIP];
  357. /* forward declarations */
  359. STATUS slipDelete (); /* global for user access */
  360. void slipWrtTask (SL_SOFTC *sc); /* global for "ENTRY" status */
  361. STATUS slattach (int unit, int fd, BOOL compressEnable,
  362.   BOOL compressAllow, int mtu);
  364. /* static forward declarations */
  366. #ifdef __STDC__
  368. static void slSoftcFree (SL_SOFTC *sc, int unit);
  369. static void slinit (int unit);
  370. static STATUS sloutput (struct ifnet *ifp, struct mbuf *m,
  371.                         struct sockaddr* dst, struct rtentry * rtp);
  372. static BOOL slintr (int unit, int inchar);
  373. static void slread (SL_SOFTC *sc, int count);
  374. static char *slRecv (SL_SOFTC *sc, BOOL firstCluster);
  375. static int slioctl (struct ifnet *ifp, int cmd, caddr_t data);
  376. static int numCharsToMask (u_char mask1, u_char mask2, u_int size, u_char *cp);
  377. static void slLoanFree (SL_SOFTC *sc, char *pRxBuf, UINT8 *pRef);
  379. static void slRtRequest (int cmd, struct rtentry * pRtEntry,
  380.                          struct sockaddr * pSockAddr); 
  382. #else /* __STDC__ */
  384. static void slSoftcFree ();
  385. static void slinit ();
  386. static STATUS sloutput ();
  387. static BOOL slintr ();
  388. static void slread ();
  389. static char *slRecv ();
  390. static int slioctl ();
  391. static int numCharsToMask ();
  392. static void slLoanFree ();
  394. #endif /* __STDC__ */
  396. /*******************************************************************************
  397. *
  398. * slipInit - initialize a SLIP interface
  399. *
  400. * This routine initializes a SLIP device.  Its parameters specify the name
  401. * of the tty device, the Internet addresses of both sides of the SLIP
  402. * point-to-point link (i.e., the local and remote sides of the serial line
  403. * connection), and CSLIP options.
  404. *
  405. * The Internet address of the local side of the connection is specified in
  406. * <myAddr> and the name of its tty device is specified in <devName>.
  407. * The Internet address of the remote side is specified in <peerAddr>.
  408. * If <baud> is not zero, the baud rate will be the specified value;
  409. * otherwise, the default baud rate will be the rate set by the tty driver.
  410. * The <unit> parameter specifies the SLIP device unit number.  Up to twenty
  411. * units may be created.
  412. *
  413. * The CLSIP options parameters <compressEnable> and <compressAllow> determine
  414. * support for TCP/IP header compression.  If <compressAllow> is TRUE (1), then
  415. * CSLIP will be enabled only if a CSLIP type packet is received by this
  416. * device.  If <compressEnable> is TRUE (1), then CSLIP compression will be
  417. * enabled explicitly for all transmitted packets, and compressed packets
  418. * can be received.
  419. *
  420. * The MTU option parameter allows the setting of the MTU for the link.
  421. * 
  422. * For example, the following call initializes a SLIP device, using the
  423. * console's second port, where the Internet address of the local host is
  424. * 192.10.1.1 and the address of the remote host is 192.10.1.2.
  425. * The baud rate will be the default rate for /tyCo/1.  CLSIP is enabled
  426. * if a CSLIP type packet is received.  The MTU of the link is 1006.
  427. * .CS
  428. *     slipInit (0, "/tyCo/1", "192.10.1.1", "192.10.1.2", 0, 0, 1, 1006);
  429. * .CE
  430. *
  431. * RETURNS:
  432. * OK, or ERROR if the device cannot be opened, memory is insufficient,
  433. * or the route is invalid.
  434. */
  436. STATUS slipInit
  437.     (
  438.     int         unit,           /* SLIP device unit number (0 - 19) */
  439.     char        *devName,       /* name of the tty device to be initialized */
  440.     char        *myAddr,        /* address of the SLIP interface */
  441.     char        *peerAddr,      /* address of the remote peer SLIP interface */
  442.     int         baud,           /* baud rate of SLIP device: 0=don't set rate */
  443.     BOOL compressEnable, /* explicitly enable CSLIP compression */
  444.     BOOL compressAllow, /* enable CSLIP compression on Rx */
  445.     int mtu /* user set-able MTU */
  446.     )
  447.     {
  448.     SL_SOFTC *sc;
  449.     int  slipFd;
  450.     char  slipName [10];
  451.     char  slipWrtName [10];
  453.     /* check and see of unit is in valid range */
  454.     if (unit < 0 || unit >= NSLIP)
  455. {
  456. (void)errnoSet (S_if_sl_INVALID_UNIT_NUMBER);
  457. return (ERROR);
  458. }
  460.     if ((slipFd = open (devName, O_RDWR, 0)) == ERROR)
  461. return (ERROR);
  463.     /* set the baud rate only if the 'baud' is not equal to zero */
  464.     if (baud != 0 && ioctl (slipFd, FIOBAUDRATE, baud) == ERROR)
  465. {
  466. (void) close (slipFd);
  467. return (ERROR);
  468. }
  470.     if (mtu <= 0 || mtu > 2048)
  471. mtu = SLMTU;
  472.     /*
  473.      * Re-allocate big enough ring buffers for this tty device since
  474.      * the default ring buffer size of tty devices is 512 bytes, which
  475.      * may be smaller than SLMTU.  The ring buffers are 4 times
  476.      * the size of a maximum SLIP packet, for insurance.
  477.      */
  478.     if (ioctl (slipFd, FIORBUFSET, 4 * mtu) == ERROR ||
  479. ioctl (slipFd, FIOWBUFSET, 4 * mtu) == ERROR)
  480. {
  481. (void) close (slipFd);
  482. return (ERROR);
  483. }
  485.     if (slattach (unit, slipFd, compressEnable, compressAllow, mtu) == ERROR)
  486. {
  487. (void) close (slipFd);
  488. return (ERROR);
  489. }
  491.     sc = sl_softc [unit];
  493.     (void) sprintf (slipName, "sl%d", sc->sc_if.if_unit);
  494.     (void) sprintf (slipWrtName, "tSl%dWrt", sc->sc_if.if_unit);
  496.     /* Set own and peer's internet address.
  497.      * Add a routing table entry to tell how to loopback over SLIP.
  498.      * Point to point loopback routing table entry is required to
  499.      * properly talk to myself using the SLIP interface address.
  500.      */
  501.     if (ifDstAddrSet (slipName, peerAddr) == ERROR ||
  502.         ifAddrSet (slipName, myAddr) == ERROR ||
  503. routeAdd (myAddr, myAddr) == ERROR)
  504. {
  505. (void) close (slipFd);
  506. return (ERROR);
  507. }
  509.     /* start up the SLIP output task for this interface */
  511.     sc->sc_wrtTaskId = taskSpawn (slipWrtName, slipTaskPriority,
  512.                   slipTaskOptions, slipTaskStackSize,
  513.                   (FUNCPTR) slipWrtTask, (int) sc,
  514.   0, 0, 0, 0, 0, 0, 0, 0, 0);
  516.     if (sc->sc_wrtTaskId == ERROR)
  517. {
  518. (void) close (slipFd);
  519. return (ERROR);
  520. }
  522.     return (OK);
  523.     }
  525. /*******************************************************************************
  526. *
  527. * slipBaudSet - set the baud rate for a SLIP interface
  528. *
  529. * This routine adjusts the baud rate of a tty device attached to a SLIP
  530. * interface.  It provides a way to modify the baud rate of a tty
  531. * device being used as a SLIP interface.
  532. *
  533. * RETURNS: OK, or ERROR if the unit number is invalid or uninitialized.
  534. */
  536. STATUS slipBaudSet
  537.     (
  538.     int unit,           /* SLIP device unit number */
  539.     int baud            /* baud rate */
  540.     )
  541.     {
  542.     SL_SOFTC *sc;
  544.     /* check for valid unit number */
  546.     if (unit < 0 || unit >= NSLIP)
  547. {
  548. (void)errnoSet (S_if_sl_INVALID_UNIT_NUMBER);
  549. return (ERROR);
  550. }
  552.     /* make sure that the sl_softc for the 'unit' is initialized properly */
  553.     if ((sc = sl_softc [unit]) == NULL)
  554. {
  555. (void)errnoSet (S_if_sl_UNIT_UNINITIALIZED);
  556. return (ERROR);
  557. }
  559.     return (ioctl (sc->sc_fd, FIOBAUDRATE, baud));
  560.     }
  562. /*******************************************************************************
  563. *
  564. * slattach - publish the `sl' network interface and initialize the driver and device
  565. *
  566. * This routine publishes the `sl' interface by filling in a network interface
  567. * record and adding this record to the system list.  It also initializes
  568. * the driver and the device to the operational state.
  569. *
  570. * This routine is usually called by slipInit().
  571. *
  572. * RETURNS: OK or ERROR.
  573. */
  575. STATUS slattach
  576.     (
  577.     int unit, /* SLIP device unit number */
  578.     int fd, /* fd of tty device for SLIP interface */
  579.     BOOL compressEnable, /* explicitly enable CSLIP compression */
  580.     BOOL compressAllow, /* enable CSLIP compression on Rx */
  581.     int mtu /* user setable MTU */
  582.     )
  583.     {
  584.     SL_SOFTC *sc;
  585.     struct ifnet *ifp;
  586.     int ix;
  588.     if (sl_softc [unit] != NULL)
  589. {
  590. (void)errnoSet (S_if_sl_UNIT_ALREADY_INITIALIZED);
  591. return (ERROR);
  592. }
  594.     if ((sc = (SL_SOFTC *) calloc (1, sizeof (SL_SOFTC))) == (SL_SOFTC *) NULL)
  595. return (ERROR);
  597.     if (mtu <= 0 || mtu > 2048)
  598. mtu = SLMTU;
  600.     sl_softc [unit] = sc;
  602.     ifp = &sc->sc_if; /* get a pointer to ifnet structure */
  604.     ifp->if_name     = "sl";
  605.     ifp->if_unit     = unit;
  606.     ifp->if_mtu     = mtu;
  607.     ifp->if_flags     = IFF_POINTOPOINT | IFF_MULTICAST;
  608.     sc->sc_if.if_type     = IFT_SLIP;
  609.     ifp->if_ioctl     = slioctl;
  610.     ifp->if_init    = (FUNCPTR) slinit;
  611.     ifp->if_output     = sloutput;
  612.     ifp->if_reset     = slipDelete;
  613.     ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
  615.     /* allocate SLIP input buffer space, including loaner buffers */
  617.     if ((sc->sc_orig = (char *) calloc (L_POOL, (u_int) SLBUFSIZE)) == NULL)
  618.         {
  619.         free ( (char *)sc);
  620.         return (ERROR);
  621.         }
  623.     /* attach SLIP to linked list of all interfaces */
  625.     if (if_attach (ifp) == ERROR)
  626.         {
  627.         free ( (char *)sc);
  628.         return (ERROR);
  629.         }
  631.     sc->sc_flags = 0;
  632.     sc->sc_ilen = 0;
  633.     sc->sc_qlen = 0;
  634.     sc->sc_nLoanRxBuf = L_POOL;
  636.     /* set CSLIP options in the SL_SOFTC flags */
  638.     if (compressEnable || compressAllow)
  639. {
  640.         sl_compress_init (&sc->sc_comp);
  641.         if (compressEnable)
  642.             sc->sc_flags |= SL_COMPRESS;
  643. else
  644.             sc->sc_flags |= SL_COMPRESS_RX;
  645.         }
  647.     sc->sc_buf = sc->sc_orig + SLBUF_OFF; /* leave space for uncompress */
  649.     /* assign loaner buffer addresses */
  651.     for (ix = 0; ix < L_POOL; ix++)
  652. {
  653. sc->sc_lPool[ix] = (sc->sc_buf + (ix * SLBUFSIZE));
  654. sc->sc_refC[ix]  = 0;
  655. sc->sc_pRefC[ix] = &sc->sc_refC[ix];
  656. }
  658.     if ((sc->sc_wrtSem = semBCreate (SEM_Q_PRIORITY, SEM_EMPTY)) == NULL)
  659. {
  660. slSoftcFree (sc, unit);
  661. return (ERROR);
  662. }
  664.     /*
  665.      * Make sure that the tty device described by 'fd' is
  666.      * indeed a tty device.
  667.      */
  668.     if (ioctl (fd, FIOISATTY, 0 /*XXX*/) == TRUE)
  669. sc->sc_fd = fd;
  670.     else
  671.         {
  672. slSoftcFree (sc, unit);
  673. return (ERROR);
  674.         }
  676.     /*
  677.      * call ioctl to,
  678.      *   FIOFLUSH     - flush out everything on this tty dev
  679.      *   FIOOPTIONS   - set the tty dev in RAW mode
  680.      *   FIOPROTOHOOK - specify the protocol interface hook routine for SLIP
  681.      *   FIOPROTOARG  - specify the SLIP unit number for this tty dev
  682.      */
  684.     if (ioctl (fd, FIOFLUSH, 0 /*XXX*/)        == ERROR ||
  685. ioctl (fd, FIOOPTIONS, OPT_RAW)        == ERROR ||
  686. ioctl (fd, FIOPROTOHOOK, (int) slintr) == ERROR ||
  687. ioctl (fd, FIOPROTOARG, unit)          == ERROR)
  688. {
  689. slSoftcFree (sc, unit);
  690. return (ERROR);
  691. }
  693.     return (OK);
  694.     }
  696. /*******************************************************************************
  697. *
  698. * slipDelete - delete a SLIP interface
  699. *
  700. * This routine resets a specified SLIP interface.  It detaches the tty from
  701. * the `sl' unit and deletes the specified SLIP interface from the list of
  702. * network interfaces.  For example, the following call will delete the first
  703. * SLIP interface from the list of network interfaces:
  704. * .CS
  705. *     slipDelete (0);
  706. * .CE
  707. *
  708. * RETURNS: OK, or ERROR if the unit number is invalid or uninitialized.
  709. */
  711. STATUS slipDelete
  712.     (
  713.     int unit                    /* SLIP unit number */
  714.     )
  715.     {
  716.     SL_SOFTC *sc;
  717.     struct mbuf *pMbuf;
  718.     int s;
  720.     if (unit >= 0 && unit < NSLIP)
  721.      sc = sl_softc [unit];
  722.     else
  723. {
  724. (void)errnoSet (S_if_sl_INVALID_UNIT_NUMBER);
  725.      return (ERROR);
  726. }
  728.     if (sc == NULL)
  729. {
  730. (void)errnoSet (S_if_sl_UNIT_UNINITIALIZED);
  731. return (ERROR);
  732. }
  734.     /* flush write side of the tty ringer buffer */
  736.     (void) ioctl (sc->sc_fd, FIOWFLUSH, 0 /*XXX*/);
  737.     (void) ioctl (sc->sc_fd, FIOPROTOHOOK, (int) NULL);
  739.     s = splimp (); /* paranoid; splnet probably ok */
  741.     if_down (&sc->sc_if); /* mark it down */
  742.     (void) close (sc->sc_fd); /* close the tty device */
  744.     for (;;) /* flush the wrt task queue and free mbufs */
  745. {
  746. IF_DEQUEUE (&sc->sc_if.if_snd, pMbuf);
  747. if (pMbuf == NULL)
  748.     break;
  749. m_freem (pMbuf);
  750. }
  752.     if (sc->sc_wrtTaskId != ERROR)
  753.         taskDelete (sc->sc_wrtTaskId);
  755.     /*
  756.      * Delete all routes associated with this SLIP interface.
  757.      * This will effectively delete the point-to-point routes for this SLIP.
  758.      */
  760.     (void) ifRouteDelete ("sl", unit);
  762.     slSoftcFree (sc, unit);
  764.     splx (s);
  765.     return (OK);
  766.     }
  768. /*******************************************************************************
  769. *
  770. * slSoftcFree - free the allocated sl_softc structure
  771. *
  772. * This is called by slattach to free the allocated sl_softc structure
  773. * when error occurs within slattach.  The reason for having this routine
  774. * is to get rid of the repetitive code within slattach ().
  775. * This routine is also called by slipDelete ().
  776. */
  778. LOCAL void slSoftcFree
  779.     (
  780.     SL_SOFTC *sc,
  781.     int       unit
  782.     )
  783.     {
  784.     /* Take the pointer to this SLIP interface out of the linked list
  785.      * of all available network interfaces.  The if_dettach () will un-do
  786.      * the action taken by if_attach ().
  787.      */
  789.     if_dettach (&sc->sc_if);
  791.     if (sc->sc_wrtSem)
  792.         semDelete (sc->sc_wrtSem); /* delete write semaphore */
  794.     if (sc->sc_buf)
  795. {
  796. (void) free (sc->sc_orig);
  797. sc->sc_buf = NULL;
  798. }
  800.     (void) free ((char *) sc);
  801.     sl_softc [unit] = (SL_SOFTC *) NULL;
  802.     }
  804. /*******************************************************************************
  805. *
  806. * slinit - initialize SLIP interface
  807. */
  809. LOCAL void slinit
  810.     (
  811.     int unit
  812.     )
  813.     {
  814.     SL_SOFTC *sc = sl_softc [unit];
  816.     sc->sc_if.if_flags |= IFF_UP|IFF_RUNNING; /* open for business */
  817.     }
  819. /*******************************************************************************
  820. *
  821. * sloutput - output a packet over the SLIP line
  822. *
  823. * Queue a packet and trigger the slipWrtTask if a packet is ready
  824. * by releasing the semaphore.  CSLIP compression for TCP/IP headers is
  825. * supported if (enabled).
  826. *
  827. * RETURNS: OK, or ERROR if the output queue is full.
  828. */
  830. LOCAL STATUS sloutput
  831.     (
  832.     FAST struct ifnet   *ifp,           /* SLIP interface pointer */
  833.     FAST struct mbuf    *m,             /* SLIP packet to be sent out */
  834.     struct sockaddr     *dst,           /* address of the destination */
  835.     struct rtentry *rtp /* pointer to the route entry */
  836.     )
  837.     {
  838.     FAST SL_SOFTC *sc;
  839.     FAST struct ip *ip;
  840.     FAST int     s;
  841.     FAST int     unit;
  843.     if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
  844. {
  845.         m_freem (m);
  846.         return (ENETDOWN);
  847. }
  849.     /*
  850.      * Check and see if protocol family is equal to AF_INET.
  851.      * Currently only AF_INET is support for SLIP.
  852.      */
  853.     if (dst->sa_family != AF_INET)
  854.         {
  855.         m_freem (m);
  856. return (EAFNOSUPPORT);
  857.         }
  859.     unit = ifp->if_unit;
  861.     sc = sl_softc [unit];
  863.     /*
  864.      * n.b.-- the `40' below checks that we have a least a min length
  865.      * tcp/ip header contiguous in an mbuf.  We don't do `sizeof' on
  866.      * some struct because too many compilers add random padding.
  867.      */
  869.     if (sc->sc_flags & SL_COMPRESS) /* compress enabled ? */
  870. {
  871.         ip = mtod(m, struct ip *);
  873.         if ((ip->ip_p == IPPROTO_TCP) && (m->m_len >= 40))
  874.             *mtod(m, u_char *) |= sl_compress_tcp (m, ip, &sc->sc_comp, 1);
  875.         }
  877.     s = splimp ();
  879.     /*
  880.      * If send queue is full drop the packet.
  881.      */
  882.     if (IF_QFULL (&ifp->if_snd))
  883.         {
  884.         IF_DROP (&ifp->if_snd);
  885.         m_freem (m);
  886.         ++sc->sc_if.if_oerrors;
  887.         splx (s);
  889.         return (ENOBUFS);
  890.         }
  892.     /* enqueue the packet for IP module to read later */
  894.     IF_ENQUEUE (&ifp->if_snd, m);
  895.     ifp->if_lastchange = tickGet (); 
  897.     splx (s);
  899.     /* wake the SLIP ouput task to let it send out this packet */
  901.     semGive (sc->sc_wrtSem);
  903.     return (OK);
  904.     }
  906. /*******************************************************************************
  907. *
  908. * slipWrtTask - SLIP writer task
  909. *
  910. * This is our write side task.  It waits for a semaphore and
  911. * when sloutput() yields the semaphore, it will try to send out
  912. * the packet that's been queue up so far.  Each SLIP interface
  913. * has its own slipWrtTask which is spawned in slipInit().
  914. * Start output on interface.  Get another datagram
  915. * to send from the interface queue and map it to
  916. * the interface before starting output.
  917. *
  918. * NOMANUAL
  919. */
  921. void slipWrtTask
  922.     (
  923.     FAST SL_SOFTC *sc           /* SLIP softc pointer */
  924.     )
  925.     {
  926.     FAST struct mbuf  *m;
  927.     FAST u_char  *cp;
  928.     FAST int   len;
  929.     int     fd;
  930.     struct mbuf   *m2;
  931.     int   rdCount;
  932.     int   numch;
  933.     char   ch;
  934.     int   s;
  936.     fd = sc->sc_fd;
  938.     FOREVER
  939. {
  940. semTake (sc->sc_wrtSem, WAIT_FOREVER); /* sync w/ sloutput */
  942. FOREVER
  943.     {
  944.     /* get a packet off of the queue */
  946.     s = splimp ();
  947.     IF_DEQUEUE (&sc->sc_if.if_snd, m);
  948.     splx (s);
  950.     if (m == NULL)
  951. break;
  953.     /*
  954.      * Check if the serial line has been idle for awhile.
  955.      * If it has been idle for awhile, we send out a FRAME_END
  956.      * character to clear out any garbage in transit and start
  957.      * fresh with a new packet.  We find out whether or not
  958.      * the line has been idle for awhile by looking at the
  959.      * read side of the tty ring buffer queue.  It is assumed
  960.      * that if there is nothing to read from the queue, we
  961.      * must have been idle for awhile.  If our assumption
  962.      * is incorrect, we only have wasted the amount of work
  963.      * and bandwidth it takes to send a character over SLIP.
  964.      * More than likely, though, this is better than sending
  965.      * out a large packet and clobbering the whole packet
  966.      * because of the bad data.
  967.      */
  969.     (void) ioctl (fd, FIONREAD, (int) &rdCount);
  970.     if (rdCount == 0)
  971. {
  972. ch = FRAME_END;
  973. ++sc->sc_if.if_obytes;
  974. (void) write (fd, &ch, 1);
  975. }
  977.     /*
  978.      * send the packet.
  979.      */
  980.     while (m)
  981. {
  982. cp  = mtod (m, u_char *);
  983. len = m->m_len;
  985. while (len > 0)
  986.     {
  987.     /*
  988.      * Find out how many bytes in the string we can
  989.      * handle without doing something special.
  990.      */
  992.     if ((numch = numCharsToMask (FRAME_ESCAPE, FRAME_END,
  993. (u_int) len, cp)) > 0)
  994. {
  995. /*
  996.  * Put numch characters at once
  997.  * into the tty output queue.
  998.  */
  999. if (write (fd, (char *)cp, numch) != numch)
  1000.     break;
  1002. sc->sc_if.if_obytes += numch;
  1003. len -= numch;
  1004. cp  += numch;
  1005. }
  1007.     /*
  1008.      * If there are characters left in the mbuf,
  1009.      * the first one must be special..
  1010.      * Put it out in a different form.
  1011.      */
  1012.     if (len)
  1013. {
  1014. ch = FRAME_ESCAPE;
  1016. if (write (fd, &ch, 1) != 1)
  1017.     break;
  1019. ++sc->sc_if.if_obytes;
  1021. ch = (*cp == FRAME_ESCAPE) ?
  1022.      TRANS_FRAME_ESCAPE :
  1023.      TRANS_FRAME_END;
  1025. if (write (fd, &ch, 1) != 1)
  1026.     break;
  1028. ++sc->sc_if.if_obytes;
  1029. ++cp;
  1030. --len;
  1031. }
  1032.     }
  1034. m2 = m_free (m); 
  1035. m = m2;
  1036. }
  1038.    /*
  1039.     * indicate the end-of-packet.
  1040.     */
  1042.     ch = FRAME_END;
  1043.     if (write (fd, &ch, 1) != 1)
  1044. {
  1045. /*
  1046.  * This shouldn't happen but if it does we try one
  1047.  * more time (just for the hack of it) and increment
  1048.  * the if_collisions and if_oerrors.
  1049.  */
  1050. ch = FRAME_END;
  1051. (void) write (fd, &ch, 1);
  1052. sc->sc_if.if_collisions++;
  1053. sc->sc_if.if_oerrors++;
  1054. }
  1055.     else
  1056. {
  1057. ++sc->sc_if.if_obytes;
  1058. sc->sc_if.if_opackets++;
  1059. }
  1060.     }
  1061. }
  1062.     }
  1064. /*******************************************************************************
  1065. *
  1066. * slintr - SLIP tty protocol hook routine
  1067. *
  1068. * Called at interrupt level by the tty driver input nterrupt routine.
  1069. * It is our "protocol hook" routine set by an FIOPROTOHOOK ioctl() call.
  1070. * slintr() examines each character coming in and keeps a count
  1071. * of input characters in the ring buffer of the tty driver until
  1072. * a full packet is indicated by FRAME_END.
  1073. * When detected, enqueue a call to slread() via netJobAdd() to
  1074. * be processed later at task level.
  1075. * A net job will not be added if the first character of the packet
  1076. * won't fit into the ring buffer.  In that case the entire packet
  1077. * must be discarded at interrupt level.
  1078. *
  1079. * This routine will return FALSE to tyIRd() to indicate
  1080. * that normal processing should continue within tyIRd() when
  1081. * this routine returns.
  1082. *
  1083. * RETURNS: FALSE so tyIRd continues processing
  1084. */
  1086. LOCAL BOOL slintr
  1087.     (
  1088.     int unit,   /* SLIP unit number */
  1089.     int inchar  /* incoming character */
  1090.     )
  1091.     {
  1092.     FAST SL_SOFTC *sc = sl_softc [unit];
  1093.     TY_DEV * pTyDev;
  1094.     RING_ID ringId;
  1096.     /* Set discard flag if this is a new packet and ring buffer full */
  1098.     if ( sc->sc_qlen == 0 )
  1099. {
  1100.         pTyDev = (TY_DEV *) iosFdDevFind(sc->sc_fd);
  1101.         ringId = pTyDev->rdBuf;
  1102.         if (rngIsFull (ringId))
  1103.     sc->sc_flags |= SL_INTR_PACKET_DISCARD;
  1104.         else
  1105.     sc->sc_flags &= ~SL_INTR_PACKET_DISCARD;
  1106.         }
  1108.     ++sc->sc_qlen;
  1110.     if ((inchar & 0xff) == FRAME_END || sc->sc_qlen == SLBUF_HI)
  1111. {
  1112. /* schedule a read for this packet */
  1114.         if (sc->sc_flags & SL_INTR_PACKET_DISCARD)
  1115.     sc->sc_if.if_ierrors++;
  1116.         else
  1117.     {
  1118.     if (sc->sc_qlen == 1) /* Single FRAME_END character */
  1119. {
  1120. sc->sc_qlen = 0;
  1121. return (TRUE);          /* Don't put it in ring buffer */
  1122. }
  1123.             else
  1124.         (void) netJobAdd ((FUNCPTR) slread, (int) sc, sc->sc_qlen, 
  1125.   0, 0, 0);
  1126.             }
  1127. sc->sc_qlen = 0;
  1128. }
  1130.     return (FALSE); /* continue ty processing */
  1131.     }
  1133. /*******************************************************************************
  1134. *
  1135. * slread - read a whole SLIP packet and call slinput to process each char
  1136. *
  1137. * slread() is called only when FRAME_END is encountered when
  1138. * we have a SLIP packet waiting for us to read in the tty's
  1139. * input ring buffer.
  1140. */
  1142. LOCAL void slread
  1143.     (
  1144.     FAST SL_SOFTC *sc,  /* SLIP interface */
  1145.     FAST int count      /* number of characters to be read */
  1146.     )
  1147.     {
  1148.     BOOL firstCluster = TRUE;
  1149.     char *builtCluster;
  1150.     char *nextBuf = sc->sc_buf;
  1151.     FAST u_char *c1 = (u_char *) sc->sc_buf;
  1152.     FAST u_char *c2 = c1;
  1153.     FAST u_char *end;
  1154.     int len;
  1156.     if ((len = read (sc->sc_fd, sc->sc_buf, count)) == 0)
  1157. return;
  1158.     end = (u_char *) (sc->sc_buf + len);
  1160.     while (c1 < end)
  1161. {
  1162. ++sc->sc_if.if_ibytes; /* increment the recieved bytes */
  1163.         
  1164. if (sc->sc_ilen > sc->sc_if.if_mtu)
  1165.             {
  1166.     sc->sc_if.if_ierrors++;
  1167.     break;
  1168.     }
  1170. switch (*c1)
  1171.     {
  1172.     case FRAME_END:
  1173.         {
  1174.                 if (sc->sc_ilen > 0)
  1175.     {
  1176.             if ((builtCluster = slRecv (sc, firstCluster)) != NULL)
  1177.         {
  1178.         nextBuf = builtCluster;
  1179.         firstCluster = FALSE;
  1180. }
  1181.                     sc->sc_ilen = 0;
  1182.     }
  1184.         sc->sc_buf = (char *) ++c1;
  1185. c2 = c1;
  1186. break;
  1187.         }
  1188.     case FRAME_ESCAPE:
  1189. {
  1190. c1++;
  1191.         if (*c1 == TRANS_FRAME_ESCAPE)
  1192.             *c1 = FRAME_ESCAPE;
  1193.         else if (*c1 == TRANS_FRAME_END)
  1194.     *c1 = FRAME_END;
  1195.         else 
  1196.     {
  1197.             sc->sc_if.if_ierrors++;
  1198.                     sc->sc_ilen = 0;
  1199.             sc->sc_buf = (char *) c1;
  1200.     c2 = c1;
  1201.     break;
  1202.     }
  1203. }
  1204.             default:
  1205. {
  1206. sc->sc_ilen++;
  1207.                 *c2++ = *c1++;
  1208. }
  1209.             }
  1210. }
  1212.     sc->sc_buf = nextBuf;
  1213.     sc->sc_ilen = 0;
  1214.     }
  1216. /*******************************************************************************
  1217. *
  1218. * slRecv - process an input frame
  1219. *
  1220. * This routine processes an input frame, then passes it up to the higher
  1221. * level in a form it expects.  Buffer loaning, etherInputHookRtns, and
  1222. * CSLIP uncompression are all supported.  Trailer protocols are not supported.
  1223. *
  1224. * RETURNS: N/A
  1225. */
  1227. LOCAL char *slRecv
  1228.     (
  1229.     FAST SL_SOFTC *sc, /* SLIP interface */
  1230.     BOOL firstCluster
  1231.     )
  1232.     {
  1233.     FAST  struct mbuf *m = NULL;
  1234.     FAST  char type;
  1235.     char  *nextBuf = NULL;
  1236.     char  *origBuf = sc->sc_buf;
  1237.     UINT8 *origRef = sc->sc_pRefC[(sc->sc_nLoanRxBuf - 1)];
  1239.     type = *sc->sc_buf & 0xf0;
  1240.     if (type != (IPVERSION << 4))
  1241.         {
  1242.         if (type & 0x80)
  1243.     type = TYPE_COMPRESSED_TCP;
  1244.         else if (type == TYPE_UNCOMPRESSED_TCP)
  1245.             *sc->sc_buf &= 0x4f;
  1247.         /*
  1248.          * we've got something that's not an IP packet.
  1249.          * If compression is enabled, try to uncompress
  1250.          * it.  Otherwise, if `auto-enable' compression
  1251.          * is on and it's a reasonable packet,
  1252.          * uncompress it then enable compression.
  1253.          * Otherwise, drop it.
  1254.          */
  1256.         if ((sc->sc_flags & SL_COMPRESS) || ((sc->sc_flags & SL_COMPRESS_RX) &&
  1257.              (type == TYPE_UNCOMPRESSED_TCP) && (sc->sc_ilen >= 40)))
  1258.     {
  1259.             if ((sc->sc_ilen = sl_uncompress_tcp ((u_char **)&sc->sc_buf, 
  1260.   sc->sc_ilen, (u_int) type,
  1261.   &sc->sc_comp)) <= 0)
  1262.                 {
  1263.         sc->sc_if.if_ierrors++;
  1264.         return (NULL);
  1265.                 }
  1267.             sc->sc_flags |= SL_COMPRESS;
  1268.             }
  1269.         else
  1270.             {
  1271.     sc->sc_if.if_ierrors++;
  1272.     return (NULL);
  1273.             }
  1274.         }
  1276.     if ((etherInputHookRtn != NULL) && ((*etherInputHookRtn)
  1277.         (&sc->sc_if, sc->sc_buf, sc->sc_ilen) != 0))
  1278.         return (NULL);
  1280.     if ((firstCluster) && (sc->sc_nLoanRxBuf > 0) &&
  1281. (USE_CLUSTER (sc->sc_ilen)))
  1282.         m = build_cluster (sc->sc_buf, sc->sc_ilen, &sc->sc_if,
  1283.             MC_SL, sc->sc_pRefC[(sc->sc_nLoanRxBuf - 1)], 
  1284.     (FUNCPTR) slLoanFree, (int) sc, (int) origBuf, (int) origRef);
  1286.     /* if buffer was successfully turned into mbuf cluster */
  1287.  
  1288.     if (m != NULL)
  1289.         nextBuf = sc->sc_lPool[--sc->sc_nLoanRxBuf];
  1290.     else
  1291.         {
  1292.         /* else do same ol' copy to mbuf */
  1294.         m = copy_to_mbufs (sc->sc_buf, sc->sc_ilen, 0, &sc->sc_if);
  1295. if (m == NULL)
  1296.     {
  1297.     sc->sc_if.if_ierrors++;
  1298.     return (NULL);
  1299.             }
  1300.         }
  1302.     /* send up to protocol */
  1304.     sc->sc_if.if_ipackets++;
  1305.     sc->sc_if.if_lastchange = tickGet(); 
  1307.     ipintr (m);
  1309.     return (nextBuf);
  1310.     }
  1312. /*******************************************************************************
  1313. *
  1314. * slioctl - SLIP ioctl routine
  1315. *
  1316. * Process an ioctl request.
  1317. *
  1318. * RETURNS: 0 or errno
  1319. */
  1321. LOCAL int slioctl
  1322.     (
  1323.     FAST struct ifnet *ifp,     /* pointer to SLIP interface */
  1324.     int cmd,                    /* command */
  1325.     caddr_t data                /* data */
  1326.     )
  1327.     {
  1328.     FAST struct ifaddr * ifa = (struct ifaddr *)data;
  1329.     FAST struct ifreq * ifr;
  1330.     int error = 0;
  1331.     int  s;
  1333.     s = splimp ();
  1335.     switch (cmd)
  1336.         {
  1337.         case SIOCGIFFLAGS:
  1338.             *(short *)data = ifp->if_flags;
  1339.             break;
  1341.         case SIOCSIFADDR:
  1342.     if (ifa->ifa_addr->sa_family == AF_INET)
  1343.                 {
  1344. slinit (ifp->if_unit);
  1345.                 ifa->ifa_rtrequest = slRtRequest;
  1346.                 }
  1347.     else
  1348. error = EAFNOSUPPORT;
  1349.     break;
  1351. case SIOCSIFDSTADDR:
  1352.             if (ifa->ifa_dstaddr->sa_family != AF_INET)
  1353. error = EAFNOSUPPORT;
  1354.         break;
  1356. case SIOCADDMULTI:
  1357. case SIOCDELMULTI:
  1358.     ifr = (struct ifreq *)data;
  1359.     if (ifr == 0) 
  1360. {
  1361. error = EAFNOSUPPORT; /* XXX */
  1362. break;
  1363. }
  1364.     switch (ifr->ifr_addr.sa_family)
  1365. {
  1366. #ifdef INET
  1367. case AF_INET:
  1368.     break;
  1369. #endif
  1370. default:
  1371.     error = EAFNOSUPPORT;
  1372.     break;
  1373. }
  1374.     break;
  1376.         default:
  1377.          error = EINVAL;
  1378.         }
  1380.     splx (s);
  1382.     return (error);
  1383.     }
  1385. /*******************************************************************************
  1386. *
  1387. * numCharsToMask - scan the buffer for a mask
  1388. *
  1389. * numcharsToMask finds out how many characters are in a string
  1390. * before a character that matches the 'mask'.
  1391. *
  1392. * RETURNS: number of chars up to the mask
  1393. */
  1395. LOCAL int numCharsToMask
  1396.     (
  1397.     FAST u_char mask1,
  1398.     FAST u_char mask2,
  1399.     u_int size,
  1400.     FAST u_char *cp
  1401.     )
  1402.     {
  1403.     FAST u_char *end = &cp [size];
  1404.     u_char *start = cp;
  1406.     while ((cp < end) && (*cp != mask1) && (*cp != mask2))
  1407.      cp++;
  1409.     return (cp - start);
  1410.     }
  1412. /********************************************************************************
  1413. * slLoanFree - return the given buffer to loaner pool
  1414. *
  1415. * This routine returns <pRxBuf> to the pool of available loaner buffers.
  1416. * It also returns <pRef> to the pool of available loaner reference counters,
  1417. * then zeroes the reference count.
  1418. *
  1419. * RETURNS: N/A
  1420. */
  1421.  
  1422. LOCAL void slLoanFree
  1423.     (
  1424.     SL_SOFTC *sc,
  1425.     char *pRxBuf,
  1426.     UINT8 *pRef
  1427.     )
  1428.     {
  1429.     /* return loaned buffer to pool */
  1431.     sc->sc_lPool[sc->sc_nLoanRxBuf] = pRxBuf;
  1432.  
  1433.     /* return loaned reference count to pool */
  1434.  
  1435.     sc->sc_pRefC[sc->sc_nLoanRxBuf++] = pRef;
  1436.  
  1437.     /* reset reference count - should have been done from above, but... */
  1438.  
  1439.     *pRef = 0;
  1440.     }
  1442. /*******************************************************************************
  1443. *
  1444. * slRtRequest - perform special routing.
  1445. *
  1446. * This function performs special processing when adding a route to itself
  1447. * on a slip interface. It intializes the interface pointer to the loop back
  1448. * so that the packet can be rerouted through the loopback instead of actually
  1449. * sending the packet out on the wire and have the other end loop back the
  1450. * packet. The capability can be turned off by intializing the global flag
  1451. * slipLoopBack to 0. By default it is turned on. 
  1452. *
  1453. * NOMANUAL
  1454. *
  1455. * RETURNS: N/A
  1456. */
  1458. static void slRtRequest
  1459.     (
  1460.     int  cmd, /* route command */
  1461.     struct rtentry *  pRtEntry, /* pointer to the route entry */
  1462.     struct sockaddr *  pSockAddr /* pointer to the sock addr */
  1463.     )
  1464.     {
  1465.     /* only when adding a route to itself */
  1467.     if (cmd == RTM_ADD)
  1468.         {
  1469.         if (slipLoopBack && (pRtEntry->rt_flags & RTF_HOST) &&
  1470.             (SIN(rt_key(pRtEntry))->sin_addr.s_addr ==
  1471.              (IA_SIN(pRtEntry->rt_ifa))->sin_addr.s_addr))
  1472.             {
  1473.             pRtEntry->rt_rmx.rmx_expire = 0;
  1474.             pRtEntry->rt_ifp = &loif; /* initialize to the loop back */ 
  1475.             }
  1476.         }
  1477.     }