Changeset 4af54d1


Ignore:
Timestamp:
03/26/06 17:15:32 (15 years ago)
Author:
Perry Lorier <perry@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
c2f71ad
Parents:
c219603
Message:

Split protocol decode logic into a seperate file, cleaned up some of the
protocol decode logic. Started IPv6 support, added some
trace_get_payload_from_* helper functions

Location:
lib
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • lib/Makefile.am

    r49babe0 r4af54d1  
    77                format_helper.c format_helper.h \
    88                parse_cmd.c parse_cmd.h libtrace_int.h lt_inttypes.h \
    9                 linktypes.c
     9                linktypes.c protocols.c
     10
    1011if DAG2_4
    1112nodist_libtrace_la_SOURCES = dagopts.c dagapi.c
  • lib/libtrace.h

    r9c4b5e3 r4af54d1  
    176176    struct in_addr ip_src;              /**< source address */
    177177    struct in_addr ip_dst;              /**< dest address */
    178 } libtrace_ip_t
    179 ;
     178} libtrace_ip_t;
     179
     180/** IPv6 header structure */
     181typedef PACKED struct libtrace_ip6
     182{
     183#if BYTE_ORDER == LITTLE_ENDIAN
     184    unsigned int flow:4;                /**< Flow label */
     185    unsigned int tclass:8;              /**< Traffic class */
     186    unsigned int version:4;             /**< IP Version (6) */
     187#elif BYTE_ORDER == BIG_ENDIAN
     188    unsigned int version:4;             /**< IP Version (6) */
     189    unsigned int tclass:8;              /**< Traffic class */
     190    unsigned int flow:4;                /**< Flow label */
     191#else
     192#   error "Adjust your <bits/endian.h> defines"
     193#endif
     194    uint16_t peln;                      /**< Payload length */
     195    uint8_t nxthdr;                     /**< Next header */
     196    uint8_t hlim;                       /**< Hop limit */
     197    struct in6_addr ip_src;             /**< source address */
     198    struct in6_addr ip_dst;             /**< dest address */
     199} libtrace_ip6_t;
    180200
    181201/** Structure for dealing with TCP packets */
     
    293313 u_int16_t ether_type;          /**< ether type */
    294314} __attribute__ ((packed)) libtrace_pos;
     315
     316/** 802.11 header */
     317typedef struct libtrace_80211_t {
     318        unsigned int      protocol:2;
     319        unsigned int      type:2;
     320        unsigned int      subtype:4;
     321        unsigned int      to_ds:1;              /**< Packet to Distribution Service */
     322        unsigned int      from_ds:1;            /**< Packet from Distribution Service */
     323        unsigned int      more_frag:1;          /**< Packet has more fragments */
     324        unsigned int      retry:1;              /**< Packet is a retry */
     325        unsigned int      power:1;
     326        unsigned int      more_data:1;
     327        unsigned int      wep:1;
     328        unsigned int      order:1;
     329        unsigned int     duration;
     330        uint8_t      mac1[6];
     331        uint8_t      mac2[6];
     332        uint8_t      mac3[6];
     333        uint16_t     SeqCtl;
     334        uint8_t      mac4[6];
     335} libtrace_80211_t;
     336
     337
    295338/*@}*/
    296339
     
    621664void *trace_get_transport(const libtrace_packet_t *packet);
    622665
    623 /** Gets a pointer to the transport layer header (if any) given a pointer to the
    624  * IP header
     666/** Gets a pointer to the payload given a pointer to the IP header
    625667 * @param ip            The IP Header
    626668 * @param[out] skipped  An output variable of the number of bytes skipped
     
    629671 *
    630672 * Skipped can be NULL, in which case it will be ignored
    631  */
    632 void *trace_get_transport_from_ip(const libtrace_ip_t *ip, int *skipped);
     673 * @note This was called trace_get_transport_from_ip in libtrace2
     674 */
     675void *trace_get_payload_from_ip(libtrace_ip_t *ip, int *skipped);
     676
     677/** Gets a pointer to the payload given a pointer to a tcp header
     678 * @param tcp           The tcp Header
     679 * @param[out] skipped  An output variable of the number of bytes skipped
     680 *
     681 * @return a pointer to the transport layer header, or NULL if there is no header
     682 *
     683 * Skipped can be NULL, in which case it will be ignored
     684 * @note This was called trace_get_transport_from_ip in libtrace2
     685 */
     686void *trace_get_payload_from_tcp(libtrace_tcp_t *tcp, int *skipped);
     687
     688/** Gets a pointer to the payload given a pointer to a udp header
     689 * @param udp           The udp Header
     690 * @param[out] skipped  An output variable of the number of bytes skipped
     691 *
     692 * @return a pointer to the transport layer header, or NULL if there is no header
     693 *
     694 * Skipped can be NULL, in which case it will be ignored
     695 * @note This was called trace_get_transport_from_ip in libtrace2
     696 */
     697void *trace_get_payload_from_udp(libtrace_udp_t *udp, int *skipped);
     698
     699/** Gets a pointer to the payload given a pointer to a icmp header
     700 * @param icmp          The udp Header
     701 * @param[out] skipped  An output variable of the number of bytes skipped
     702 *
     703 * @return a pointer to the transport layer header, or NULL if there is no header
     704 *
     705 * Skipped can be NULL, in which case it will be ignored
     706 * @note This was called trace_get_transport_from_ip in libtrace2
     707 */
     708void *trace_get_payload_from_udp(libtrace_udp_t *udp, int *skipped);
    633709
    634710/** get a pointer to the TCP header (if any)
     
    651727 */
    652728SIMPLE_FUNCTION
    653 libtrace_tcp_t *trace_get_tcp_from_ip(const libtrace_ip_t *ip,int *skipped);
     729libtrace_tcp_t *trace_get_tcp_from_ip(libtrace_ip_t *ip,int *skipped);
    654730
    655731/** get a pointer to the UDP header (if any)
     
    659735 */
    660736SIMPLE_FUNCTION
    661 libtrace_udp_t *trace_get_udp(const libtrace_packet_t *packet);
     737libtrace_udp_t *trace_get_udp(libtrace_packet_t *packet);
    662738
    663739/** get a pointer to the UDP header (if any) given a pointer to the IP header
     
    670746 */
    671747SIMPLE_FUNCTION
    672 libtrace_udp_t *trace_get_udp_from_ip(const libtrace_ip_t *ip,int *skipped);
     748libtrace_udp_t *trace_get_udp_from_ip(libtrace_ip_t *ip,int *skipped);
    673749
    674750/** get a pointer to the ICMP header (if any)
     
    689765 */
    690766SIMPLE_FUNCTION
    691 libtrace_icmp_t *trace_get_icmp_from_ip(const libtrace_ip_t *ip,int *skipped);
     767libtrace_icmp_t *trace_get_icmp_from_ip(libtrace_ip_t *ip,int *skipped);
    692768/*@}*/
    693769
  • lib/libtrace_int.h

    r7ac9705 r4af54d1  
    119119void trace_set_err_out(libtrace_out_t *trace, int errcode, const char *msg,...);
    120120
    121 struct trace_sll_header_t {
     121typedef struct trace_sll_header_t {
    122122        uint16_t pkttype;               /* packet type */
    123123        uint16_t hatype;                /* link-layer address type */
     
    125125        char addr[8];                   /* link-layer address */
    126126        uint16_t protocol;              /* protocol */
    127 };
     127} trace_sll_header_t;
    128128
    129129#ifndef PF_RULESET_NAME_SIZE
  • lib/trace.c

    reea0f87 r4af54d1  
    696696*/
    697697
    698 /* get a pointer to the IP header (if any)
    699  * @param packet        a pointer to a libtrace_packet structure
    700  *
    701  * @returns a pointer to the IP header, or NULL if there is not an IP packet
    702  */
    703 struct libtrace_ip *trace_get_ip(const struct libtrace_packet_t *packet) {
    704         struct libtrace_ip *ipptr = 0;
    705 
    706         switch(trace_get_link_type(packet)) {
    707                 case TRACE_TYPE_80211_PRISM:
    708                         {
    709                                 struct ieee_802_11_header *wifi =
    710                                         (void*)(
    711                                          (char*)trace_get_link(packet)+144);
    712                                 if (!wifi) {
    713                                         ipptr = NULL;
    714                                         break;
    715                                 }
    716 
    717                                 /* Data packet? */
    718                                 if (wifi->type != 2) {
    719                                         ipptr = NULL;
    720                                 }
    721                                 else {
    722                                         struct ieee_802_11_payload *eth =
    723                                                 (void*)((char*)wifi+sizeof(struct ieee_802_11_header));
    724                                         ipptr = NULL;
    725 
    726                                         if (ntohs(eth->type) == 0x0800) {
    727                                             ipptr=(void*)
    728                                                     ((char*)eth + sizeof(*eth));
    729                                         } else if (ntohs(eth->type) == 0x8100) {
    730                                             struct libtrace_8021q *vlanhdr =
    731                                                 (struct libtrace_8021q *)eth;
    732                                             if (ntohs(vlanhdr->vlan_ether_type)
    733                                                             == 0x0800) {
    734                                                 ipptr=(void*)(
    735                                                  (char*)eth+sizeof(*vlanhdr));
    736                                             }
    737                                         }
    738                                 }
    739                         }
    740                         break;
    741                 case TRACE_TYPE_80211:
    742                         {
    743                                
    744                                 struct ieee_802_11_header *wifi = trace_get_link(packet);       
    745                                 if (!wifi) {
    746                                         ipptr = NULL;
    747                                         break;
    748                                 }
    749 
    750                                 /* Data packet? */
    751                                 if (wifi->type != 2) {
    752                                         ipptr = NULL;
    753                                 }
    754                                 else {
    755                                         struct ieee_802_11_payload *eth =
    756                                                 (void*)((char*)wifi+sizeof(struct ieee_802_11_header));
    757                                         ipptr = NULL;
    758 
    759                                         if (ntohs(eth->type) == 0x0800) {
    760                                             ipptr=(void*)((char*)eth + sizeof(*eth));
    761                                         } else if (ntohs(eth->type) == 0x8100) {
    762                                             struct libtrace_8021q *vlanhdr =
    763                                                 (struct libtrace_8021q *)eth;
    764                                             if (ntohs(vlanhdr->vlan_ether_type)
    765                                                             == 0x0800) {
    766                                                 ipptr=(void*)((char*)eth +
    767                                                         sizeof(*vlanhdr));
    768                                             }
    769                                         }
    770                                 }
    771                         }
    772                         break;
    773                 case TRACE_TYPE_ETH:
    774                 case TRACE_TYPE_LEGACY_ETH:
    775                         {
    776                                 struct libtrace_ether *eth =
    777                                         trace_get_link(packet);
    778                                 if (!eth) {
    779                                         ipptr = NULL;
    780                                         break;
    781                                 }
    782                                 ipptr = NULL;
    783                                
    784                                 if (ntohs(eth->ether_type)==0x0800) {
    785                                         ipptr = (void*)((char *)eth + sizeof(*eth));
    786                                 } else if (ntohs(eth->ether_type) == 0x8100) {
    787                                         struct libtrace_8021q *vlanhdr =
    788                                                 (struct libtrace_8021q *)eth;
    789                                         if (ntohs(vlanhdr->vlan_ether_type)
    790                                                         == 0x0800) {
    791                                                 ipptr = (void*)((char *)eth +
    792                                                         sizeof(*vlanhdr));
    793                                         }
    794                                 }
    795                                 break;
    796                         }
    797                 case TRACE_TYPE_NONE:
    798                         ipptr = trace_get_link(packet);
    799                         break;
    800                 case TRACE_TYPE_LINUX_SLL:
    801                         {
    802                                 struct trace_sll_header_t *sll;
    803 
    804                                 sll = trace_get_link(packet);
    805                                 if (!sll) {
    806                                         ipptr = NULL;
    807                                         break;
    808                                 }
    809                                 if (ntohs(sll->protocol)!=0x0800) {
    810                                         ipptr = NULL;
    811                                 }
    812                                 else {
    813                                         ipptr = (void*)((char*)sll+
    814                                                         sizeof(*sll));
    815                                 }
    816                         }
    817                         break;
    818                 case TRACE_TYPE_PFLOG:
    819                         {
    820                                 struct trace_pflog_header_t *pflog;
    821                                 pflog = trace_get_link(packet);
    822                                 if (!pflog) {
    823                                         ipptr = NULL;
    824                                         break;
    825                                 }
    826                                 if (pflog->af != AF_INET) {
    827                                         ipptr = NULL;
    828                                 } else {
    829                                         ipptr = (void*)((char*)pflog+
    830                                                 sizeof(*pflog));
    831                                 }
    832                         }
    833                         break;
    834                 case TRACE_TYPE_LEGACY_POS:
    835                         {
    836                                 /* 64 byte capture. */
    837                                 struct libtrace_pos *pos =
    838                                         trace_get_link(packet);
    839                                 if (ntohs(pos->ether_type) == 0x0800) {
    840                                         ipptr=(void*)((char *)pos+sizeof(*pos));
    841                                 } else {
    842                                         ipptr=NULL;
    843                                 }
    844                                 break;
    845                                
    846                         }
    847                 case TRACE_TYPE_LEGACY_ATM:
    848                 case TRACE_TYPE_ATM:
    849                         {
    850                                 /* 64 byte capture. */
    851                                 struct libtrace_llcsnap *llc =
    852                                         trace_get_link(packet);
    853 
    854                                 /* advance the llc ptr +4 into the link layer.
    855                                  * need to check what is in these 4 bytes.
    856                                  * don't have time!
    857                                  */
    858                                 llc = (void*)((char *)llc + 4);
    859                                 if (ntohs(llc->type) == 0x0800) {
    860                                         ipptr=(void*)((char*)llc+sizeof(*llc));
    861                                 } else {
    862                                         ipptr = NULL;
    863                                 }
    864                                 break;
    865                         }
    866                 default:
    867                         fprintf(stderr,"Don't understand link layer type %i in trace_get_ip()\n",
    868                                 trace_get_link_type(packet));
    869                         ipptr=NULL;
    870                         break;
    871         }
    872 
    873         return ipptr;
    874 }
    875 
    876 #define SW_IP_OFFMASK 0xff1f
    877 
    878 /* Gets a pointer to the transport layer header (if any)
    879  * @param packet        a pointer to a libtrace_packet structure
    880  *
    881  * @returns a pointer to the transport layer header, or NULL if there is no header
    882  */
    883 void *trace_get_transport(const struct libtrace_packet_t *packet) {
    884         void *trans_ptr = 0;
    885         struct libtrace_ip *ipptr = 0;
    886 
    887         if (!(ipptr = trace_get_ip(packet))) {
    888                 return 0;
    889         }
    890 
    891         if ((ipptr->ip_off & SW_IP_OFFMASK) == 0) {
    892                 trans_ptr = (void *)((ptrdiff_t)ipptr + (ipptr->ip_hl * 4));
    893         }
    894         return trans_ptr;
    895 }
    896 
    897 /* Gets a pointer to the transport layer header (if any) given a pointer to the
    898  * IP header
    899  * @param ip            The IP Header
    900  * @param[out] skipped  An output variable of the number of bytes skipped
    901  *
    902  * @returns a pointer to the transport layer header, or NULL if there is no header
    903  *
    904  * Skipped can be NULL, in which case it will be ignored
    905  */
    906 void *trace_get_transport_from_ip(const libtrace_ip_t *ip, int *skipped) {
    907         void *trans_ptr = 0;   
    908 
    909         if ((ip->ip_off & SW_IP_OFFMASK) == 0) {
    910                 trans_ptr = (void *)((ptrdiff_t)ip + (ip->ip_hl * 4));
    911         }
    912 
    913         if (skipped)
    914                 *skipped = (ip->ip_hl*4);
    915 
    916         return trans_ptr;
    917 }
    918 
    919 /* get a pointer to the TCP header (if any)
    920  * @param packet        a pointer to a libtrace_packet structure
    921  *
    922  * @returns a pointer to the TCP header, or NULL if there is not a TCP packet
    923  */
    924 libtrace_tcp_t *trace_get_tcp(const libtrace_packet_t *packet) {
    925         struct libtrace_tcp *tcpptr = 0;
    926         struct libtrace_ip *ipptr = 0;
    927 
    928         if(!(ipptr = trace_get_ip(packet))) {
    929                 return 0;
    930         }
    931         if (ipptr->ip_p == 6) {
    932                 tcpptr = (struct libtrace_tcp *)trace_get_transport_from_ip(ipptr, 0);
    933         }
    934         return tcpptr;
    935 }
    936 
    937 /* get a pointer to the TCP header (if any) given a pointer to the IP header
    938  * @param ip            The IP header
    939  * @param[out] skipped  An output variable of the number of bytes skipped
    940  *
    941  * @returns a pointer to the TCP header, or NULL if this is not a TCP packet
    942  *
    943  * Skipped can be NULL, in which case it will be ignored by the program.
    944  */
    945 libtrace_tcp_t *trace_get_tcp_from_ip(const libtrace_ip_t *ip, int *skipped)
    946 {
    947         struct libtrace_tcp *tcpptr = 0;
    948 
    949         if (ip->ip_p == 6)  {
    950                 tcpptr = (struct libtrace_tcp *)trace_get_transport_from_ip(ip, skipped);
    951         }
    952 
    953         return tcpptr;
    954 }
    955 
    956 /* get a pointer to the UDP header (if any)
    957  * @param packet        a pointer to a libtrace_packet structure
    958  *
    959  * @returns a pointer to the UDP header, or NULL if this is not a UDP packet
    960  */
    961 struct libtrace_udp *trace_get_udp(const struct libtrace_packet_t *packet) {
    962         struct libtrace_udp *udpptr = 0;
    963         struct libtrace_ip *ipptr = 0;
    964        
    965         if(!(ipptr = trace_get_ip(packet))) {
    966                 return 0;
    967         }
    968         if (ipptr->ip_p == 17)  {
    969                 udpptr = (struct libtrace_udp *)trace_get_transport_from_ip(ipptr, 0);
    970         }
    971 
    972         return udpptr;
    973 }
    974 
    975 /* get a pointer to the UDP header (if any) given a pointer to the IP header
    976  * @param ip            The IP header
    977  * @param[out] skipped  An output variable of the number of bytes skipped
    978  *
    979  * @returns a pointer to the UDP header, or NULL if this is not a UDP packet
    980  *
    981  * Skipped can be NULL, in which case it will be ignored by the program.
    982  */
    983 struct libtrace_udp *trace_get_udp_from_ip(const struct libtrace_ip *ip, int *skipped)
    984 {
    985         struct libtrace_udp *udpptr = 0;
    986 
    987         if (ip->ip_p == 17) {
    988                 udpptr = (struct libtrace_udp *)trace_get_transport_from_ip(ip, skipped);
    989         }
    990 
    991         return udpptr;
    992 }
    993 
    994 
    995 /* get a pointer to the ICMP header (if any)
    996  * @param packet        a pointer to a libtrace_packet structure
    997  *
    998  * @returns a pointer to the ICMP header, or NULL if this is not a ICMP packet
    999  */
    1000 struct libtrace_icmp *trace_get_icmp(const struct libtrace_packet_t *packet) {
    1001         struct libtrace_icmp *icmpptr = 0;
    1002         struct libtrace_ip *ipptr = 0;
    1003        
    1004         if(!(ipptr = trace_get_ip(packet))) {
    1005                 return 0;
    1006         }
    1007         if (ipptr->ip_p == 1){
    1008                 icmpptr = (struct libtrace_icmp *)trace_get_transport_from_ip(ipptr, 0);
    1009         }
    1010         return icmpptr;
    1011 }
    1012 
    1013 /* get a pointer to the ICMP header (if any) given a pointer to the IP header
    1014  * @param ip            The IP header
    1015  * @param[out] skipped  An output variable of the number of bytes skipped
    1016  *
    1017  * @returns a pointer to the ICMP header, or NULL if this is not a ICMP packet
    1018  *
    1019  * Skipped can be NULL, in which case it will be ignored by the program.
    1020  */
    1021 struct libtrace_icmp *trace_get_icmp_from_ip(const struct libtrace_ip *ip, int *skipped)
    1022 {
    1023         struct libtrace_icmp *icmpptr = 0;
    1024 
    1025         if (ip->ip_p == 1)  {
    1026                 icmpptr = (struct libtrace_icmp *)trace_get_transport_from_ip(ip, skipped);
    1027         }
    1028 
    1029         return icmpptr;
    1030 }
     698
     699
     700
    1031701/* parse an ip or tcp option
    1032702 * @param[in,out] ptr   the pointer to the current option
     
    1243913uint8_t *trace_get_source_mac(const struct libtrace_packet_t *packet) {
    1244914        void *link = trace_get_link(packet);
    1245         struct ieee_802_11_header *wifi = link;
    1246         struct libtrace_ether *ethptr = link;
     915        libtrace_80211_t *wifi = link;
     916        libtrace_ether_t *ethptr = link;
    1247917        if (!link)
    1248918                return NULL;
     
    1266936uint8_t *trace_get_destination_mac(const struct libtrace_packet_t *packet) {
    1267937        void *link = trace_get_link(packet);
    1268         struct ieee_802_11_header *wifi = link;
    1269         struct libtrace_ether *ethptr = link;
     938        libtrace_80211_t *wifi = link;
     939        libtrace_ether_t *ethptr = link;
    1270940        if (!link)
    1271941                return NULL;
     
    14551125uint16_t trace_get_source_port(const struct libtrace_packet_t *packet)
    14561126{
    1457         struct libtrace_ip *ip = trace_get_ip(packet);
    1458         struct ports_t *port;
    1459         if (6 != ip->ip_p
    1460           && 17 != ip->ip_p)
    1461                 return 0;
    1462         if (0 != (ip->ip_off & SW_IP_OFFMASK))
    1463                 return 0;
    1464 
    1465         port = (struct ports_t *)((ptrdiff_t)ip + (ip->ip_hl * 4));
     1127        struct ports_t *port = trace_get_transport(packet);
    14661128
    14671129        return ntohs(port->src);
     
    14711133uint16_t trace_get_destination_port(const struct libtrace_packet_t *packet)
    14721134{
    1473         struct libtrace_ip *ip = trace_get_ip(packet);
    1474         struct ports_t *port;
    1475 
    1476         if (6 != ip->ip_p
    1477           && 17 != ip->ip_p)
    1478                 return 0;
    1479 
    1480         if (0 != (ip->ip_off & SW_IP_OFFMASK))
    1481                 return 0;
    1482 
    1483         port = (struct ports_t *)((ptrdiff_t)ip + (ip->ip_hl * 4));
     1135        struct ports_t *port = trace_get_transport(packet);
    14841136
    14851137        return ntohs(port->dst);
     
    18181470        return buf2;
    18191471}
     1472
  • lib/wag.h

    r0d768c8 r4af54d1  
    107107};
    108108
    109 struct ieee_802_11_header {
    110         unsigned int      protocol:2;
    111         unsigned int      type:2;
    112         unsigned int      subtype:4;
    113         unsigned int      to_ds:1;
    114         unsigned int      from_ds:1;
    115         unsigned int      more_frag:1;
    116         unsigned int      retry:1;
    117         unsigned int      power:1;
    118         unsigned int      more_data:1;
    119         unsigned int      wep:1;
    120         unsigned int      order:1;
    121         unsigned int     duration;
    122         uint8_t      mac1[6];
    123         uint8_t      mac2[6];
    124         uint8_t      mac3[6];
    125         uint16_t     SeqCtl;
    126         uint8_t      mac4[6];
    127 };
    128 
    129109/** 802.11 payload */
    130110struct ieee_802_11_payload {
Note: See TracChangeset for help on using the changeset viewer.