usr.sbin/IPXrouted/output.c

   1 /*
   2  * Copyright (c) 1985, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Copyright (c) 1995 John Hay.  All rights reserved.
   6  *
   7  * This file includes significant work done at Cornell University by
   8  * Bill Nesheim.  That work included by permission.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by the University of
  21  *      California, Berkeley and its contributors.
  22  * 4. Neither the name of the University nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  *
  38  * $FreeBSD: src/usr.sbin/IPXrouted/output.c,v 1.8 1999/08/28 01:15:03 peter Exp $
  39  * $DragonFly: src/usr.sbin/IPXrouted/output.c,v 1.2 2003/06/17 04:29:52 dillon Exp $
  40  *
  41  * @(#)output.c 8.1 (Berkeley) 6/5/93
  42  */
  43
  44 /*
  45  * Routing Table Management Daemon
  46  */
  47 #include <unistd.h>
  48 #include "defs.h"
  49
  50 /*
  51  * Apply the function "f" to all non-passive
  52  * interfaces.  If the interface supports the
  53  * use of broadcasting use it, otherwise address
  54  * the output to the known router.
  55  */
  56 void
  57 toall(f, except, changesonly)
  58         void (*f)(struct sockaddr *, int, struct interface *, int);
  59         struct rt_entry *except;
  60         int changesonly;
  61 {
  62         register struct interface *ifp;
  63         register struct sockaddr *dst;
  64         register int flags;
  65         register struct rt_entry *trt;
  66         int onlist;
  67         extern struct interface *ifnet;
  68
  69         for (ifp = ifnet; ifp; ifp = ifp->int_next) {
  70                 if (ifp->int_flags & IFF_PASSIVE)
  71                         continue;
  72
  73                 /*
  74                  * Don't send it on interfaces in the except list.
  75                  */
  76                 onlist = 0;
  77                 trt = except;
  78                 while(trt) {
  79                         if (ifp == trt->rt_ifp) {
  80                                 onlist = 1;
  81                                 break;
  82                         }
  83                         trt = trt->rt_clone;
  84                 }
  85                 if (onlist)
  86                         continue;
  87
  88                 dst = ifp->int_flags & IFF_BROADCAST ? &ifp->int_broadaddr :
  89                       ifp->int_flags & IFF_POINTOPOINT ? &ifp->int_dstaddr :
  90                       &ifp->int_addr;
  91                 flags = ifp->int_flags & IFF_INTERFACE ? MSG_DONTROUTE : 0;
  92                 (*f)(dst, flags, ifp, changesonly);
  93         }
  94 }
  95
  96 /*
  97  * Output a preformed packet.
  98  */
  99 void
 100 sndmsg(dst, flags, ifp, changesonly)
 101         struct sockaddr *dst;
 102         int flags;
 103         struct interface *ifp;
 104         int changesonly;
 105 {
 106
 107         (*afswitch[dst->sa_family].af_output)
 108                 (ripsock, flags, dst, sizeof (struct rip));
 109         TRACE_OUTPUT(ifp, dst, sizeof (struct rip));
 110 }
 111
 112 /*
 113  * Supply dst with the contents of the routing tables.
 114  * If this won't fit in one packet, chop it up into several.
 115  *
 116  * This must be done using the split horizon algorithm.
 117  * 1. Don't send routing info to the interface from where it was received.
 118  * 2. Don't publish an interface to itself.
 119  * 3. If a route is received from more than one interface and the cost is
 120  *    the same, don't publish it on either interface. I am calling this
 121  *    clones.
 122  */
 123 void
 124 supply(dst, flags, ifp, changesonly)
 125         struct sockaddr *dst;
 126         int flags;
 127         struct interface *ifp;
 128         int changesonly;
 129 {
 130         register struct rt_entry *rt;
 131         register struct rt_entry *crt; /* Clone route */
 132         register struct rthash *rh;
 133         register struct netinfo *nn;
 134         register struct netinfo *n = msg->rip_nets;
 135         struct sockaddr_ipx *sipx =  (struct sockaddr_ipx *) dst;
 136         af_output_t *output = afswitch[dst->sa_family].af_output;
 137         int size, metric, ticks;
 138         union ipx_net net;
 139         int delay = 0;
 140
 141         if (sipx->sipx_port == 0)
 142                 sipx->sipx_port = htons(IPXPORT_RIP);
 143
 144         msg->rip_cmd = ntohs(RIPCMD_RESPONSE);
 145         for (rh = nethash; rh < &nethash[ROUTEHASHSIZ]; rh++)
 146         for (rt = rh->rt_forw; rt != (struct rt_entry *)rh; rt = rt->rt_forw) {
 147                 size = (char *)n - (char *)msg;
 148                 if (size >= ((MAXRIPNETS * sizeof (struct netinfo)) +
 149                                 sizeof (msg->rip_cmd))) {
 150                         (*output)(ripsock, flags, dst, size);
 151                         TRACE_OUTPUT(ifp, dst, size);
 152                         n = msg->rip_nets;
 153                         delay++;
 154                         if(delay == 2) {
 155                                 usleep(50000);
 156                                 delay = 0;
 157                         }
 158                 }
 159
 160                 if (changesonly && !(rt->rt_state & RTS_CHANGED))
 161                         continue;
 162
 163                 /*
 164                  * This should do rule one and two of the split horizon
 165                  * algorithm.
 166                  */
 167                 if (rt->rt_ifp == ifp)
 168                         continue;
 169
 170                 /*
 171                  * Rule 3.
 172                  * Look if we have clones (different routes to the same
 173                  * place with exactly the same cost).
 174                  *
 175                  * We should not publish on any of the clone interfaces.
 176                  */
 177                 crt = rt->rt_clone;
 178                 while (crt) {
 179                         if (crt->rt_ifp == ifp)
 180                                 goto next;
 181                         crt = crt->rt_clone;
 182                 }
 183
 184                 sipx = (struct sockaddr_ipx *)&rt->rt_dst;
 185                 if ((rt->rt_flags & (RTF_HOST|RTF_GATEWAY)) == RTF_HOST)
 186                         sipx = (struct sockaddr_ipx *)&rt->rt_router;
 187                 if (rt->rt_metric == HOPCNT_INFINITY)
 188                         metric = HOPCNT_INFINITY;
 189                 else {
 190                         metric = rt->rt_metric + 1;
 191                         /*
 192                          * We don't advertize routes with more than 15 hops.
 193                          */
 194                         if (metric >= HOPCNT_INFINITY)
 195                                 continue;
 196                 }
 197                 /* XXX One day we should cater for slow interfaces also. */
 198                 ticks = rt->rt_ticks + 1;
 199                 net = sipx->sipx_addr.x_net;
 200
 201                 /*
 202                  * Make sure that we don't put out a two net entries
 203                  * for a pt to pt link (one for the G route, one for the if)
 204                  * This is a kludge, and won't work if there are lots of nets.
 205                  */
 206                 for (nn = msg->rip_nets; nn < n; nn++) {
 207                         if (ipx_neteqnn(net, nn->rip_dst)) {
 208                                 if (ticks < ntohs(nn->rip_ticks)) {
 209                                         nn->rip_metric = htons(metric);
 210                                         nn->rip_ticks = htons(ticks);
 211                                 } else if ((ticks == ntohs(nn->rip_ticks)) &&
 212                                            (metric < ntohs(nn->rip_metric))) {
 213                                         nn->rip_metric = htons(metric);
 214                                         nn->rip_ticks = htons(ticks);
 215                                 }
 216                                 goto next;
 217                         }
 218                 }
 219                 n->rip_dst = net;
 220                 n->rip_metric = htons(metric);
 221                 n->rip_ticks = htons(ticks);
 222                 n++;
 223         next:;
 224         }
 225         if (n != msg->rip_nets) {
 226                 size = (char *)n - (char *)msg;
 227                 (*output)(ripsock, flags, dst, size);
 228                 TRACE_OUTPUT(ifp, dst, size);
 229         }
 230 }