IPXrouted(8): Fix some amd64 warnings.
[dragonfly.git] / usr.sbin / IPXrouted / input.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/input.c,v 1.7 1999/08/28 01:15:02 peter Exp $
39  * $DragonFly: src/usr.sbin/IPXrouted/input.c,v 1.3 2004/03/11 09:38:59 hmp Exp $
40  *
41  * @(#)input.c  8.1 (Berkeley) 6/5/93
42  */
43
44 /*
45  * IPX Routing Table Management Daemon
46  */
47 #include "defs.h"
48
49 struct sockaddr *
50 ipx_nettosa(union ipx_net net)
51 {
52         static struct sockaddr_ipx sxn;
53         
54         bzero(&sxn, sizeof (struct sockaddr_ipx));
55         sxn.sipx_family = AF_IPX;
56         sxn.sipx_len = sizeof (sxn);
57         sxn.sipx_addr.x_net = net;
58         return( (struct sockaddr *)&sxn);
59         
60 }
61
62 /*
63  * Process a newly received packet.
64  */
65 void
66 rip_input(struct sockaddr *from, int size)
67 {
68         int newsize;
69         int rtchanged = 0;
70         struct rt_entry *rt;
71         struct netinfo *n;
72         struct interface *ifp = 0;
73         struct afswitch *afp;
74         struct sockaddr_ipx *ipxp;
75
76         ifp = if_ifwithnet(from);
77         ipxp = (struct sockaddr_ipx *)from;
78         if (ifp == 0) {
79                 if(ftrace) {
80                         fprintf(ftrace, "Received bogus packet from %s\n",
81                                 ipxdp_ntoa(&ipxp->sipx_addr));
82                 }
83                 return;
84         }
85
86         TRACE_INPUT(ifp, from, size);
87         if (from->sa_family >= AF_MAX)
88                 return;
89         afp = &afswitch[from->sa_family];
90         
91         size -= sizeof (u_short)        /* command */;
92         n = msg->rip_nets;
93
94         switch (ntohs(msg->rip_cmd)) {
95
96         case RIPCMD_REQUEST:
97                 if (ipx_hosteq(satoipx_addr(ifp->int_addr), ipxp->sipx_addr))
98                         return;
99                 newsize = 0;
100                 while (size > 0) {
101                         if (size < sizeof (struct netinfo))
102                                 break;
103                         size -= sizeof (struct netinfo);
104
105                         /* 
106                          * A single entry with rip_dst == DSTNETS_ALL and
107                          * metric ``infinity'' means ``all routes''.
108                          *
109                          * XXX According to the IPX RIP spec the metric
110                          * and tick fields can be anything. So maybe we
111                          * should not check the metric???
112                          */
113                         if (ipx_neteqnn(n->rip_dst, ipx_anynet) &&
114                             ntohs(n->rip_metric) == HOPCNT_INFINITY &&
115                             size == 0) {
116                                 supply(from, 0, ifp, 0);
117                                 return;
118                         }
119                         /*
120                          * request for specific nets
121                          */
122                         rt = rtlookup(ipx_nettosa(n->rip_dst));
123                         if (ftrace) {
124                                 fprintf(ftrace,
125                                         "specific request for %s",
126                                         ipxdp_nettoa(n->rip_dst));
127                                 fprintf(ftrace,
128                                         " yields route %p\n",
129                                         rt);
130                         }
131                         /*
132                          * XXX We break out on the first net that isn't
133                          * found. The specs is a bit vague here. I'm not
134                          * sure what we should do.
135                          */
136                         if (rt == 0)
137                                 return;
138                         /* XXX
139                          * According to the spec we should not include
140                          * information about networks for which the number
141                          * of hops is 16.
142                          */
143                         if (rt->rt_metric == (HOPCNT_INFINITY-1))
144                                 return;
145                         n->rip_metric = htons( rt == 0 ? HOPCNT_INFINITY :
146                                 min(rt->rt_metric+1, HOPCNT_INFINITY));
147                         n->rip_ticks = htons(rt->rt_ticks+1);
148
149                         /*
150                          * We use split horizon with a twist. If the requested
151                          * net is the directly connected net we supply an
152                          * answer. This is so that the host can learn about
153                          * the routers on its net.
154                          */
155                         {
156                                 struct rt_entry *trt = rt;
157
158                                 while (trt) {
159                                         if ((trt->rt_ifp == ifp) && 
160                                             !ipx_neteqnn(n->rip_dst, 
161                                                 satoipx_addr(ifp->int_addr).x_net))
162                                                 return;
163                                         trt = trt->rt_clone;
164                                 }
165                                 n++;
166                                 newsize += sizeof (struct netinfo);
167                         }
168                 }
169                 if (newsize > 0) {
170                         msg->rip_cmd = htons(RIPCMD_RESPONSE);
171                         newsize += sizeof (u_short);
172                         /* should check for if with dstaddr(from) first */
173                         (*afp->af_output)(ripsock, 0, from, newsize);
174                         TRACE_OUTPUT(ifp, from, newsize);
175                         if (ftrace) {
176                                 /* XXX This should not happen anymore. */
177                                 if(ifp == 0)
178                                         fprintf(ftrace, "--- ifp = 0\n");
179                                 else
180                                         fprintf(ftrace,
181                                                 "request arrived on interface %s\n",
182                                                 ifp->int_name);
183                         }
184                 }
185                 return;
186
187         case RIPCMD_RESPONSE:
188                 /* verify message came from a router */
189                 if ((*afp->af_portmatch)(from) == 0)
190                         return;
191                 (*afp->af_canon)(from);
192                 /* are we talking to ourselves? */
193                 if ((ifp = if_ifwithaddr(from)) != 0) {
194                         rt = rtfind(from);
195                         if (rt == 0 || (rt->rt_state & RTS_INTERFACE) == 0) {
196                                 addrouteforif(ifp);
197                                 rtchanged = 1;
198                         } else
199                                 rt->rt_timer = 0;
200                         return;
201                 }
202                 /* Update timer for interface on which the packet arrived.
203                  * If from other end of a point-to-point link that isn't
204                  * in the routing tables, (re-)add the route.
205                  */
206                 if ((rt = rtfind(from)) && (rt->rt_state & RTS_INTERFACE)) {
207                         if(ftrace) fprintf(ftrace, "Got route\n");
208                         rt->rt_timer = 0;
209                 } else if ((ifp = if_ifwithdstaddr(from)) != 0) {
210                         if(ftrace) fprintf(ftrace, "Got partner\n");
211                         addrouteforif(ifp);
212                         rtchanged = 1;
213                 }
214                 for (; size > 0; size -= sizeof (struct netinfo), n++) {
215                         struct sockaddr *sa;
216                         if (size < sizeof (struct netinfo))
217                                 break;
218                         if ((unsigned) ntohs(n->rip_metric) > HOPCNT_INFINITY)
219                                 continue;
220                         rt = rtfind(sa = ipx_nettosa(n->rip_dst));
221                         if (rt == 0) {
222                                 if (ntohs(n->rip_metric) == HOPCNT_INFINITY)
223                                         continue;
224                                 rtadd(sa, from, ntohs(n->rip_metric),
225                                         ntohs(n->rip_ticks), 0);
226                                 rtchanged = 1;
227                                 continue;
228                         }
229
230                         /*
231                          * A clone is a different route to the same net
232                          * with exactly the same cost (ticks and metric).
233                          * They must all be recorded because those interfaces
234                          * must be handled in the same way as the first route
235                          * to that net. ie When using the split horizon
236                          * algorithm we must look at these interfaces also.
237                          *
238                          * Update if from gateway and different,
239                          * from anywhere and less ticks or
240                          * if same ticks and shorter,
241                          * or getting stale and equivalent.
242                          */
243                         if (!equal(from, &rt->rt_router) &&
244                             ntohs(n->rip_ticks) == rt->rt_ticks &&
245                             ntohs(n->rip_metric) == rt->rt_metric &&
246                             ntohs(n->rip_metric) != HOPCNT_INFINITY) {
247                                 struct rt_entry *trt = rt->rt_clone;
248
249                                 while (trt) {
250                                         if (equal(from, &trt->rt_router)) {
251                                                 trt->rt_timer = 0;
252                                                 break;
253                                         }
254                                         trt = trt->rt_clone;
255                                 }
256                                 if (trt == NULL) {
257                                         rtadd_clone(rt, sa, from, 
258                                                     ntohs(n->rip_metric),
259                                                     ntohs(n->rip_ticks), 0);
260                                 }
261                                 continue;
262                         }
263                         if ((equal(from, &rt->rt_router) &&
264                             ((ntohs(n->rip_ticks) != rt->rt_ticks) ||
265                             (ntohs(n->rip_metric) != rt->rt_metric))) ||
266                             (ntohs(n->rip_ticks) < rt->rt_ticks) ||
267                             ((ntohs(n->rip_ticks) == rt->rt_ticks) &&
268                             (ntohs(n->rip_metric) < rt->rt_metric)) ||
269                             (rt->rt_timer > (EXPIRE_TIME*2/3) &&
270                             rt->rt_metric == ntohs(n->rip_metric) &&
271                             ntohs(n->rip_metric) != HOPCNT_INFINITY)) {
272                                 rtchange(rt, from, ntohs(n->rip_metric),
273                                         ntohs(n->rip_ticks));
274                                 if (ntohs(n->rip_metric) == HOPCNT_INFINITY)
275                                         rt->rt_timer = EXPIRE_TIME;
276                                 else
277                                         rt->rt_timer = 0;
278                                 rtchanged = 1;
279                         } else if (equal(from, &rt->rt_router) &&
280                                    (ntohs(n->rip_ticks) == rt->rt_ticks) &&
281                                    (ntohs(n->rip_metric) == rt->rt_metric) &&
282                                    (ntohs(n->rip_metric) != HOPCNT_INFINITY)) {
283                                 rt->rt_timer = 0;
284                         }
285                 }
286                 if (rtchanged) {
287                         struct rthash *rh;
288                         struct rt_entry *rt;
289
290                         toall(supply, NULL, 1);
291                         for (rh = nethash; rh < &nethash[ROUTEHASHSIZ]; rh++)
292                                 for (rt = rh->rt_forw;
293                                     rt != (struct rt_entry *)rh;
294                                     rt = rt->rt_forw)
295                                         rt->rt_state &= ~RTS_CHANGED;
296                 }
297
298                 return;
299         }
300 }