_lane.c

This directory contains source code for tcpdump, a tool for network monitoring and data acquisition

/*
 * Marko Kiiskila [e-mail]
 *
 * Tampere University of Technology - Telecommunications Laboratory
 *
 * Permission to use, copy, modify and distribute this
 * software and its documentation is hereby granted,
 * provided that both the copyright notice and this
 * permission notice appear in all copies of the software,
 * derivative works or modified versions, and any portions
 * thereof, that both notices appear in supporting
 * documentation, and that the use of this software is
 * acknowledged in any publications resulting from using
 * the software.
 *
 * TUT ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION AND DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS
 * SOFTWARE.
 *
 */

#include <stdio.h>
#include <sys/param.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>

#include <net/if.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/udp.h>
#include <netinet/udp_var.h>
#include <netinet/tcp.h>
#include <netinet/tcpip.h>

#include <pcap.h>

#include "interfac.h"
#include "a2name.h"
#include "lane.h"

static void lane_print (const u_char * bp, int length)
{
  const struct lecdatahdr_8023 *ep = (const struct lecdatahdr_8023 *) bp;

  if (qflag)
       PRINTF ("lecid:%d %s %s %d: ",
               ntohs (ep->le_header),
               etheraddr_string (ep->h_source),
               etheraddr_string (ep->h_dest),
               length);
  else PRINTF ("lecid:%d %s %s %s %d: ",
               ntohs (ep->le_header),
               etheraddr_string (ep->h_source),
               etheraddr_string (ep->h_dest),
               etherproto_string (ep->h_type),
               length);
}

/*
 * This is the top level routine of the printer.  'p' is the points
 * to the ether header of the packet, 'tvp' is the timestamp,
 * 'length' is the length of the packet off the wire, and 'caplen'
 * is the number of bytes actually captured.
 */
void lane_if_print (u_char * user, const struct pcap_pkthdr *h, const u_char * p)
{
  struct  lecdatahdr_8023 *ep;
  int     caplen = h->caplen;
  int     length = h->len;
  u_short ether_type;

  ts_print (&h->ts);

  if (caplen < sizeof(struct lecdatahdr_8023))
  {
    PUTS ("[|lane]");
    goto out;
  }

  if (eflag)
    lane_print (p, length);

  /*
   * Some printers want to get back at the ethernet addresses,
   * and/or check that they're not walking off the end of the packet.
   * Rather than pass them all the way down, we set these globals.
   */
  packetp = p;
  snapend = p + caplen;

  length -= sizeof(struct lecdatahdr_8023);
  caplen -= sizeof(struct lecdatahdr_8023);

  ep = (struct lecdatahdr_8023 *) p;
  p += sizeof(struct lecdatahdr_8023);

  ether_type = ntohs (ep->h_type);

  /*
   * Is it (gag) an 802.3 encapsulation?
   */
  extracted_ethertype = 0;
  if (ether_type < ETHERMTU)
  {
    /* Try to print the LLC-layer header & higher layers */
    if (llc_print (p, length, caplen, ep->h_source, ep->h_dest) == 0)
    {
      /* ether_type not known, print raw packet */
      if (!eflag)
        lane_print ((u_char *) ep, length);
      if (extracted_ethertype)
         PRINTF ("(LLC %s) ", etherproto_string (htons (extracted_ethertype)));

      if (!xflag && !qflag)
         default_print (p, caplen);
    }
  }
  else if (ether_encap_print (p, ether_type, length, caplen) == 0)
  {
    /* ether_type not known, print raw packet
     */
    if (!eflag)
       lane_print ((u_char*)ep, length + sizeof(*ep));

    if (!xflag && !qflag)
       default_print (p, caplen);
  }
  if (xflag)
    default_print (p, caplen);

out:
  PUTCHAR ('\n');
}