Changeset 29532e3 for lib/protocols_transport.c

Timestamp:

01/05/12 16:49:23 (10 years ago)

Author:

Shane Alcock <salcock@…>

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:

cc6fcee

Parents:

48d72f8

Message:

Added support for parsing OSPFv2 headers, based on Simon Wadsworth's 591 project.

A few comments on the implementation thus far:

• This code has only been tested with Hello, LS Update and LS Acknowledge packets. DB Desc and LS Request is completely untested, mainly due to a lack of traces containing those packets.
• This release supports not only accessing the basic OSPF headers but also parsing the interesting LSAs and Link Ids in LSA Update packets.
• OSPF is not a nice protocol - there's lots of dynamic length stuff for starters. I've tried to design the API so that is as nice as possible for the end user who may not be overly knowledgeable about OSPF. In particular, I've tried to minimise the amount of pointer arithmetic needed to get at the LSAs and Link Ids. More documentation and an example program will come in a later commit.
• Also, whoever came up with 24-bit metric values should be shot. To make life easier for users, I've included functions to return the correct value for the metric from a given header. I hope you all appreciate the extra effort :)

File:

• lib/protocols_transport.c (modified) (1 diff)

lib/protocols_transport.c

@@ -194 +194 @@
 }
 
+DLLEXPORT void *trace_get_ospf_header(libtrace_packet_t *packet,
+                uint8_t *version, uint32_t *remaining) {
+        uint8_t proto;
+        void *ospf;
+        uint32_t dummy_rem = 0;
+
+
+        if (!remaining)
+                remaining = &dummy_rem;
+
+        assert(version != NULL && "version may not be NULL when calling trace_get_ospf_header!");
+
+        ospf = trace_get_transport(packet, &proto, remaining);
+
+        if (!ospf || proto != TRACE_IPPROTO_OSPF || *remaining == 0)
+                return NULL;
+
+        *version = *((uint8_t *)ospf);
+        
+        if (*version == 2 && *remaining < sizeof(libtrace_ospf_v2_t))
+                return NULL;
+
+        return ospf;
+}
+
+DLLEXPORT void *trace_get_ospf_contents_v2(libtrace_ospf_v2_t *header,
+                uint8_t *ospf_type, uint32_t *remaining) {
+
+        uint8_t dummy_type;
+        char *ptr;
+        
+        assert(remaining != NULL && "remaining may not be NULL when calling trace_get_ospf_contents!");
+
+        if (!ospf_type)
+                ospf_type = &dummy_type;
+
+        if (!header || *remaining < sizeof(libtrace_ospf_v2_t)) {
+                *ospf_type = 0;
+                *remaining = 0;
+                return NULL;
+        }
+        
+        *ospf_type = header->type;
+
+        ptr = ((char *)header) + sizeof(libtrace_ospf_v2_t);
+        *remaining -= sizeof(libtrace_ospf_v2_t);
+
+        return (void *)ptr;
+
+}
+
+DLLEXPORT unsigned char *trace_get_first_ospf_link_from_router_lsa_v2(
+                libtrace_ospf_router_lsa_v2_t *lsa,
+                uint32_t *remaining) {
+
+        unsigned char *link_ptr = NULL;
+        assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_link_from_router_lsa_v2!");
+
+        if (!lsa || *remaining < sizeof(libtrace_ospf_router_lsa_v2_t)) {
+                *remaining = 0;
+                return NULL;
+        }
+
+        link_ptr = ((unsigned char *)lsa) + sizeof(libtrace_ospf_router_lsa_v2_t);
+        *remaining -= sizeof(libtrace_ospf_router_lsa_v2_t);
+        return link_ptr;
+
+}
+
+DLLEXPORT unsigned char *trace_get_first_ospf_lsa_from_db_desc_v2(
+                libtrace_ospf_db_desc_v2_t *db_desc,
+                uint32_t *remaining) {
+
+        unsigned char *lsa_ptr = NULL;
+
+        assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_ospf_v2_lsa!");
+
+        if (!db_desc || *remaining < sizeof(libtrace_ospf_db_desc_v2_t)) {
+                *remaining = 0;
+                return NULL;
+        }
+        
+        lsa_ptr = ((unsigned char *)db_desc) + sizeof(libtrace_ospf_db_desc_v2_t);
+        *remaining -= sizeof(libtrace_ospf_db_desc_v2_t);
+
+        return lsa_ptr;
+}
+
+DLLEXPORT unsigned char *trace_get_first_ospf_lsa_from_update_v2(
+                libtrace_ospf_ls_update_t *ls_update,
+                uint32_t *remaining) {
+
+        unsigned char *lsa_ptr = NULL;
+
+        assert(remaining != NULL && "remaining may not be NULL when calling trace_get_first_ospf_v2_lsa!");
+
+        if (!ls_update || *remaining < sizeof(libtrace_ospf_ls_update_t)) {
+                *remaining = 0;
+                return NULL;
+        }
+        
+        lsa_ptr = ((unsigned char *)ls_update) + sizeof(libtrace_ospf_ls_update_t);
+        *remaining -= sizeof(libtrace_ospf_ls_update_t);
+
+        return lsa_ptr;
+}
+
+DLLEXPORT uint32_t trace_get_ospf_metric_from_as_external_lsa_v2(
+                libtrace_ospf_as_external_lsa_v2_t *as_lsa) {
+
+        uint32_t metric = 0;
+
+        assert(as_lsa);
+
+        metric = as_lsa->metric_a << 16;
+        metric |= (as_lsa->metric_b << 8);
+        metric |= as_lsa->metric_c;
+
+        return metric;
+}
+
+DLLEXPORT uint32_t trace_get_ospf_metric_from_summary_lsa_v2(
+                libtrace_ospf_summary_lsa_v2_t *sum_lsa) {
+
+        uint32_t metric = 0;
+
+        assert(sum_lsa);
+
+        metric = sum_lsa->metric_a << 16;
+        metric |= (sum_lsa->metric_b << 8);
+        metric |= sum_lsa->metric_c;
+
+        return metric;
+}
+
+DLLEXPORT int trace_get_next_ospf_link_v2(unsigned char **current,
+                libtrace_ospf_link_v2_t **link,
+                uint32_t *remaining,
+                uint32_t *link_len) {
+
+        if (*current == NULL || *remaining < sizeof(libtrace_ospf_link_v2_t)) {
+                *remaining = 0;
+                *link = NULL;
+                return 0;
+        }
+
+        *link = (libtrace_ospf_link_v2_t *)*current;
+
+        /* XXX The spec allows for multiple metrics for a single link. This
+         * approach won't support this, so we may need to be more intelligent
+         * about this in future */
+        *remaining -= sizeof(libtrace_ospf_link_v2_t);
+        *link_len = sizeof(libtrace_ospf_link_v2_t);
+        *current += sizeof(libtrace_ospf_link_v2_t);
+        
+        return 1; 
+
+}
+
+DLLEXPORT int trace_get_next_ospf_lsa_v2(unsigned char **current,
+                libtrace_ospf_lsa_v2_t **lsa_hdr,
+                unsigned char **lsa_body,
+                uint32_t *remaining,
+                uint8_t *lsa_type,
+                uint16_t *lsa_length) {
+
+        int valid_lsa = 0;
+
+        if (*current == NULL || *remaining < sizeof(libtrace_ospf_lsa_v2_t)) {
+                *lsa_hdr = NULL;
+                *lsa_body = NULL;
+                *remaining = 0;
+
+                return 0;
+
+        }
+
+        *lsa_hdr = (libtrace_ospf_lsa_v2_t *)(*current);
+        *lsa_type = (*lsa_hdr)->lsa_type;
+        *lsa_length = ntohs((*lsa_hdr)->length);
+
+        /* Check that the LSA type is valid */
+        switch (*lsa_type) {
+                case TRACE_OSPF_LS_ROUTER:
+                case TRACE_OSPF_LS_NETWORK:
+                case TRACE_OSPF_LS_SUMMARY:
+                case TRACE_OSPF_LS_ASBR_SUMMARY:
+                case TRACE_OSPF_LS_EXTERNAL:
+                        valid_lsa = 1;
+                        break;
+        }
+                
+        if (*lsa_length > *remaining || !valid_lsa) {
+                /* LSA is incomplete or an invalid type.
+                 *
+                 * If this occurs, you've probably managed to read something
+                 * that is NOT a legit LSA */
+                *remaining = 0;
+                return -1;
+        }
+        
+        /* Some OSPF packets, e.g. LS ACKs, only contain LSA headers. If this
+         * is the case, we'll set the body pointer to NULL so the caller 
+         * can't read invalid data */
+        if (*lsa_length == sizeof(libtrace_ospf_lsa_v2_t))
+                *lsa_body = NULL;
+        else
+                *lsa_body = (*current + sizeof(libtrace_ospf_lsa_v2_t));
+
+        *remaining -= *lsa_length;
+        *current += *lsa_length;
+
+        if (remaining == 0) {
+                /* No more LSAs */
+                return 0;
+        }
+
+        return 1;
+
+}
+
 DLLEXPORT libtrace_tcp_t *trace_get_tcp(libtrace_packet_t *packet) {
         uint8_t proto;