home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 2 / amigaformatcd02.iso / comms / netsoftware / cslip.lha / usr / sys / amiga / driver / slip.c-diff < prev   
Encoding:
Text File  |  1992-11-11  |  15.1 KB  |  527 lines
  1. *** cslip.c    Fri Nov  6 03:54:11 1992
  2. --- cslip.c.new    Fri Nov  6 17:07:20 1992
  3. ***************
  4. *** 10,15 ****
  5. --- 10,19 ----
  6.    * time and always left open.  To do slattach, a module is pushed
  7.    * on a tty device and an ioctl done on it to find out which slip
  8.    * interface should be started up using ifconfig(1).
  9. +  *
  10. +  * 92-11-6:
  11. +  * V1.1  Markus Wild  integrated TCP header compression and added code
  12. +  *                    to favor interactive traffic over regular traffic
  13.    */
  14.   
  15.   #include "sys/types.h"
  16. ***************
  17. *** 34,46 ****
  18. --- 38,72 ----
  19.   #include "netinet/in.h"
  20.   #include "netinet/in_var.h"
  21.   #include "netinet/ip_str.h"
  22. + #include "netinet/in_systm.h"
  23. + #include "netinet/ip.h"
  24. + #include "netinet/tcp.h"
  25.   
  26.   extern struct ifstats    *ifstats;    /* per-interface statistics for inet */
  27.   
  28. + #include "slcompress.h"
  29.   #include "slip.h"
  30.   
  31. + /* the code to deal with interactive traffic is from the cslip reference
  32. +    code, sunos/ directory (for streams) */
  33. + 
  34. + /*
  35. +  * The following hack gets around the problem that IP TOS
  36. +  * can't be set in BSD/Sun OS yet.  We want to put "interactive"
  37. +  * traffic on a high priority queue.  To decide if traffic is
  38. +  * interactive, we check that a) it is TCP and b) one of it's ports
  39. +  * if telnet, rlogin or ftp control.
  40. +  */
  41. + static u_short interactive_ports[8] = {
  42. +     0,    513,    0,    0,
  43. +     0,    21,    0,    23,
  44. + };
  45. + #define INTERACTIVE(p) (interactive_ports[(p) & 7] == (p))
  46. + 
  47.   
  48.   #define SLIP_WHICH_INTERFACE 'slwh'
  49. + #define SLIP_GET_CONF_FLAGS  'slgc'
  50. + #define SLIP_SET_CONF_FLAGS  'slsc'
  51.   
  52.   #define SLIP_DLPI_MID    'SD'        /* DLPI Module ID */
  53.   #define SLIP_TTY_MID    'ST'        /* TTY Module ID */
  54. ***************
  55. *** 47,56 ****
  56. --- 73,145 ----
  57.   
  58.   #define SLIP_MAXDEV    5        /* Maximum number of simultaneous */
  59.                       /* active SLIP interfaces. */
  60. + 
  61. + /* explanatory text to the BSD code. I used the suggested MTU, but am
  62. +  * for now using a much higher hi/lo-water pair (seems streams-specific) */
  63. + 
  64. + /*
  65. +  * SLMAX is a hard limit on input packet size.  To simplify the code
  66. +  * and improve performance, we require that packets fit in an mbuf
  67. +  * cluster, and if we get a compressed packet, there's enough extra
  68. +  * room to expand the header into a max length tcp/ip header (128
  69. +  * bytes).  So, SLMAX can be at most
  70. +  *    MCLBYTES - 128
  71. +  *
  72. +  * SLMTU is a hard limit on output packet size.  To insure good
  73. +  * interactive response, SLMTU wants to be the smallest size that
  74. +  * amortizes the header cost.  (Remember that even with
  75. +  * type-of-service queuing, we have to wait for any in-progress
  76. +  * packet to finish.  I.e., we wait, on the average, 1/2 * mtu /
  77. +  * cps, where cps is the line speed in characters per second.
  78. +  * E.g., 533ms wait for a 1024 byte MTU on a 9600 baud line.  The
  79. +  * average compressed header size is 6-8 bytes so any MTU > 90
  80. +  * bytes will give us 90% of the line bandwidth.  A 100ms wait is
  81. +  * tolerable (500ms is not), so want an MTU around 296.  (Since TCP
  82. +  * will send 256 byte segments (to allow for 40 byte headers), the
  83. +  * typical packet size on the wire will be around 260 bytes).  In
  84. +  * 4.3tahoe+ systems, we can set an MTU in a route so we do that &
  85. +  * leave the interface MTU relatively high (so we don't IP fragment
  86. +  * when acting as a gateway to someone using a stupid MTU).
  87. +  *
  88. +  * Similar considerations apply to SLIP_HIWAT:  It's the amount of
  89. +  * data that will be queued 'downstream' of us (i.e., in clists
  90. +  * waiting to be picked up by the tty output interrupt).  If we
  91. +  * queue a lot of data downstream, it's immune to our t.o.s. queuing.
  92. +  * E.g., if SLIP_HIWAT is 1024, the interactive traffic in mixed
  93. +  * telnet/ftp will see a 1 sec wait, independent of the mtu (the
  94. +  * wait is dependent on the ftp window size but that's typically
  95. +  * 1k - 4k).  So, we want SLIP_HIWAT just big enough to amortize
  96. +  * the cost (in idle time on the wire) of the tty driver running
  97. +  * off the end of its clists & having to call back slstart for a
  98. +  * new packet.  For a tty interface with any buffering at all, this
  99. +  * cost will be zero.  Even with a totally brain dead interface (like
  100. +  * the one on a typical workstation), the cost will be <= 1 character
  101. +  * time.  So, setting SLIP_HIWAT to ~100 guarantees that we'll lose
  102. +  * at most 1% while maintaining good interactive response.
  103. +  */
  104. + #if 0 /* BSD implementation constants described in above text */
  105. + #define BUFOFFSET    128
  106. + #define    SLMAX        (MCLBYTES - BUFOFFSET)
  107. + #define    SLBUFSIZE    (SLMAX + BUFOFFSET)
  108. + #define    SLMTU        296
  109. + #define    SLIP_HIWAT    roundup(50,CBSIZE)
  110. + #define    CLISTRESERVE    1024    /* Can't let clists get too low */
  111. + #else
  112. + #ifdef COMMODORE_PARAMETERS
  113.   #define    SLIP_MIN    1
  114.   #define SLIP_MAX    1006        /* Is this some sort of standard? */
  115. + #define SLIP_MTU    SLIP_MAX
  116.   #define SLIP_HIWAT    2048
  117.   #define SLIP_LOWAT    (2*SLIP_HIWAT/3)
  118. + #else
  119. + #define    SLIP_MIN    1
  120. + #define SLIP_MAX    1006        /* Is this some sort of standard? */
  121. + #define SLIP_MTU    296
  122. + #define SLIP_HIWAT    100
  123. + #define SLIP_LOWAT    (2*SLIP_HIWAT/3)
  124. + #endif
  125. + #define BUFOFFSET    128        /* room for decompressed header */
  126. + #endif
  127.   
  128.   struct slipdev
  129.   {
  130. ***************
  131. *** 62,69 ****
  132. --- 151,167 ----
  133.       char ifname[20];
  134.       mblk_t *curblk;            /* Input packet being assembled */
  135.       int escaped;            /* Last character was ESCAPE */
  136. + 
  137. +     u_int sc_flags;            /* see below */
  138. +     struct slcompress sc_comp;        /* tcp compression data */
  139. +     mblk_t *lastpriopkt;        /* last priority interactive message */
  140.   };
  141.   
  142. + /* visible flags */
  143. + #define    SC_COMPRESS    0x0002        /* compress TCP traffic */
  144. + #define    SC_NOICMP    0x0004        /* supress ICMP traffic */
  145. + #define    SC_AUTOCOMP    0x0008        /* auto-enable TCP compression */
  146. + 
  147.   
  148.   /*
  149.    *  DLPI stream data structure definitions
  150. ***************
  151. *** 75,81 ****
  152. --- 173,184 ----
  153.   
  154.   static struct module_info dlpi_minfo =
  155.   {
  156. + #ifdef COMMODORE_PARAMETERS
  157.       SLIP_DLPI_MID, "sld", SLIP_MIN, SLIP_MAX, SLIP_HIWAT, SLIP_LOWAT,
  158. + #else
  159. +     /* these parameters are from the SunOS streams code, who is right?? */
  160. +     SLIP_DLPI_MID, "sld", 0, INFPSZ, 16384, 4096,
  161. + #endif
  162.   };
  163.   
  164.   static struct qinit dlpirinit =
  165. ***************
  166. *** 101,107 ****
  167. --- 204,214 ----
  168.   
  169.   static struct module_info tty_minfo =
  170.   {
  171. + #ifdef COMMODORE_PARAMETERS
  172.       SLIP_TTY_MID, "slipmod", SLIP_MIN, SLIP_MAX, SLIP_HIWAT, SLIP_LOWAT,
  173. + #else
  174. +     SLIP_TTY_MID, "slipmod", 0, INFPSZ, 16384, 4096,
  175. + #endif
  176.   };
  177.   
  178.   static struct qinit ttyrinit =
  179. ***************
  180. *** 164,170 ****
  181.       }
  182.   
  183.       slip->stats.ifs_active = 1;
  184. !     slip->stats.ifs_mtu = SLIP_MAX;
  185.       slip->stats.ifs_ipackets =
  186.           slip->stats.ifs_ierrors =
  187.           slip->stats.ifs_opackets =
  188. --- 271,277 ----
  189.       }
  190.   
  191.       slip->stats.ifs_active = 1;
  192. !     slip->stats.ifs_mtu = SLIP_MTU;
  193.       slip->stats.ifs_ipackets =
  194.           slip->stats.ifs_ierrors =
  195.           slip->stats.ifs_opackets =
  196. ***************
  197. *** 172,177 ****
  198. --- 279,289 ----
  199.   
  200.       WR(rq)->q_ptr = rq->q_ptr = (caddr_t)slip;
  201.       slip->dlpiq = rq;
  202. + 
  203. +     /* seems like a reasonable default to me */
  204. +     slip->sc_flags = SC_AUTOCOMP;
  205. +     sl_compress_init (& slip->sc_comp);
  206. +     slip->lastpriopkt = 0;
  207.       }
  208.   
  209.       return 0;
  210. ***************
  211. *** 448,454 ****
  212.   register struct slipdev *slip;
  213.   mblk_t *dlpimp;
  214.   {
  215. !     mblk_t *bp, *outmp;
  216.   
  217.       if (!canput(WR(slip->ttyq)))
  218.       return 0;
  219. --- 560,568 ----
  220.   register struct slipdev *slip;
  221.   mblk_t *dlpimp;
  222.   {
  223. !     mblk_t *bp, *outmp, *tmpmp=0;
  224. !     struct ip *ip;
  225. !     int s, p, hiprio;
  226.   
  227.       if (!canput(WR(slip->ttyq)))
  228.       return 0;
  229. ***************
  230. *** 461,469 ****
  231.       }
  232.       outmp->b_datap->db_type = M_DATA;
  233.   
  234.   #define putc(ch) (*outmp->b_wptr++ = (ch))
  235.       /* Copy input to output, escaping special characters */
  236. !     for ( bp=dlpimp->b_cont ; bp ; bp=bp->b_cont )
  237.       while (bp->b_wptr > bp->b_rptr)
  238.       {
  239.           unsigned char c = *bp->b_rptr++;
  240. --- 575,624 ----
  241.       }
  242.       outmp->b_datap->db_type = M_DATA;
  243.   
  244. +     ip = (struct ip *)(dlpimp->b_cont->b_rptr);
  245. +     hiprio = 0;
  246. +     if (ip->ip_p == IPPROTO_TCP)
  247. +       {
  248. +     if (slip->sc_flags & SC_COMPRESS)
  249. +       {
  250. +         /* copy over the chain of mblk_t into one buffer. This is to
  251. +            make sure the compression code can assume the whole mess
  252. +            is one packet. It probably would do to just convert the
  253. +            first buffer, but since I don't have any documentation to
  254. +            mblk_t internals.. */
  255. +         if (!(tmpmp = allocb (SLIP_MAX, BPRI_MED)))
  256. +           {
  257. +         ++slip->stats.ifs_oerrors;
  258. +         freemsg (outmp);
  259. +         return 0;
  260. +           }
  261. +         for (bp = dlpimp->b_cont; bp; bp = bp->b_cont)
  262. +           while (bp->b_wptr > bp->b_rptr)
  263. +         *tmpmp->b_wptr++ = *bp->b_rptr++;
  264. + 
  265. +         /* ok, compress the sucker */
  266. +         ip = (struct ip *) tmpmp->b_rptr;
  267. +         p = ((int *)ip)[ip->ip_hl];
  268. +         hiprio = INTERACTIVE(p & 0xffff) || INTERACTIVE(p >> 16);
  269. +         p = sl_compress_tcp (tmpmp, ip, &slip->sc_comp, hiprio);
  270. +         *(u_char *) tmpmp->b_rptr |= p; /* what the ... */
  271. +         bp = tmpmp;
  272. +       }
  273. +     else if ((slip->sc_flags & SC_NOICMP) && ip->ip_p == IPPROTO_ICMP)
  274. +       {
  275. +         freemsg (tmpmp);
  276. +         freemsg (outmp);
  277. +         return 0;
  278. +       }
  279. +     else
  280. +       bp = dlpimp->b_cont;
  281. +       }
  282. +     else
  283. +       bp = dlpimp->b_cont;
  284. + 
  285.   #define putc(ch) (*outmp->b_wptr++ = (ch))
  286.       /* Copy input to output, escaping special characters */
  287. !     for ( ; bp ; bp=bp->b_cont )
  288.       while (bp->b_wptr > bp->b_rptr)
  289.       {
  290.           unsigned char c = *bp->b_rptr++;
  291. ***************
  292. *** 489,497 ****
  293.   #undef putc
  294.   
  295.       ++slip->stats.ifs_opackets;
  296.       putnext(WR(slip->ttyq), outmp);
  297. !     freemsg(dlpimp);
  298.   
  299.       return 1;
  300.   }
  301.   
  302. --- 644,694 ----
  303.   #undef putc
  304.   
  305.       ++slip->stats.ifs_opackets;
  306. + #if 1
  307. +     /* then queue it for later transmission through the port */
  308. +     s = splstr();
  309. +     if (WR(slip->ttyq)) 
  310. +       {    /* inside splstr() in case WR(slip->ttyq) = 0 */
  311. +     if (hiprio) 
  312. +       {    /* macchiavelli mode */
  313. +         register mblk_t    *tp = WR(slip->ttyq)->q_next->q_first;
  314. +         /*
  315. +          * We want this packet to come before other
  316. +          * IP packets but after other TELNET/LOGINSERVER
  317. +          * packets, ignoring real priority messages.
  318. +          */
  319. +         for (; tp != NULL; tp = tp->b_next)
  320. +           if (tp == slip->lastpriopkt)
  321. +         break;
  322. +         if (tp == NULL)
  323. +           tp = WR(slip->ttyq)->q_next->q_first;
  324. +         if (tp == NULL)
  325. +           /* since insq doesn't schedule the q! */
  326. +           putnext(WR(slip->ttyq), outmp);
  327. +         else
  328. +           insq(WR(slip->ttyq)->q_next, tp, outmp);
  329. +         slip->lastpriopkt = outmp;
  330. +       } 
  331. +     else
  332. +       putnext(WR(slip->ttyq), outmp);
  333. +       } 
  334. +     else
  335. +       {
  336. +     freemsg(outmp);
  337. +     outmp = 0;
  338. +       }
  339. +     (void) splx(s);
  340. + #else
  341.       putnext(WR(slip->ttyq), outmp);
  342. ! #endif
  343. !     if (tmpmp)
  344. !       freemsg (tmpmp);
  345.   
  346. +     if (outmp)
  347. +       freemsg(dlpimp);
  348. +     else
  349. +       return 0;
  350. + 
  351.       return 1;
  352.   }
  353.   
  354. ***************
  355. *** 634,639 ****
  356. --- 831,837 ----
  357.   {
  358.       register struct slipdev *slip = (struct slipdev *)q->q_ptr;
  359.       struct iocblk *iocbp = (struct iocblk *)mp->b_rptr;
  360. +     int s;
  361.   
  362.       switch (iocbp->ioc_cmd)
  363.       {
  364. ***************
  365. *** 640,645 ****
  366. --- 838,868 ----
  367.       case SLIP_WHICH_INTERFACE:
  368.       RETURN(M_IOCACK, slip-sliptab, 0);
  369.   
  370. +     case SLIP_GET_CONF_FLAGS:
  371. +     RETURN(M_IOCACK, slip->sc_flags, 0);
  372. + 
  373. +     case SLIP_SET_CONF_FLAGS:
  374. +     if (iocbp->ioc_count == TRANSPARENT)
  375. +       {
  376. +         slip->sc_flags = (*(long *)mp->b_cont->b_rptr) & 0xffff;
  377. + /*        printf("sl: setting flags 0x%x\n", slip->sc_flags);*/
  378. +         freemsg (mp->b_cont);
  379. +         mp->b_cont = 0;
  380. +         RETURN(M_IOCACK, 0, 0);
  381. +       }
  382. +     else
  383. +       {
  384. +         /* fail if I_STR (from streams guide) */
  385. +         if (mp->b_cont)
  386. +           {
  387. +         freemsg (mp->b_cont);
  388. +         mp->b_cont = 0;
  389. +           }
  390. +         mp->b_datap->db_type = M_IOCNAK;
  391. +         qreply (q, mp);
  392. +         break;
  393. +       }
  394. + 
  395.       default:
  396.       RETURN(M_IOCNAK, 0, EINVAL);
  397.       }
  398. ***************
  399. *** 681,702 ****
  400.               {
  401.               mblk_t *dlpimp;
  402.               register dl_unitdata_ind_t *udp;
  403.               dlpimp = allocb(sizeof *udp, BPRI_MED);
  404.               if (dlpimp)
  405. !             {
  406. !                 udp = (dl_unitdata_ind_t *)dlpimp->b_wptr;
  407. !                 udp->dl_primitive = DL_UNITDATA_IND;
  408. !                 udp->dl_dest_addr_length = 0;
  409. !                 udp->dl_dest_addr_offset = sizeof *udp;
  410. !                 udp->dl_src_addr_length = 0;
  411. !                 udp->dl_src_addr_offset = sizeof *udp;
  412. !                 udp->dl_reserved = 0;
  413. ! 
  414. !                 dlpimp->b_wptr += sizeof *udp;
  415. !                 dlpimp->b_datap->db_type = M_PROTO;
  416. !                 dlpimp->b_cont = outmp;
  417. !                 ++slip->stats.ifs_ipackets;
  418. !                 putnext(slip->dlpiq, dlpimp);
  419.               }
  420.               else
  421.                   freemsg(outmp);
  422. --- 904,965 ----
  423.               {
  424.               mblk_t *dlpimp;
  425.               register dl_unitdata_ind_t *udp;
  426. +             int c;
  427. + 
  428.               dlpimp = allocb(sizeof *udp, BPRI_MED);
  429.               if (dlpimp)
  430. !               {
  431. !                 int ok = 1;
  432. !                 
  433. !                 if ((c = (*outmp->b_rptr & 0xf0)) != 
  434. !                 (IPVERSION << 4)) 
  435. !                   {
  436. !                 if (c & 0x80)
  437. !                   c = TYPE_COMPRESSED_TCP;
  438. !                 else if (c == TYPE_UNCOMPRESSED_TCP)
  439. !                   *outmp->b_rptr &= 0x4f; /* XXX */
  440. !                 /*
  441. !                  * We've got something that's not an IP packet.
  442. !                  * If compression is enabled, try to decompress it.
  443. !                  * Otherwise, if `auto-enable' compression is on and
  444. !                  * it's a reasonable packet, decompress it and then
  445. !                  * enable compression.  Otherwise, drop it.
  446. !                  */
  447. !                 if (slip->sc_flags & SC_COMPRESS) 
  448. !                   ok = sl_uncompress_tcp (outmp, (u_int)c, 
  449. !                               &slip->sc_comp);
  450. !                 else if ((slip->sc_flags & SC_AUTOCOMP) &&
  451. !                      c == TYPE_UNCOMPRESSED_TCP && 
  452. !                      outmp->b_wptr - outmp->b_rptr >= 40) 
  453. !                   {
  454. !                     ok = sl_uncompress_tcp (outmp, (u_int)c, 
  455. !                                 &slip->sc_comp);
  456. !                     if (ok > 0)
  457. !                       slip->sc_flags |= SC_COMPRESS;
  458. !                   } 
  459. !                   }
  460. !                 
  461. !                 if (ok <= 0)
  462. !                   {
  463. !                 freemsg (outmp);
  464. !                 freemsg (dlpimp);
  465. !                   }
  466. !                 else
  467. !                   {
  468. !                 udp = (dl_unitdata_ind_t *)dlpimp->b_wptr;
  469. !                 udp->dl_primitive = DL_UNITDATA_IND;
  470. !                 udp->dl_dest_addr_length = 0;
  471. !                 udp->dl_dest_addr_offset = sizeof *udp;
  472. !                 udp->dl_src_addr_length = 0;
  473. !                 udp->dl_src_addr_offset = sizeof *udp;
  474. !                 udp->dl_reserved = 0;
  475. !                 
  476. !                 dlpimp->b_wptr += sizeof *udp;
  477. !                 dlpimp->b_datap->db_type = M_PROTO;
  478. !                 dlpimp->b_cont = outmp;
  479. !                 ++slip->stats.ifs_ipackets;
  480. !                 putnext(slip->dlpiq, dlpimp);
  481. !                   }
  482.               }
  483.               else
  484.                   freemsg(outmp);
  485. ***************
  486. *** 727,734 ****
  487.   
  488.               /* if packet is too large, drop it and start over */
  489.               if (!outmp)
  490. !             if (outmp=allocb(SLIP_MAX, BPRI_MED))
  491.                   slip->curblk = outmp;
  492.               else
  493.               {
  494.                   ++slip->stats.ifs_ierrors;
  495. --- 990,1003 ----
  496.   
  497.               /* if packet is too large, drop it and start over */
  498.               if (!outmp)
  499. !             if (outmp=allocb(SLIP_MAX+BUFOFFSET, BPRI_MED))
  500. !               {
  501.                   slip->curblk = outmp;
  502. +                 /* make a hole to possibly insert a decompressed
  503. +                    header */
  504. +                 outmp->b_wptr = outmp->b_rptr = 
  505. +                   outmp->b_datap->db_base + BUFOFFSET;
  506. +               }
  507.               else
  508.               {
  509.                   ++slip->stats.ifs_ierrors;
  510. ***************
  511. *** 739,745 ****
  512.               {
  513.                   ++slip->stats.ifs_ierrors;
  514.                   outmp->b_wptr = outmp->b_rptr =
  515. !                 outmp->b_datap->db_base;
  516.               }
  517.   
  518.               *outmp->b_wptr++ = c;
  519. --- 1008,1014 ----
  520.               {
  521.                   ++slip->stats.ifs_ierrors;
  522.                   outmp->b_wptr = outmp->b_rptr =
  523. !                 outmp->b_datap->db_base + BUFOFFSET;
  524.               }
  525.   
  526.               *outmp->b_wptr++ = c;
  527.