Main Page Modules Data Structures File List Data Fields Globals Related Pages

# Gathering Statistics on the network traffic
[WinPcap tutorial: a step by step guide to program WinPcap]

This lesson shows another advanced feature of WinPcap: the ability to collect statistics about network traffic. The statistical engine makes use of the kernel-level packet filter to efficiently classify the incoming packet. You can give a look at the NPF driver internals manual if you want to know more details.

In order to use this feature to monitor the network, the programmer must open an adapter and put it in statistical mode. This can be done with pcap_setmode(). In particular, MODE_STAT must be used as the mode argument of this function.

With statistical mode, making an application that monitors the TCP traffic load is a matter of few lines of code. The following sample shows how to do it.

    /*
     * Copyright (c) 1999 - 2002
     *  Politecnico di Torino.  All rights reserved.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that: (1) source code distributions
     * retain the above copyright notice and this paragraph in its entirety, (2)
     * distributions including binary code include the above copyright notice and
     * this paragraph in its entirety in the documentation or other materials
     * provided with the distribution, and (3) all advertising materials mentioning
     * features or use of this software display the following acknowledgement:
     * ``This product includes software developed by the Politecnico
     * di Torino, and its contributors.'' Neither the name of
     * the University nor the names of its contributors may be used to endorse
     * or promote products derived from this software without specific prior
     * written permission.
     * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
     * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
     * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
     */

    #include <stdlib.h>
    #include <stdio.h>

    #include <pcap.h>

    void usage();

    void dispatcher_handler(u_char *,
        const struct pcap_pkthdr *, const u_char *);

    void main(int argc, char **argv) {
        pcap_t *fp;
        char error[PCAP_ERRBUF_SIZE];
        struct timeval st_ts;
        u_int netmask;
        struct bpf_program fcode;

        /* Check the validity of the command line */
        if (argc != 2)
        {
            usage();
            return;
        }

        /* Open the output adapter */
        if((fp = pcap_open_live(argv[1], 100, 1, 1000, error) ) == NULL)
        {
            fprintf(stderr,"\nError opening adapter: %s\n", error);
            return;
        }

        /* Don't care about netmask, it won't be used for this filter */
        netmask=0xffffff;

        //compile the filter
        if(pcap_compile(fp, &fcode, "tcp", 1, netmask) <0 ){
            fprintf(stderr,"\nUnable to compile the packet filter. Check the syntax.\n");
            /* Free the device list */
            return;
        }

        //set the filter
        if(pcap_setfilter(fp, &fcode)<0){
            fprintf(stderr,"\nError setting the filter.\n");
            /* Free the device list */
            return;
        }

        /* Put the interface in statstics mode */
        pcap_setmode(fp, MODE_STAT);

        printf("TCP traffic summary:\n");

        /* Start the main loop */
        pcap_loop(fp, 0, dispatcher_handler, (PUCHAR)&st_ts);

        return;
    }

    void dispatcher_handler(u_char *state, const struct pcap_pkthdr *header, const u_char *pkt_data)
    {
        struct timeval *old_ts = (struct timeval *)state;
        u_int delay;
        LARGE_INTEGER Bps,Pps;
        struct tm *ltime;
        char timestr[16];

        /* Calculate the delay in microseconds from the last sample. */
        /* This value is obtained from the timestamp that the associated with the sample. */
        delay=(header->ts.tv_sec - old_ts->tv_sec) * 1000000 - old_ts->tv_usec + header->ts.tv_usec;
        /* Get the number of Bits per second */
        Bps.QuadPart=(((*(LONGLONG*)(pkt_data + 8)) * 8 * 1000000) / (delay));
        /*                                            ^      ^
                                                      |      |
                                                      |      |
                                                      |      |
                             converts bytes in bits --       |
                                                             |
                        delay is expressed in microseconds --
        */

        /* Get the number of Packets per second */
        Pps.QuadPart=(((*(LONGLONG*)(pkt_data)) * 1000000) / (delay));

        /* Convert the timestamp to readable format */
        ltime=localtime(&header->ts.tv_sec);
        strftime( timestr, sizeof timestr, "%H:%M:%S", ltime);

        /* Print timestamp*/
        printf("%s ", timestr);

        /* Print the samples */
        printf("BPS=%I64u ", Bps.QuadPart);
        printf("PPS=%I64u\n", Pps.QuadPart);

        //store current timestamp
        old_ts->tv_sec=header->ts.tv_sec;
        old_ts->tv_usec=header->ts.tv_usec;
    }

    void usage()
    {

        printf("\nShows the TCP traffic load, in bits per second and packets per second.\nCopyright (C) 2002 Loris Degioanni.\n");
        printf("\nUsage:\n");
        printf("\t tcptop adapter\n");
        printf("\t You can use \"WinDump -D\" if you don't know the name of your adapters.\n");

        exit(0);
    }

Before enabling statistical mode, the user has the possibility to set a filter, that defines the subset of network traffic that will be monitored. See the paragraph on the Filtering expression syntax for details. If no filter has been set, the whole traffic will be monitored. Once

- the filter is set
- pcap_setmode() is called
- callback invocation is enabled with pcap_loop()

the interface descriptor starts to work in statistical mode. Notice the fourth parameter (to_ms) of pcap_open_live(): it defines the interval among the statistical samples. The callback receives, every to_ms milliseconds, the samples calculated by the driver. These samples are encapsulated in the second and third parameter of the callback, like shown in the following figure:

Two 64-bit counters are provided: the number of packets and the amount of bytes received during the last interval.

In the example, the adapter is opened with a timeout of 1000 ms. This means that dispatcher_handler() is called once per second. At this point a filter that keeps only tcp packets is compiled and set. Then pcap_setmode() and pcap_loop() are called. Note that a struct timeval pointer is passed to pcap_loop() as the user parameter. This structure will be used to store a timestamp in order to calculate the interval between two samples. dispatcher_handler()uses this interval to obtain the bits per second and the packets per second and then prints these values on the screen.

Note finally that this example is by far more efficient than a program that captures the packets in the traditional way and calculates statistics at user-level: statistical mode requires the minumum amount of data copies and context switches, therefore the CPU is optimized. Moreover, a very small quantity of memory is required.

documentation. Copyright (c) 2002-2003 Politecnico di Torino. All rights reserved.