* Ethernet manufacturer support (Laurent)

* PPP fixes (Gerald)
* Null/loopback interface support (Gerald)

svn path=/trunk/; revision=25

1 files changed, 536 insertions, 19 deletions

diff --git a/resolv.c b/resolv.c
index e669a862ed..f00f843be4 100644
--- a/resolv.c
+++ b/resolv.c
@@ -1,7 +1,7 @@
 /* resolv.c
  * Routines for network object lookup
  *
- * $Id: resolv.c,v 1.2 1998/09/16 03:22:18 gerald Exp $
+ * $Id: resolv.c,v 1.3 1998/09/25 23:24:06 gerald Exp $
  *
  * Laurent Deniel <deniel@worldnet.fr>
  *
@@ -23,14 +23,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
- *
- *
- * To do:
- *
- * - Add ethernet address resolution
- * - In a future live capture and decode mode, 
- *   add hostname entries in hash table from DNS packet decoding.
- *
  */
 
 #ifdef HAVE_CONFIG_H
@@ -65,8 +57,13 @@
 #include "packet.h"
 #include "resolv.h"
 
+#ifndef MAXNAMELEN
 #define MAXNAMELEN  	64	/* max name length (hostname and port name) */
+#endif
+#define MAXMANUFLEN	9	/* max vendor name length with ending '\0' */
+#define HASHETHSIZE	1024
 #define HASHHOSTSIZE	1024
+#define HASHMANUFSIZE   256
 #define HASHPORTSIZE	256
 
 /* hash table used for host and port lookup */
@@ -77,15 +74,50 @@ typedef struct hashname {
   struct hashname 	*next;
 } hashname_t;
 
-static hashname_t *host_table[HASHHOSTSIZE];
-static hashname_t *udp_port_table[HASHPORTSIZE];
-static hashname_t *tcp_port_table[HASHPORTSIZE];
+/* hash tables used for ethernet and manufacturer lookup */
+
+typedef struct hashmanuf {
+  u_char 		addr[3];
+  char 			name[MAXMANUFLEN];
+  struct hashmanuf     	*next;
+} hashmanuf_t;
+
+typedef struct hashether {
+  u_char 		addr[6];
+  char 			name[MAXNAMELEN];
+  struct hashether     	*next;
+} hashether_t;
+
+/* internal ethernet type */
 
-/* global variable that indicates if name resolving is actif */
+typedef struct _ether
+{
+  u_char		addr[6];
+  char 			name[MAXNAMELEN];
+} ether_t;
+
+static hashname_t 	*host_table[HASHHOSTSIZE];
+static hashname_t 	*udp_port_table[HASHPORTSIZE];
+static hashname_t 	*tcp_port_table[HASHPORTSIZE];
+static hashether_t 	*eth_table[HASHETHSIZE];
+static hashmanuf_t 	*manuf_table[HASHMANUFSIZE];
+
+static int 		eth_resolution_initialized = 0;
+
+/*
+ *  Global variables (can be changed in GUI sections)
+ */
+
+int g_resolving_actif = 1; 		/* routines are active by default */
 
-int g_resolving_actif = 1; 	/* routines are active by default */
+gchar *g_ethers_path  = EPATH_ETHERS;
+gchar *g_pethers_path = NULL; 		/* "$HOME"/EPATH_PERSONAL_ETHERS    */
+gchar *g_manuf_path   = EPATH_MANUF;	/* may only be changed before the   */
+					/* first resolving call        	    */
 
-/* local function definitions */
+/*
+ *  Local function definitions 
+ */
 
 static u_char *serv_name_lookup(u_int port, u_int proto)
 {
@@ -141,6 +173,7 @@ static u_char *serv_name_lookup(u_int port, u_int proto)
     sprintf(tp->name, "%d", port);
   } else {
     strncpy(tp->name, servp->s_name, MAXNAMELEN);
+    tp->name[MAXNAMELEN-1] = '\0';
   }
 
   return (tp->name);
@@ -190,9 +223,9 @@ static u_char *host_name_lookup(u_int addr)
   tp->next = NULL;
 
 #ifdef AVOID_DNS_TIMEOUT
-
+    
   /* Quick hack to avoid DNS/YP timeout */
-
+  
   if (!setjmp(hostname_env)) {
     signal(SIGALRM, abort_network_query);
     alarm(DNS_TIMEOUT);
@@ -203,6 +236,7 @@ static u_char *host_name_lookup(u_int addr)
 #endif
     if (hostp != NULL) {
       strncpy(tp->name, hostp->h_name, MAXNAMELEN);
+      tp->name[MAXNAMELEN-1] = '\0';
       return tp->name;
     }
 #ifdef AVOID_DNS_TIMEOUT
@@ -212,11 +246,412 @@ static u_char *host_name_lookup(u_int addr)
   /* unknown host or DNS timeout */
 
   sprintf(tp->name, "%s", ip_to_str((guint8 *)&addr));  
+
   return (tp->name);
 
 } /* host_name_lookup */
 
-/* external functions */
+/*
+ *  Miscellaneous functions
+ */
+
+static int fgetline(char **buf, int *size, FILE *fp)
+{
+  int len;
+  int c;
+
+  if (fp == NULL)
+    return -1;
+
+  if (*buf == NULL) {
+    if (*size == 0) 
+      *size = BUFSIZ;
+    
+    if ((*buf = g_malloc(*size)) == NULL)
+      return -1;
+  }
+
+  if (feof(fp))
+    return -1;
+    
+  len = 0;
+  while ((c = getc(fp)) != EOF && c != '\n') {
+    if (len+1 >= *size) {
+      if ((*buf = g_realloc(*buf, *size += BUFSIZ)) == NULL)
+	return -1;
+    }
+    (*buf)[len++] = c;
+  }
+
+  if (len == 0 && c == EOF)
+    return -1;
+    
+  (*buf)[len] = '\0';
+    
+  return len;
+
+} /* fgetline */
+
+
+/*
+ * Ethernet / manufacturer resolution
+ *
+ * The following functions implement ethernet address resolution and
+ * ethers files parsing (see ethers(4)). 
+ *
+ * /etc/manuf has the same format as ethers(4) except that names are 
+ * truncated to MAXMANUFLEN-1 characters and that an address contains 
+ * only 3 bytes (instead of 6).
+ *
+ * Notes:
+ *
+ * I decide to not use the existing functions (see ethers(3) on some 
+ * operating systems) for the following reasons:
+ * - performance gains (use of hash tables and some other enhancements),
+ * - use of two ethers files (system-wide and per user),
+ * - avoid the use of NIS maps,
+ * - lack of these functions on some systems.
+ *
+ * So the following functions do _not_ behave as the standard ones.
+ *
+ * -- Laurent.
+ */
+
+
+static int parse_ether_line(char *line, ether_t *eth, int six_bytes)
+{
+  /*
+   *  See man ethers(4) for /etc/ethers file format
+   *  (not available on all systems).
+   *  We allow both ethernet address separators (':' and '-').
+   */
+
+  gchar *cp;
+  int a0, a1, a2, a3, a4, a5;
+    
+  if ((cp = strchr(line, '#')))
+    *cp = '\0';
+  
+  if ((cp = strtok(line, " \t\n")) == NULL)
+    return -1;
+
+  if (six_bytes) {
+    if (sscanf(cp, "%x:%x:%x:%x:%x:%x", &a0, &a1, &a2, &a3, &a4, &a5) != 6) {
+      if (sscanf(cp, "%x-%x-%x-%x-%x-%x", &a0, &a1, &a2, &a3, &a4, &a5) != 6)
+	return -1;
+    }
+  } else {
+    if (sscanf(cp, "%x:%x:%x", &a0, &a1, &a2) != 3) {
+      if (sscanf(cp, "%x-%x-%x", &a0, &a1, &a2) != 3)
+	return -1;
+    }
+  }
+
+  if ((cp = strtok(NULL, " \t\n")) == NULL)
+    return -1;
+
+  eth->addr[0] = a0;
+  eth->addr[1] = a1;
+  eth->addr[2] = a2;
+  if (six_bytes) {
+    eth->addr[3] = a3;
+    eth->addr[4] = a4;
+    eth->addr[5] = a5;
+  } else {
+    eth->addr[3] = 0;
+    eth->addr[4] = 0;
+    eth->addr[5] = 0;
+  }
+
+  strncpy(eth->name, cp, MAXNAMELEN);
+  eth->name[MAXNAMELEN-1] = '\0';
+
+  return 0;
+
+} /* parse_ether_line */
+
+static FILE *eth_p = NULL;
+
+static void set_ethent(char *path)
+{
+  if (eth_p)
+    rewind(eth_p);
+  else
+    eth_p = fopen(path, "r");
+}
+
+static void end_ethent(void)
+{
+  if (eth_p) {
+    fclose(eth_p);
+    eth_p = NULL;
+  }
+}
+
+static ether_t *get_ethent(int six_bytes)
+{
+ 
+  static ether_t eth;
+  static int     size = 0;
+  static char   *buf = NULL;
+  
+  if (eth_p == NULL) 
+    return NULL;
+
+  while (fgetline(&buf, &size, eth_p) >= 0) {
+    if (parse_ether_line(buf, &eth, six_bytes) == 0) {
+      return &eth;
+    }
+  }
+    
+  return NULL;
+
+} /* get_ethent */
+
+static ether_t *get_ethbyname(u_char *name)
+{
+  ether_t *eth;
+  
+  set_ethent(g_ethers_path);
+
+  while ((eth = get_ethent(1)) && strncmp(name, eth->name, MAXNAMELEN) != 0)
+    ;
+
+  if (eth == NULL) {
+    end_ethent();
+    
+    set_ethent(g_pethers_path);
+
+    while ((eth = get_ethent(1)) && strncmp(name, eth->name, MAXNAMELEN) != 0)
+      ;
+
+    end_ethent();
+  }
+
+  return eth;
+
+} /* get_ethbyname */
+
+static ether_t *get_ethbyaddr(u_char *addr)
+{
+
+  ether_t *eth;
+  
+  set_ethent(g_ethers_path);
+
+  while ((eth = get_ethent(1)) && memcmp(addr, eth->addr, 6) != 0)
+    ;
+
+  if (eth == NULL) {
+    end_ethent();
+    
+    set_ethent(g_pethers_path);
+    
+    while ((eth = get_ethent(1)) && memcmp(addr, eth->addr, 6) != 0)
+      ;
+    
+    end_ethent();
+  }
+
+  return eth;
+
+} /* get_ethbyaddr */
+
+static void add_manuf_name(u_char *addr, u_char *name)
+{
+
+  hashmanuf_t *tp;
+  hashmanuf_t **table = manuf_table;
+
+  tp = table[ ((int)addr[2]) & (HASHMANUFSIZE - 1)];
+
+  if( tp == NULL ) {
+    tp = table[ ((int)addr[2]) & (HASHMANUFSIZE - 1)] = 
+      (hashmanuf_t *)g_malloc(sizeof(hashmanuf_t));
+  } else {  
+    while(1) {
+      if (tp->next == NULL) {
+	tp->next = (hashmanuf_t *)g_malloc(sizeof(hashmanuf_t));
+	tp = tp->next;
+	break;
+      }
+      tp = tp->next;
+    }
+  }
+  
+  memcpy(tp->addr, addr, sizeof(tp->addr));
+  strncpy(tp->name, name, MAXMANUFLEN);
+  tp->name[MAXMANUFLEN-1] = '\0';
+  tp->next = NULL;
+
+} /* add_manuf_name */
+
+static hashmanuf_t *manuf_name_lookup(u_char *addr)
+{
+
+  hashmanuf_t *tp;
+  hashmanuf_t **table = manuf_table;
+
+  tp = table[ ((int)addr[2]) & (HASHMANUFSIZE - 1)];
+  
+  while(tp != NULL) {
+    if (memcmp(tp->addr, addr, sizeof(tp->addr)) == 0) {
+      return tp;
+    }
+    tp = tp->next;
+  }
+  
+  return NULL;
+
+} /* manuf_name_lookup */
+
+static hashether_t *add_eth_name(u_char *addr, u_char *name)
+{
+  hashether_t *tp;
+  hashether_t **table = eth_table;
+  int i,j;
+
+  j = (addr[2] << 8) | addr[3];
+  i = (addr[4] << 8) | addr[5];
+
+  tp = table[ (i ^ j) & (HASHETHSIZE - 1)];
+
+  if( tp == NULL ) {
+    tp = table[ (i ^ j) & (HASHETHSIZE - 1)] = 
+      (hashether_t *)g_malloc(sizeof(hashether_t));
+  } else {  
+    while(1) {
+      if (tp->next == NULL) {
+	tp->next = (hashether_t *)g_malloc(sizeof(hashether_t));
+	tp = tp->next;
+	break;
+      }
+      tp = tp->next;
+    }
+  }
+  
+  memcpy(tp->addr, addr, sizeof(tp->addr));
+  strncpy(tp->name, name, MAXNAMELEN);
+  tp->name[MAXNAMELEN-1] = '\0';
+  tp->next = NULL;
+
+  return tp;
+
+} /* add_eth_name */
+
+static u_char *eth_name_lookup(u_char *addr)
+{
+  hashmanuf_t *manufp;
+  hashether_t *tp;
+  hashether_t **table = eth_table;
+  ether_t *eth;
+  int i,j;
+
+  j = (addr[2] << 8) | addr[3];
+  i = (addr[4] << 8) | addr[5];
+
+  tp = table[ (i ^ j) & (HASHETHSIZE - 1)];
+
+  if( tp == NULL ) {
+    tp = table[ (i ^ j) & (HASHETHSIZE - 1)] = 
+      (hashether_t *)g_malloc(sizeof(hashether_t));
+  } else {  
+    while(1) {
+      if (memcmp(tp->addr, addr, sizeof(tp->addr)) == 0) {
+	return tp->name;
+      }
+      if (tp->next == NULL) {
+	tp->next = (hashether_t *)g_malloc(sizeof(hashether_t));
+	tp = tp->next;
+	break;
+      }
+      tp = tp->next;
+    }
+  }
+  
+  /* fill in a new entry */
+
+  memcpy(tp->addr, addr, sizeof(tp->addr));
+  tp->next = NULL;
+
+  if ( (eth = get_ethbyaddr(addr)) == NULL) {
+    /* unknown name */
+
+    if ((manufp = manuf_name_lookup(addr)) == NULL)
+      sprintf(tp->name, "%s", ether_to_str((guint8 *)addr));
+    else
+      sprintf(tp->name, "%s_%02x:%02x:%02x", 
+	      manufp->name, addr[3], addr[4], addr[5]);
+
+  } else {
+    strncpy(tp->name, eth->name, MAXNAMELEN);
+    tp->name[MAXNAMELEN-1] = '\0';
+  }
+
+  return (tp->name);
+
+} /* eth_name_lookup */
+
+static u_char *eth_addr_lookup(u_char *name)
+{
+  ether_t *eth;
+  hashether_t *tp;
+  hashether_t **table = eth_table;
+  int i;
+
+  /* to be optimized (hash table from name to addr) */
+  for (i = 0; i < HASHETHSIZE; i++) {
+    tp = table[i];
+    while (tp) {
+      if (strcmp(tp->name, name) == 0)
+	return tp->addr;
+      tp = tp->next;
+    }
+  }
+
+  /* not in hash table : performs a file lookup */
+
+  if ((eth = get_ethbyname(name)) == NULL)
+    return NULL;
+
+  /* add new entry in hash table */
+
+  tp = add_eth_name(eth->addr, name);
+
+  return tp->addr;
+
+} /* eth_addr_lookup */
+
+static void initialize_ethers(void)
+{
+  ether_t *eth;
+
+#ifdef DEBUG_RESOLV
+  signal(SIGSEGV, SIG_IGN);
+#endif
+
+  if (g_pethers_path == NULL) {
+    g_pethers_path = g_malloc(strlen(getenv("HOME")) + 
+			      strlen(EPATH_PERSONAL_ETHERS) + 2);
+    sprintf(g_pethers_path, "%s/%s", 
+	    (char *)getenv("HOME"), EPATH_PERSONAL_ETHERS);
+  }
+
+  /* manuf hash table initialization */
+
+  set_ethent(g_manuf_path);
+
+  while ((eth = get_ethent(0))) {
+    add_manuf_name(eth->addr, eth->name);
+  }
+
+  end_ethent();
+
+} /* initialize_ethers */
+
+/* 
+ *  External Functions
+ */
 
 extern u_char *get_hostname(u_int addr) 
 {
@@ -226,6 +661,35 @@ extern u_char *get_hostname(u_int addr)
   return host_name_lookup(addr);
 }
 
+extern void add_host_name(u_int addr, u_char *name)
+{
+
+  hashname_t *tp;
+  hashname_t **table = host_table;
+
+  tp = table[ addr & (HASHHOSTSIZE - 1)];
+
+  if( tp == NULL ) {
+    tp = table[ addr & (HASHHOSTSIZE - 1)] = 
+      (hashname_t *)g_malloc(sizeof(hashname_t));
+  } else {  
+    while(1) {
+      if (tp->next == NULL) {
+	tp->next = (hashname_t *)g_malloc(sizeof(hashname_t));
+	tp = tp->next;
+	break;
+      }
+      tp = tp->next;
+    }
+  }
+  
+  strncpy(tp->name, name, MAXNAMELEN);
+  tp->name[MAXNAMELEN-1] = '\0';
+  tp->addr = addr;
+  tp->next = NULL;
+
+} /* add_host_name */
+
 extern u_char *get_udp_port(u_int port) 
 {
   static gchar  str[3][MAXNAMELEN];
@@ -247,7 +711,6 @@ extern u_char *get_udp_port(u_int port)
 
 } /* get_udp_port */
 
-
 extern u_char *get_tcp_port(u_int port) 
 {
   static gchar  str[3][MAXNAMELEN];
@@ -269,3 +732,57 @@ extern u_char *get_tcp_port(u_int port)
 
 } /* get_tcp_port */
 
+extern u_char *get_ether_name(u_char *addr)
+{
+  if (!g_resolving_actif)
+    return ether_to_str((guint8 *)addr);
+
+  if (!eth_resolution_initialized) {
+    initialize_ethers();
+    eth_resolution_initialized = 1;
+  }
+
+  return eth_name_lookup(addr);
+
+} /* get_ether_name */
+
+extern u_char *get_ether_addr(u_char *name)
+{
+
+  /* force resolution (do not check g_resolving_actif) */
+
+  if (!eth_resolution_initialized) {
+    initialize_ethers();
+    eth_resolution_initialized = 1;
+  }
+
+  return eth_addr_lookup(name);
+
+} /* get_ether_addr */
+
+extern u_char *get_manuf_name(u_char *addr) 
+{
+  static gchar  str[3][MAXMANUFLEN];
+  static gchar *cur;
+  hashmanuf_t  *manufp;
+
+  if (g_resolving_actif && !eth_resolution_initialized) {
+    initialize_ethers();
+    eth_resolution_initialized = 1;
+  }
+
+  if (!g_resolving_actif || ((manufp = manuf_name_lookup(addr)) == NULL)) {
+    if (cur == &str[0][0]) {
+      cur = &str[1][0];
+    } else if (cur == &str[1][0]) {  
+      cur = &str[2][0];
+    } else {  
+      cur = &str[0][0];
+    }
+    sprintf(cur, "%02x:%02x:%02x", addr[0], addr[1], addr[2]);
+    return cur;
+  }
+  
+  return manufp->name;
+
+} /* get_manuf_name */