tcpprobe.c

用于嵌入式系统的TCP/IP协议栈

/***********************************************************************/
/*                                                                     */
/*   Module:  tcp_ip/tcpprobe.c                                        */
/*   Release: 2001.3                                                   */
/*   Version: 2001.0                                                   */
/*   Purpose: TCP/IP protocol decoder                                  */
/*                                                                     */
/*---------------------------------------------------------------------*/
/*                                                                     */
/*               Copyright 2001, Blunk Microsystems                    */
/*                      ALL RIGHTS RESERVED                            */
/*                                                                     */
/*   Licensees have the non-exclusive right to use, modify, or extract */
/*   this computer program for software development at a single site.  */
/*   This program may be resold or disseminated in executable format   */
/*   only. The source code may not be redistributed or resold.         */
/*                                                                     */
/*                                                                     */
/***********************************************************************/
#include "tcp_ipp.h"
#if TCP_PROBE
#include "ip/ip.h"
#include "tcp/tcp.h"
#include <string.h>

/***********************************************************************/
/* Global Variable Definitions                                         */
/***********************************************************************/
int NetProbeFlag = FALSE;

/***********************************************************************/
/* Local Function Definitions                                          */
/***********************************************************************/

/***********************************************************************/
/*     got_tcp: Decode TCP packets                                     */
/*                                                                     */
/***********************************************************************/
static void got_tcp(const NetBuf *buf)
{
  Tcp *tcp = buf->ip_data;
  Ip *ip = (Ip *)buf->ip_pkt;
  ui16   sport;         /* source port */
  ui16   dport;         /* destination port */
  tcpseq seq_num;       /* sequence */
  tcpseq ack_num;       /* acknowledged sequence */
  ui8    flags;         /* control flags */
  ui16   window;        /* window advertisement */
  ui16   cksum;         /* check sum */
  ui16   urg_ptr;       /* urgent pointer */
  int i, len;

  /*-------------------------------------------------------------------*/
  /* Read segment header, converting to host order.                    */
  /*-------------------------------------------------------------------*/
  sport = ntohs(tcp->src_port);
  dport = ntohs(tcp->dst_port);
  memcpy(&seq_num, &tcp->seq_num, IP_ALEN);
  seq_num = ntohl(seq_num);
  memcpy(&ack_num, &tcp->ack_num, IP_ALEN);
  ack_num = ntohl(ack_num);
  flags   = tcp->flags;
  window  = ntohs(tcp->window);
  cksum   = ntohs(tcp->cksum);
  urg_ptr = ntohs(tcp->urg_ptr);

  /*-------------------------------------------------------------------*/
  /* Parse segment fields.                                             */
  /*-------------------------------------------------------------------*/
  printf("TCP: flags =");
  if (flags & TCPF_URG) printf(" URG");
  if (flags & TCPF_ACK) printf(" ACK");
  if (flags & TCPF_PSH) printf(" PSH");
  if (flags & TCPF_RST) printf(" RST");
  if (flags & TCPF_SYN) printf(" SYN");
  if (flags & TCPF_FIN) printf(" FIN");
  if (flags == 0) putchar('0');
  len = ntohs(ip->length) - (IP_HLEN(ip) + TCP_HLEN(tcp));
  printf(", length = %u\n", len);

  printf("TCP: src port = %u, dst port = %u\n"
         "TCP: seq_num = 0x%X, ack_num = 0x%X\n"
         "TCP: window = %u, cksum = 0x%X, urgp = %u\n",
         sport, dport, seq_num, ack_num, window, cksum, urg_ptr);

  /*-------------------------------------------------------------------*/
  /* Check if segment came with application data.                      */
  /*-------------------------------------------------------------------*/
  if (len)
  {
    int len1;
    ui8 *data;

    /*-----------------------------------------------------------------*/
    /* Print label and limit how much segment data is displayed.       */
    /*-----------------------------------------------------------------*/
    printf("TCP: ");
    len = min(len, 16);

    /*-----------------------------------------------------------------*/
    /* Determine start and length of access from first data region.    */
    /*-----------------------------------------------------------------*/
    if (buf->app_len)
    {
      data = buf->app_data;
      len1 = min(len, buf->app_len);
    }
    else
    {
      data = (ui8 *)buf->ip_data + TCP_HLEN(tcp);
      len1 = len;
    }

    /*-----------------------------------------------------------------*/
    /* Print from first segment data region.                           */
    /*-----------------------------------------------------------------*/
    for (i = 0; i < len1; ++i)
      printf("%02X ", data[i]);

    /*-----------------------------------------------------------------*/
    /* If not finished, print from second segment data region.         */
    /*-----------------------------------------------------------------*/
    data = buf->app_data2;
    for (; i < len; ++i)
      printf("%02X ", data[i]);
    putchar('\n');
  }
}

/***********************************************************************/
/*     got_udp: Decode UDP packets                                     */
/*                                                                     */
/***********************************************************************/
static void got_udp(const NetBuf *buf)
{
  Udp *udp = buf->ip_data;
  int i, len;

  printf("UDP: src port = %u, dst port = %u\n",
         ntohs(udp->src_port), ntohs(udp->dst_port));
  len = ntohs(udp->length);
  printf("UDP: length = %u, chksum = 0x%04X\n",
         len, ntohs(udp->checksum));
  if (len)
  {
    printf("UDP: ");
    len = min(len, 16);
    for (i = 0; i < len; ++i)
      printf("%02X ", udp->data[i]);
    putchar('\n');
  }
}

/***********************************************************************/
/*      got_ip: Decode IP packets                                      */
/*                                                                     */
/***********************************************************************/
static void got_ip(const NetBuf *buf)
{
  Ip *ip = (Ip *)buf->ip_pkt;
  int frag_off;

  /*-------------------------------------------------------------------*/
  /* Parse IP header fields.                                           */
  /*-------------------------------------------------------------------*/
  printf("IP: version = %u, hlen = %u, tos = %u, length = %u\n",
                  ip->ver_len >> 4,
                  ip->ver_len & 0xF,
                  ip->ip_tos,
                  ntohs(ip->length));
  printf("IP: id = 0x%04X", ntohs(ip->ip_id));
  frag_off = ntohs(ip->frag_off);
  if (frag_off & (IP_DF | IP_MF))
  {
    putchar(',');
    if (frag_off & IP_DF) printf(" DF");
    if (frag_off & IP_MF) printf(" MF");
  }
  printf(", frag offset = %u\n", frag_off & IP_FRAGOFF);
  printf("IP: ttl = %u, proto = %u, chksum = 0x%04X\n", ip->ttl,
         ip->protocol, ntohs(ip->checksum));
  printf("IP: src addr = ");
  printIP(ip->src_ip);
  printf(", dst addr = ");
  printIP(ip->dst_ip);
  putchar('\n');
}

/***********************************************************************/
/* Global Function Definitions                                         */
/***********************************************************************/

/***********************************************************************/
/*    NetProbe:                                                        */
/*                                                                     */
/***********************************************************************/
void NetProbe(const NetBuf *buf)
{
  Ip *ip = (Ip *)buf->ip_pkt;

  /*-------------------------------------------------------------------*/
  /* Only continue if global decode flag is TRUE.                      */
  /*-------------------------------------------------------------------*/
  if ((NetProbeFlag) == FALSE)
    return;

  /*-------------------------------------------------------------------*/
  /* Decode packet type and call appropriate parsing routine.          */
  /*-------------------------------------------------------------------*/
  switch (ip->protocol)
  {
    case IPT_UDP:
      got_ip(buf);
      got_udp(buf);
      break;

    case IPT_ICMP:
      got_ip(buf);
      IcmpDecode(buf);
      break;

    case IPT_TCP:
      got_ip(buf);
      got_tcp(buf);
      break;

    default:
      printf("Unknown Protocol\n");
      break;
  }
  putchar('\n');
}

#else
static int unused;
#endif