18fa8ff2b4
In rt_change() remember to update the interface pointer otherwise we will send the RIP packets to the wrong interface(s) in future. Update the hash generator and increase the size of the hash tables. Only use the network and host parts when comparing IPX interface addresses. Immediately broadscast RIP and SAP changes. Change the alarm code to use the setitimer() call and only set a flag in the alarm signal handler. This gets rid of possible race conditions. Remove the host routing table. IPX RIP cannot do host routes, only net routes. Make the delay between broadcast packets 50ms. It seems that some Netware 4.x servers is very slow and don't have much input buffering. Handle received messages about networks and services that go down, better. Add tracing of RIP and SAP changes. It gets sysloged with a level of LOG_DEBUG.
336 lines
8.3 KiB
C
336 lines
8.3 KiB
C
/*
|
|
* Copyright (c) 1995 John Hay. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by John Hay.
|
|
* 4. Neither the name of the author nor the names of any co-contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY John Hay AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL John Hay OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $Id: sap_tables.c,v 1.4 1997/07/01 00:33:41 bde Exp $
|
|
*/
|
|
|
|
#include "defs.h"
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#define FIXLEN(s) { if ((s)->sa_len == 0) (s)->sa_len = sizeof (*(s));}
|
|
|
|
sap_hash sap_head[SAPHASHSIZ];
|
|
|
|
void
|
|
sapinit(void)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<SAPHASHSIZ; i++)
|
|
sap_head[i].forw = sap_head[i].back =
|
|
(struct sap_entry *)&sap_head[i];
|
|
}
|
|
|
|
/*
|
|
* This hash use the first 14 letters of the ServName and the ServType
|
|
* to create a 32 bit hash value.
|
|
*/
|
|
int
|
|
saphash(u_short ServType, char *ServName)
|
|
{
|
|
int hsh, i;
|
|
char name[SERVNAMELEN];
|
|
|
|
bzero(name, SERVNAMELEN);
|
|
strncpy(name, ServName, SERVNAMELEN);
|
|
ServName = name;
|
|
|
|
hsh = 0;
|
|
|
|
#define SMVAL 33
|
|
|
|
hsh = hsh * SMVAL + (ServType & 0xff);
|
|
hsh = hsh * SMVAL + (ServType >> 8);
|
|
|
|
for (i=0;i<14;i++) {
|
|
hsh = hsh * SMVAL + *ServName++;
|
|
ServName++;
|
|
}
|
|
|
|
#undef SMVAL
|
|
|
|
return hsh;
|
|
}
|
|
|
|
/*
|
|
* Look for an exact match on ServType and ServName. It is
|
|
* mostly used by the function that process SAP RESPONSE packets.
|
|
*
|
|
* A hash is created and used to index into the hash table. Then
|
|
* that list is walk through searching for a match.
|
|
*
|
|
* If no match is found NULL is returned.
|
|
*/
|
|
struct sap_entry *
|
|
sap_lookup(u_short ServType, char *ServName)
|
|
{
|
|
register struct sap_entry *sap;
|
|
register struct sap_hash *sh;
|
|
int hsh;
|
|
|
|
hsh = saphash(ServType, ServName);
|
|
sh = &sap_head[hsh & SAPHASHMASK];
|
|
|
|
for(sap = sh->forw; sap != (sap_entry *)sh; sap = sap->forw) {
|
|
if ((hsh == sap->hash) &&
|
|
(ServType == sap->sap.ServType) &&
|
|
(strncmp(ServName, sap->sap.ServName, SERVNAMELEN) == 0)) {
|
|
return sap;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* This returns the nearest service of the specified type. If no
|
|
* suitable service is found or if that service is on the interface
|
|
* where the request came from, NULL is returned.
|
|
*
|
|
* When checking interfaces clones must be considered also.
|
|
*
|
|
* XXX TODO:
|
|
* Maybe we can use RIP tables to get the fastest service (ticks).
|
|
*/
|
|
struct sap_entry *
|
|
sap_nearestserver(ushort ServType, struct interface *ifp)
|
|
{
|
|
register struct sap_entry *sap;
|
|
register struct sap_entry *csap;
|
|
struct sap_hash *sh;
|
|
register struct sap_entry *best = NULL;
|
|
register int besthops = HOPCNT_INFINITY;
|
|
|
|
sh = sap_head;
|
|
|
|
for (; sh < &sap_head[SAPHASHSIZ]; sh++)
|
|
for(sap = sh->forw; sap != (sap_entry *)sh; sap = sap->forw) {
|
|
if (ServType != sap->sap.ServType)
|
|
continue;
|
|
if (ifp == sap->ifp)
|
|
continue;
|
|
|
|
csap = sap->clone;
|
|
while (csap) {
|
|
if (ifp == csap->ifp)
|
|
/*
|
|
* I would have loved to use
|
|
* something else here.
|
|
*/
|
|
goto next;
|
|
csap = csap->clone;
|
|
}
|
|
|
|
if (ntohs(sap->sap.hops) < besthops) {
|
|
best = sap;
|
|
besthops = ntohs(best->sap.hops);
|
|
}
|
|
next:;
|
|
}
|
|
return best;
|
|
}
|
|
|
|
/*
|
|
* Add a entry to the SAP table.
|
|
*
|
|
* If the malloc fail, the entry will silently be thrown away.
|
|
*/
|
|
void
|
|
sap_add(struct sap_info *si, struct sockaddr *from)
|
|
{
|
|
register struct sap_entry *nsap;
|
|
register struct sap_hash *sh;
|
|
|
|
if (ntohs(si->hops) == HOPCNT_INFINITY)
|
|
return;
|
|
|
|
FIXLEN(from);
|
|
nsap = malloc(sizeof(struct sap_entry));
|
|
if (nsap == NULL)
|
|
return;
|
|
|
|
nsap->sap = *si;
|
|
nsap->source = *from;
|
|
nsap->clone = NULL;
|
|
nsap->ifp = if_ifwithnet(from);
|
|
nsap->state = RTS_CHANGED;
|
|
nsap->timer = 0;
|
|
nsap->hash = saphash(si->ServType, si->ServName);
|
|
|
|
sh = &sap_head[nsap->hash & SAPHASHMASK];
|
|
|
|
insque(nsap, sh);
|
|
TRACE_SAP_ACTION("ADD", nsap);
|
|
}
|
|
|
|
/*
|
|
* Change an existing SAP entry. If a clone exist for the old one,
|
|
* check if it is cheaper. If it is change tothe clone, otherwise
|
|
* delete all the clones.
|
|
*/
|
|
void
|
|
sap_change(struct sap_entry *sap,
|
|
struct sap_info *si,
|
|
struct sockaddr *from)
|
|
{
|
|
struct sap_entry *osap = NULL;
|
|
|
|
FIXLEN(from);
|
|
TRACE_SAP_ACTION("CHANGE FROM", sap);
|
|
/*
|
|
* If the hopcount (metric) is HOPCNT_INFINITY (16) it means that
|
|
* a service has gone down. We should keep it like that for 30
|
|
* seconds, so that it will get broadcast and then change to a
|
|
* clone if one exist.
|
|
*/
|
|
if (sap->clone && (ntohs(si->hops) != HOPCNT_INFINITY)) {
|
|
/*
|
|
* There are three possibilities:
|
|
* 1. The new path is cheaper than the old one.
|
|
* Free all the clones.
|
|
*
|
|
* 2. The new path is the same cost as the old ones.
|
|
* If it is on the list of clones remove it
|
|
* from the clone list and free it.
|
|
*
|
|
* 3. The new path is more expensive than the old one.
|
|
* Use the values of the first clone and take it
|
|
* out of the list, to be freed at the end.
|
|
*/
|
|
osap = sap->clone;
|
|
if (ntohs(osap->sap.hops) > ntohs(si->hops)) {
|
|
struct sap_entry *nsap;
|
|
|
|
while (osap) {
|
|
nsap = osap->clone;
|
|
TRACE_SAP_ACTION("DELETE", osap);
|
|
free(osap);
|
|
osap = nsap;
|
|
}
|
|
sap->clone = NULL;
|
|
} else if (ntohs(osap->sap.hops) == ntohs(si->hops)) {
|
|
struct sap_entry *psap;
|
|
|
|
psap = sap;
|
|
while (osap) {
|
|
if (equal(&osap->source, from)) {
|
|
psap->clone = osap->clone;
|
|
TRACE_SAP_ACTION("DELETE", osap);
|
|
free(osap);
|
|
osap = psap->clone;
|
|
} else {
|
|
psap = osap;
|
|
osap = osap->clone;
|
|
}
|
|
}
|
|
} else {
|
|
from = &osap->source;
|
|
si = &osap->sap;
|
|
sap->clone = osap->clone;
|
|
}
|
|
}
|
|
sap->sap = *si;
|
|
sap->source = *from;
|
|
sap->ifp = if_ifwithnet(from);
|
|
sap->state = RTS_CHANGED;
|
|
if (ntohs(si->hops) == HOPCNT_INFINITY)
|
|
sap->timer = EXPIRE_TIME;
|
|
else
|
|
sap->timer = 0;
|
|
|
|
if (osap) {
|
|
TRACE_SAP_ACTION("DELETE", osap);
|
|
free(osap);
|
|
}
|
|
TRACE_SAP_ACTION("CHANGE TO", sap);
|
|
}
|
|
|
|
/*
|
|
* Add a clone to the specified SAP entry. A clone is a different
|
|
* route to the same service. We must know about them when we use
|
|
* the split horizon algorithm.
|
|
*
|
|
* If the malloc fail, the entry will silently be thrown away.
|
|
*/
|
|
void
|
|
sap_add_clone(struct sap_entry *sap,
|
|
struct sap_info *clone,
|
|
struct sockaddr *from)
|
|
{
|
|
register struct sap_entry *nsap;
|
|
register struct sap_entry *csap;
|
|
|
|
if (ntohs(clone->hops) == HOPCNT_INFINITY)
|
|
return;
|
|
|
|
FIXLEN(from);
|
|
nsap = malloc(sizeof(struct sap_entry));
|
|
if (nsap == NULL)
|
|
return;
|
|
|
|
if (ftrace)
|
|
fprintf(ftrace, "CLONE ADD %04.4X %s.\n",
|
|
ntohs(clone->ServType),
|
|
clone->ServName);
|
|
|
|
nsap->sap = *clone;
|
|
nsap->source = *from;
|
|
nsap->clone = NULL;
|
|
nsap->ifp = if_ifwithnet(from);
|
|
nsap->state = RTS_CHANGED;
|
|
nsap->timer = 0;
|
|
nsap->hash = saphash(clone->ServType, clone->ServName);
|
|
|
|
csap = sap;
|
|
while (csap->clone)
|
|
csap = csap->clone;
|
|
csap->clone = nsap;
|
|
TRACE_SAP_ACTION("ADD CLONE", nsap);
|
|
}
|
|
|
|
/*
|
|
* Remove a SAP entry from the table and free the memory
|
|
* used by it.
|
|
*
|
|
* If the service have clone, do a sap_change to it and free
|
|
* the clone.
|
|
*/
|
|
void
|
|
sap_delete(struct sap_entry *sap)
|
|
{
|
|
if (sap->clone) {
|
|
sap_change(sap, &sap->clone->sap, &sap->clone->source);
|
|
return;
|
|
}
|
|
remque(sap);
|
|
TRACE_SAP_ACTION("DELETE", sap);
|
|
free(sap);
|
|
}
|