]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-bgp.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
cleaned up bgp_attr_print{}
[tcpdump] / print-bgp.c
diff --git a/print-bgp.c b/print-bgp.c
index 864fffa37543c11fe832b001ee0a6fe319e91dad..fe87a9f8d6cc84df785b98db51b10c44dfe6f70a 100644 (file)
--- a/print-bgp.c
+++ b/print-bgp.c
@@ -33,7 +33,7 @@
 
 #ifndef lint
 static const char rcsid[] =
 
 #ifndef lint
 static const char rcsid[] =
-     "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.34 2002-07-07 20:55:16 guy Exp $";
+     "@(#) $Header: /tcpdump/master/tcpdump/print-bgp.c,v 1.39 2002-07-22 14:09:07 hannes Exp $";
 #endif
 
 #include <sys/param.h>
 #endif
 
 #include <sys/param.h>
@@ -63,12 +63,14 @@ struct bgp {
 #define BGP_UPDATE             2
 #define BGP_NOTIFICATION       3
 #define BGP_KEEPALIVE          4
 #define BGP_UPDATE             2
 #define BGP_NOTIFICATION       3
 #define BGP_KEEPALIVE          4
+#define BGP_ROUTE_REFRESH       5
 
 static struct tok bgp_msg_values[] = {
     { BGP_OPEN,                 "Open"},
     { BGP_UPDATE,               "Update"},
     { BGP_NOTIFICATION,         "Notification"},
     { BGP_KEEPALIVE,            "Keepalive"},
 
 static struct tok bgp_msg_values[] = {
     { BGP_OPEN,                 "Open"},
     { BGP_UPDATE,               "Update"},
     { BGP_NOTIFICATION,         "Notification"},
     { BGP_KEEPALIVE,            "Keepalive"},
+    { BGP_ROUTE_REFRESH,        "Route Refresh"},
     { 0, NULL}
 };
 
     { 0, NULL}
 };
 
@@ -154,9 +156,24 @@ static struct tok bgp_attr_values[] = {
     { 0, NULL}
 };
 
     { 0, NULL}
 };
 
+#define BGP_OPT_AUTH                    1
+#define BGP_OPT_CAP                     2
+
+
 static struct tok bgp_opt_values[] = {
 static struct tok bgp_opt_values[] = {
-    { 1,                        "Authentication Information"},
-    { 2,                        "Capabilities Advertisement"},
+    { BGP_OPT_AUTH,             "Authentication Information"},
+    { BGP_OPT_CAP,              "Capabilities Advertisement"},
+    { 0, NULL}
+};
+
+#define BGP_CAPCODE_MP                  1
+#define BGP_CAPCODE_RR                  2
+#define BGP_CAPCODE_RR_CISCO          128
+
+static struct tok bgp_capcode_values[] = {
+    { BGP_CAPCODE_MP,           "Multiprotocol Extensions"},
+    { BGP_CAPCODE_RR,           "Route Refresh"},
+    { BGP_CAPCODE_RR_CISCO,     "Route Refresh (Cisco)"},
     { 0, NULL}
 };
 
     { 0, NULL}
 };
 
@@ -210,9 +227,9 @@ static struct tok bgp_notify_minor_update_values[] = {
 };
 
 static struct tok bgp_origin_values[] = {
 };
 
 static struct tok bgp_origin_values[] = {
-    { 1,                        "IGP"},
-    { 2,                        "EGP"},
-    { 3,                        "Incomplete"},
+    { 0,                        "IGP"},
+    { 1,                        "EGP"},
+    { 2,                        "Incomplete"},
     { 0, NULL}
 };
 
     { 0, NULL}
 };
 
@@ -285,6 +302,13 @@ static struct tok bgp_afi_values[] = {
     { 0, NULL},
 };
 
     { 0, NULL},
 };
 
+static struct tok bgp_extd_comm_subtype_values[] = {
+    { 2,                      "target"},
+    { 3,                      "origin"},
+    { 4,                      "link-BW"},
+    { 0, NULL},
+};
+
 static int
 decode_prefix4(const u_char *pd, char *buf, u_int buflen)
 {
 static int
 decode_prefix4(const u_char *pd, char *buf, u_int buflen)
 {
@@ -365,81 +389,85 @@ decode_prefix6(const u_char *pd, char *buf, u_int buflen)
 #endif
 
 static void
 #endif
 
 static void
-bgp_attr_print(const struct bgp_attr *attr, const u_char *dat, int len)
+bgp_attr_print(const struct bgp_attr *attr, const u_char *pptr, int len)
 {
        int i;
        u_int16_t af;
        u_int8_t safi, snpa;
        int advance;
        int tlen;
 {
        int i;
        u_int16_t af;
        u_int8_t safi, snpa;
        int advance;
        int tlen;
-       const u_char *p;
+       const u_char *tptr;
        char buf[MAXHOSTNAMELEN + 100];
 
        char buf[MAXHOSTNAMELEN + 100];
 
-       p = dat;
+        tptr = pptr;
+        tlen=len;
 
        switch (attr->bgpa_type) {
        case BGPTYPE_ORIGIN:
                if (len != 1)
 
        switch (attr->bgpa_type) {
        case BGPTYPE_ORIGIN:
                if (len != 1)
-                       printf(" invalid len");
+                       printf("invalid len");
                else
                else
-                       printf(" %s", tok2str(bgp_origin_values, "Unknown Origin Typecode", p[0]));
+                       printf("%s", tok2str(bgp_origin_values, "Unknown Origin Typecode", tptr[0]));
                break;
        case BGPTYPE_AS_PATH:
                if (len % 2) {
                break;
        case BGPTYPE_AS_PATH:
                if (len % 2) {
-                       printf(" invalid len");
+                       printf("invalid len");
                        break;
                }
                        break;
                }
-               while (p < dat + len) {
+                if (!len) {
+                       printf("empty");
+                       break;
+                }
+               while (tptr < pptr + len) {
                        /*
                         * under RFC1965, p[0] means:
                         * 1: AS_SET 2: AS_SEQUENCE
                         * 3: AS_CONFED_SET 4: AS_CONFED_SEQUENCE
                         */
                        /*
                         * under RFC1965, p[0] means:
                         * 1: AS_SET 2: AS_SEQUENCE
                         * 3: AS_CONFED_SET 4: AS_CONFED_SEQUENCE
                         */
-                       printf(" ");
-                       if (p[0] == 3 || p[0] == 4)
+                       if (tptr[0] == 3 || tptr[0] == 4)
                                printf("confed");
                                printf("confed");
-                       printf("%s", (p[0] & 1) ? "{" : "");
-                       for (i = 0; i < p[1] * 2; i += 2) {
+                       printf("%s", (tptr[0] & 1) ? "{" : "");
+                       for (i = 0; i < tptr[1] * 2; i += 2) {
                                printf("%s%u", i == 0 ? "" : " ",
                                printf("%s%u", i == 0 ? "" : " ",
-                                       EXTRACT_16BITS(&p[2 + i]));
+                                       EXTRACT_16BITS(&tptr[2 + i]));
                        }
                        }
-                       printf("%s", (p[0] & 1) ? "}" : "");
-                       p += 2 + p[1] * 2;
+                       printf("%s", (tptr[0] & 1) ? "}" : "");
+                       tptr += 2 + tptr[1] * 2;
                }
                break;
        case BGPTYPE_NEXT_HOP:
                if (len != 4)
                }
                break;
        case BGPTYPE_NEXT_HOP:
                if (len != 4)
-                       printf(" invalid len");
+                       printf("invalid len");
                else
                else
-                       printf(" %s", getname(p));
+                       printf("%s", getname(tptr));
                break;
        case BGPTYPE_MULTI_EXIT_DISC:
        case BGPTYPE_LOCAL_PREF:
                if (len != 4)
                break;
        case BGPTYPE_MULTI_EXIT_DISC:
        case BGPTYPE_LOCAL_PREF:
                if (len != 4)
-                       printf(" invalid len");
+                       printf("invalid len");
                else
                else
-                       printf(" %u", EXTRACT_32BITS(p));
+                       printf("%u", EXTRACT_32BITS(tptr));
                break;
        case BGPTYPE_ATOMIC_AGGREGATE:
                if (len != 0)
                break;
        case BGPTYPE_ATOMIC_AGGREGATE:
                if (len != 0)
-                       printf(" invalid len");
+                       printf("invalid len");
                break;
        case BGPTYPE_AGGREGATOR:
                if (len != 6) {
                break;
        case BGPTYPE_AGGREGATOR:
                if (len != 6) {
-                       printf(" invalid len");
+                       printf("invalid len");
                        break;
                }
                        break;
                }
-               printf(" AS #%u, origin %s", EXTRACT_16BITS(p),
-                       getname(p + 2));
+               printf(" AS #%u, origin %s", EXTRACT_16BITS(tptr),
+                       getname(tptr + 2));
                break;
        case BGPTYPE_COMMUNITIES:
                if (len % 4) {
                break;
        case BGPTYPE_COMMUNITIES:
                if (len % 4) {
-                       printf(" invalid len");
+                       printf("invalid len");
                        break;
                }
                        break;
                }
-               for (i = 0; i < len; i += 4) {
+               while (tlen>0) {
                        u_int32_t comm;
                        u_int32_t comm;
-                       comm = EXTRACT_32BITS(&p[i]);
+                       comm = EXTRACT_32BITS(tptr);
                        switch (comm) {
                        case BGP_COMMUNITY_NO_EXPORT:
                                printf(" NO_EXPORT");
                        switch (comm) {
                        case BGP_COMMUNITY_NO_EXPORT:
                                printf(" NO_EXPORT");
@@ -451,24 +479,42 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *dat, int len)
                                printf(" NO_EXPORT_SUBCONFED");
                                break;
                        default:
                                printf(" NO_EXPORT_SUBCONFED");
                                break;
                        default:
-                               printf(" (AS #%d value 0x%04x)",
-                                       (comm >> 16) & 0xffff, comm & 0xffff);
+                               printf("%u:%u%s",
+                                       (comm >> 16) & 0xffff,
+                                       comm & 0xffff,
+                                       (tlen>4) ? ", " : "");
                                break;
                        }
                                break;
                        }
+                        tlen -=4;
+                        tptr +=4;
                }
                break;
                }
                break;
-       case BGPTYPE_MP_REACH_NLRI:
-               af = EXTRACT_16BITS(p);
-               safi = p[2];
-               if (safi >= 128)
-                       printf(" %s vendor specific,",
-                               tok2str(bgp_afi_values, "Unknown AFI", af));
-               else {
-                       printf(" AFI %s SAFI %s,",
-                               tok2str(bgp_afi_values, "Unknown AFI", af),
-                               tok2str(bgp_safi_values, "Unknown SAFI", safi));
+        case BGPTYPE_ORIGINATOR_ID:
+               if (len != 4) {
+                       printf("invalid len");
+                       break;
                }
                }
-               p += 3;
+                printf("%s",getname(tptr));
+                break;
+        case BGPTYPE_CLUSTER_LIST:
+                while (tlen>0) {
+                        printf("%s%s",
+                               getname(tptr),
+                                (tlen>4) ? ", " : "");
+                        tlen -=4;
+                        tptr +=4;
+                }
+                break;
+       case BGPTYPE_MP_REACH_NLRI:
+               af = EXTRACT_16BITS(tptr);
+               safi = tptr[2];
+       
+                printf("\n\t    AFI: %s (%u), %sSAFI: %s (%u)",
+                       tok2str(bgp_afi_values, "Unknown AFI", af),
+                       af,
+                       (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
+                       tok2str(bgp_safi_values, "Unknown SAFI", safi),
+                       safi);
 
                if (af == AFNUM_INET)
                        ;
 
                if (af == AFNUM_INET)
                        ;
@@ -476,124 +522,268 @@ bgp_attr_print(const struct bgp_attr *attr, const u_char *dat, int len)
                else if (af == AFNUM_INET6)
                        ;
 #endif
                else if (af == AFNUM_INET6)
                        ;
 #endif
-               else
-                       break;
+               else {
+                    printf("\n\t    no AFI %u decoder",af);
+                    if (!vflag)
+                        print_unknown_data(tptr,"\n\t    ",tlen);
+                    break;
+                }
+
+                tptr +=3;
+
+               tlen = tptr[0];
+                tptr++;
 
 
-               tlen = p[0];
                if (tlen) {
                if (tlen) {
-                       printf(" nexthop");
-                       i = 0;
-                       while (i < tlen) {
+                       printf("\n\t    nexthop: ");
+                       while (tlen > 0) {
                                switch (af) {
                                case AFNUM_INET:
                                switch (af) {
                                case AFNUM_INET:
-                                       printf(" %s", getname(p + 1 + i));
-                                       i += sizeof(struct in_addr);
+                                    switch(safi) {
+                                    case SAFNUM_UNICAST:
+                                    case SAFNUM_MULTICAST:
+                                    case SAFNUM_UNIMULTICAST:
+                                    case SAFNUM_LABUNICAST:
+                                       printf("%s", getname(tptr));
+                                       tlen -= sizeof(struct in_addr);
+                                        tptr += sizeof(struct in_addr);
                                        break;
                                        break;
+                                    default:
+                                        printf("no SAFI %u decoder",safi);                                        
+                                        if (!vflag)
+                                            print_unknown_data(tptr,"\n\t    ",tlen);
+                                        break;
+                                    }
+                                    break;
 #ifdef INET6
                                case AFNUM_INET6:
 #ifdef INET6
                                case AFNUM_INET6:
-                                       printf(" %s", getname6(p + 1 + i));
-                                       i += sizeof(struct in6_addr);
-                                       break;
+                                    switch(safi) {
+                                    case SAFNUM_UNICAST:
+                                    case SAFNUM_MULTICAST:
+                                    case SAFNUM_UNIMULTICAST:
+                                    case SAFNUM_LABUNICAST:
+                                        printf("%s", getname6(tptr));
+                                        tlen -= sizeof(struct in6_addr);
+                                        tptr += sizeof(struct in6_addr);
+                                        break;
+                                    default:
+                                        printf("no SAFI %u decoder",safi);
+                                        if (!vflag)
+                                            print_unknown_data(tptr,"\n\t    ",tlen);                                        
+                                        break;
+                                    }
 #endif
                                default:
 #endif
                                default:
-                                       printf(" (unknown af)");
-                                       i = tlen;       /*exit loop*/
-                                       break;
+                                    printf("no AFI %u decoder",af);
+                                    if (!vflag)
+                                      print_unknown_data(tptr,"\n\t    ",tlen);
+                                    break;
                                }
                        }
                                }
                        }
-                       printf(",");
                }
                }
-               p += 1 + tlen;
+               tptr += tlen;
+
+               snpa = tptr[0];
+               tptr++;
 
 
-               snpa = p[0];
-               p++;
                if (snpa) {
                if (snpa) {
-                       printf(" %u snpa", snpa);
+                       printf("\n\t    %u SNPA", snpa);
                        for (/*nothing*/; snpa > 0; snpa--) {
                        for (/*nothing*/; snpa > 0; snpa--) {
-                               printf("(%d bytes)", p[0]);
-                               p += p[0] + 1;
+                               printf("\n\t      %d bytes", tptr[0]);
+                               tptr += tptr[0] + 1;
                        }
                        }
-                       printf(",");
                } else {
                } else {
-                printf(" no spna,");
+                printf(", no SNPA");
                 }
 
                 }
 
-               printf(" NLRI");
-               while (len - (p - dat) > 0) {
+               while (len - (tptr - pptr) > 0) {
                        switch (af) {
                        case AFNUM_INET:
                        switch (af) {
                        case AFNUM_INET:
-                            if(safi==SAFNUM_LABUNICAST) {
-                                advance = decode_labeled_prefix4(p, buf, sizeof(buf));
-                            } else {
-                               advance = decode_prefix4(p, buf, sizeof(buf));
-                            }
-                            if (advance<0)
+                            switch (safi) {
+                            case SAFNUM_UNICAST:
+                            case SAFNUM_MULTICAST:
+                            case SAFNUM_UNIMULTICAST:
+                                advance = decode_prefix4(tptr, buf, sizeof(buf));
+                                printf("\n\t      %s", buf);
+                                break;
+                            case SAFNUM_LABUNICAST:
+                                advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
+                                printf("\n\t      %s", buf);
                                 break;
                                 break;
-                            printf(" %s", buf);
+                            default:
+                                printf("\n\t      no SAFI %u decoder",safi);
+                                if (!vflag)
+                                    print_unknown_data(tptr-3,"\n\t    ",tlen);
+                                advance = 0;
+                               tptr = pptr + len;
+                               break;  
+                            }
                             break;
 #ifdef INET6
                        case AFNUM_INET6:
                             break;
 #ifdef INET6
                        case AFNUM_INET6:
-                            advance = decode_prefix6(p, buf, sizeof(buf));
-                            printf(" %s", buf);
+                            switch (safi) {
+                            case SAFNUM_UNICAST:
+                            case SAFNUM_MULTICAST:
+                            case SAFNUM_UNIMULTICAST:
+                               advance = decode_prefix6(tptr, buf, sizeof(buf));
+                               printf("\n\t      %s", buf);
+                               break;
+                            default:
+                                printf("\n\t      no SAFI %u decoder ",safi);
+                                if (!vflag)
+                                    print_unknown_data(tptr-3,"\n\t    ",tlen);
+                                advance = 0;
+                               tptr = ptr + len;
+                               break;
+                            }
                             break;
 #endif
                        default:
                             break;
 #endif
                        default:
-                            printf(" (unknown af)");
+                            printf("\n\t      no AFI %u decoder ",af);
+                            if (!vflag)
+                                    print_unknown_data(tptr-3,"\n\t    ",tlen);
                             advance = 0;
                             advance = 0;
-                            p = dat + len;
+                            tptr = pptr + len;
                             break;
                        }
 
                             break;
                        }
 
-                       p += advance;
+                       tptr += advance;
                }
 
                break;
 
        case BGPTYPE_MP_UNREACH_NLRI:
                }
 
                break;
 
        case BGPTYPE_MP_UNREACH_NLRI:
-               af = EXTRACT_16BITS(p);
-               safi = p[2];
-               if (safi >= 128)
-                       printf(" %s vendor specific,",
-                               tok2str(bgp_afi_values, "Unknown AFI", af));
-               else {
-                       printf(" AFI %s SAFI %s,",
-                               tok2str(bgp_afi_values, "Unknown AFI", af),
-                               tok2str(bgp_safi_values, "Unknown SAFI", safi));
-               }
-               p += 3;
-
-               printf(" Withdraw");
-               while (len - (p - dat) > 0) {
+               af = EXTRACT_16BITS(tptr);
+               safi = tptr[2];
+
+                printf("\n\t    AFI: %s (%u), %sSAFI: %s (%u)",
+                       tok2str(bgp_afi_values, "Unknown AFI", af),
+                       af,
+                       (safi>128) ? "vendor specific " : "", /* 128 is meanwhile wellknown */
+                       tok2str(bgp_safi_values, "Unknown SAFI", safi),
+                       safi);
+
+               tptr += 3;
+                
+               while (len - (tptr - pptr) > 0) {
                        switch (af) {
                        case AFNUM_INET:
                        switch (af) {
                        case AFNUM_INET:
-                            if(safi==SAFNUM_LABUNICAST) {
-                                advance = decode_labeled_prefix4(p, buf, sizeof(buf));
-                            } else {
-                               advance = decode_prefix4(p, buf, sizeof(buf));
-                            }
-                            if (advance<0)
+                            switch (safi) {
+                            case SAFNUM_UNICAST:
+                            case SAFNUM_MULTICAST:
+                            case SAFNUM_UNIMULTICAST:
+                                advance = decode_prefix4(tptr, buf, sizeof(buf));
+                                printf("\n\t      %s", buf);
+                                break;
+                            case SAFNUM_LABUNICAST:
+                                advance = decode_labeled_prefix4(tptr, buf, sizeof(buf));
+                                printf("\n\t      %s", buf);
                                 break;
                                 break;
-                            printf(" %s", buf);
+                            default:
+                                printf("\n\t      no SAFI %u decoder",safi);
+                                if (!vflag)
+                                    print_unknown_data(tptr-3,"\n\t    ",tlen);
+                                advance = 0;
+                               tptr = pptr + len;
+                               break;  
+                            }
                             break;
                             break;
+
 #ifdef INET6
                        case AFNUM_INET6:
 #ifdef INET6
                        case AFNUM_INET6:
-                               advance = decode_prefix6(p, buf, sizeof(buf));
-                               printf(" %s", buf);
+                            switch (safi) {
+                            case SAFNUM_UNICAST:
+                            case SAFNUM_MULTICAST:
+                            case SAFNUM_UNIMULTICAST:
+                               advance = decode_prefix6(tptr, buf, sizeof(buf));
+                               printf("\n\t      %s", buf);
+                               break;
+                            default:
+                                printf("\n\t      no SAFI %u decoder",safi);
+                                if (!vflag)
+                                    print_unknown_data(tptr-3,"\n\t    ",tlen);
+                                advance = 0;
+                               tptr = pptr + len;
                                break;
                                break;
+                            }
+                            break;
 #endif
                        default:
 #endif
                        default:
-                               printf(" (unknown af)");
+                               printf("\n\t    no AFI %u decoder",af);
+                                if (!vflag)
+                                    print_unknown_data(tptr-3,"\n\t    ",tlen);
                                advance = 0;
                                advance = 0;
-                               p = dat + len;
+                               tptr = pptr + len;
                                break;
                        }
 
                                break;
                        }
 
-                       p += advance;
+                       tptr += advance;
                }
                break;
                }
                break;
+        case BGPTYPE_EXTD_COMMUNITIES:
+               if (len % 8) {
+                       printf("invalid len");
+                       break;
+               }
+                while (tlen>0) {
+                    u_int8_t extd_comm,extd_comm_type,extd_comm_subtype;
+                    extd_comm=*tptr;
+                    extd_comm_type=extd_comm&0x3f;
+                    extd_comm_subtype=*(tptr+1);
+                    switch(extd_comm_type) {
+                        case 0:
+                            printf("%s%s%s:%u:%s%s",
+                                   (extd_comm&0x80) ? "vendor-specific: " : "",
+                                   (extd_comm&0x40) ? "non-transitive:" : "",
+                                   tok2str(bgp_extd_comm_subtype_values,
+                                           "unknown",
+                                           extd_comm_subtype&0x3f),
+                                   EXTRACT_16BITS(tptr+2),
+                                   getname(tptr+4),
+                                   (tlen>8) ? ", " : "");
+                            break;
+                        case 1:
+                            printf("%s%s%s:%s:%u%s",
+                                   (extd_comm&0x80) ? "vendor-specific: " : "",
+                                   (extd_comm&0x40) ? "non-transitive:" : "",
+                                   tok2str(bgp_extd_comm_subtype_values,
+                                           "unknown",
+                                           extd_comm_subtype&0x3f),
+                                   getname(tptr+2),
+                                   EXTRACT_16BITS(tptr+6),
+                                   (tlen>8) ? ", " : "");
+                            break;
+                        case 2:
+                            printf("%s%s%s:%u:%u%s",
+                                   (extd_comm&0x80) ? "vendor-specific: " : "",
+                                   (extd_comm&0x40) ? "non-transitive:" : "",
+                                   tok2str(bgp_extd_comm_subtype_values,
+                                           "unknown",
+                                           extd_comm_subtype&0x3f),
+                                   EXTRACT_32BITS(tptr+2),
+                                   EXTRACT_16BITS(tptr+6),
+                                   (tlen>8) ? ", " : "");
+                            break;
+
+                        default:
+                            printf("\n\t      no typecode %u decoder",
+                               extd_comm_type);
+                            print_unknown_data(tptr,"\n\t      ",8);
+                            break;
+                    }
+                    tlen -=8;
+                    tptr +=8;
+                }
+                break;
+
        default:
        default:
-               break;
+            printf("\n\t    no Attribute %u decoder",attr->bgpa_type); /* we have no decoder for the attribute */
+            if (!vflag)
+                print_unknown_data(pptr,"\n\t    ",len);
+            break;
        }
        }
+        if (vflag&&len) /* omit zero length attributes*/
+            print_unknown_data(pptr,"\n\t    ",len);
 }
 
 static void
 }
 
 static void
@@ -603,17 +793,17 @@ bgp_open_print(const u_char *dat, int length)
        struct bgp_opt bgpopt;
        int hlen;
        const u_char *opt;
        struct bgp_opt bgpopt;
        int hlen;
        const u_char *opt;
-       int i;
+       int i,cap_type,cap_len;
 
        TCHECK2(dat[0], BGP_OPEN_SIZE);
        memcpy(&bgpo, dat, BGP_OPEN_SIZE);
        hlen = ntohs(bgpo.bgpo_len);
 
 
        TCHECK2(dat[0], BGP_OPEN_SIZE);
        memcpy(&bgpo, dat, BGP_OPEN_SIZE);
        hlen = ntohs(bgpo.bgpo_len);
 
-       printf(": Version %d,", bgpo.bgpo_version);
-       printf(" AS #%u,", ntohs(bgpo.bgpo_myas));
-       printf(" Holdtime %u,", ntohs(bgpo.bgpo_holdtime));
-       printf(" ID %s,", getname((u_char *)&bgpo.bgpo_id));
-       printf(" Option length %u", bgpo.bgpo_optlen);
+       printf("\n\t  Version %d, ", bgpo.bgpo_version);
+       printf("my AS %u, ", ntohs(bgpo.bgpo_myas));
+       printf("Holdtime %us, ", ntohs(bgpo.bgpo_holdtime));
+       printf("ID %s", getname((u_char *)&bgpo.bgpo_id));
+       printf("\n\t  Optional parameters, length %u", bgpo.bgpo_optlen);
 
        /* ugly! */
        opt = &((const struct bgp_open *)dat)->bgpo_optlen;
 
        /* ugly! */
        opt = &((const struct bgp_open *)dat)->bgpo_optlen;
@@ -624,13 +814,47 @@ bgp_open_print(const u_char *dat, int length)
                TCHECK2(opt[i], BGP_OPT_SIZE);
                memcpy(&bgpopt, &opt[i], BGP_OPT_SIZE);
                if (i + 2 + bgpopt.bgpopt_len > bgpo.bgpo_optlen) {
                TCHECK2(opt[i], BGP_OPT_SIZE);
                memcpy(&bgpopt, &opt[i], BGP_OPT_SIZE);
                if (i + 2 + bgpopt.bgpopt_len > bgpo.bgpo_optlen) {
-                       printf(" [|opt %d %d]", bgpopt.bgpopt_len, bgpopt.bgpopt_type);
+                        printf("\n\t     Option %d, length %d", bgpopt.bgpopt_type, bgpopt.bgpopt_len);
                        break;
                }
 
                        break;
                }
 
-               printf(" (option %s, len=%d)",
+               printf("\n\t    Option %s (%u), length %d",
                        tok2str(bgp_opt_values,"Unknown", bgpopt.bgpopt_type),
                        tok2str(bgp_opt_values,"Unknown", bgpopt.bgpopt_type),
+                       bgpopt.bgpopt_type,
                        bgpopt.bgpopt_len);
                        bgpopt.bgpopt_len);
+
+                /* now lets decode the options we know*/
+                switch(bgpopt.bgpopt_type) {
+                case BGP_OPT_CAP:
+                    cap_type=opt[i+BGP_OPT_SIZE];
+                    cap_len=opt[i+BGP_OPT_SIZE+1];
+                    printf("\n\t      %s, length %u",
+                           tok2str(bgp_capcode_values,"Unknown", cap_type),
+                           cap_len);
+                    switch(cap_type) {
+                    case BGP_CAPCODE_MP:
+                        printf("\n\t\tAFI %s (%u), SAFI %s (%u)",
+                               tok2str(bgp_afi_values,"Unknown", EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2)),
+                               EXTRACT_16BITS(opt+i+BGP_OPT_SIZE+2),
+                               tok2str(bgp_safi_values,"Unknown", opt[i+BGP_OPT_SIZE+5]),
+                               opt[i+BGP_OPT_SIZE+5]);
+                        break;
+                    case BGP_CAPCODE_RR:
+                    case BGP_CAPCODE_RR_CISCO:
+                        break;
+                    default:
+                        printf("\n\t\tno decoder for Capability %u",
+                               cap_type);
+                        break;
+                    }
+                    break;
+                case BGP_OPT_AUTH:
+                default:
+                       printf("\n\t      no decoder for option %u",
+                           bgpopt.bgpopt_type);
+                       break;
+                }
+
                i += BGP_OPT_SIZE + bgpopt.bgpopt_len;
        }
        return;
                i += BGP_OPT_SIZE + bgpopt.bgpopt_len;
        }
        return;
@@ -647,13 +871,11 @@ bgp_update_print(const u_char *dat, int length)
        const u_char *p;
        int len;
        int i;
        const u_char *p;
        int len;
        int i;
-       int newline;
 
        TCHECK2(dat[0], BGP_SIZE);
        memcpy(&bgp, dat, BGP_SIZE);
        hlen = ntohs(bgp.bgp_len);
        p = dat + BGP_SIZE;     /*XXX*/
 
        TCHECK2(dat[0], BGP_SIZE);
        memcpy(&bgp, dat, BGP_SIZE);
        hlen = ntohs(bgp.bgp_len);
        p = dat + BGP_SIZE;     /*XXX*/
-       printf(":");
 
        /* Unfeasible routes */
        len = EXTRACT_16BITS(p);
 
        /* Unfeasible routes */
        len = EXTRACT_16BITS(p);
@@ -664,20 +886,19 @@ bgp_update_print(const u_char *dat, int length)
                 * so only try to decode it if we're not v6 enabled.
                 */
 #ifdef INET6
                 * so only try to decode it if we're not v6 enabled.
                 */
 #ifdef INET6
-               printf(" (Withdrawn routes: %d bytes)", len);
+               printf("\n\t  Withdrawn routes: %d bytes", len);
 #else
                char buf[MAXHOSTNAMELEN + 100];
 
                TCHECK2(p[2], len);
                i = 2;
 
 #else
                char buf[MAXHOSTNAMELEN + 100];
 
                TCHECK2(p[2], len);
                i = 2;
 
-               printf(" (Withdrawn routes:");
+               printf("\n\t  Withdrawn routes:");
 
                while(i < 2 + len) {
                        i += decode_prefix4(&p[i], buf, sizeof(buf));
 
                while(i < 2 + len) {
                        i += decode_prefix4(&p[i], buf, sizeof(buf));
-                       printf(" %s", buf);
+                       printf("\n\t    %s", buf);
                }
                }
-               printf(")\n");
 #endif
        }
        p += 2 + len;
 #endif
        }
        p += 2 + len;
@@ -687,8 +908,6 @@ bgp_update_print(const u_char *dat, int length)
        if (len) {
                /* do something more useful!*/
                i = 2;
        if (len) {
                /* do something more useful!*/
                i = 2;
-               printf(" (Path attributes:");   /* ) */
-               newline = 0;
                while (i < 2 + len) {
                        int alen, aoff;
 
                while (i < 2 + len) {
                        int alen, aoff;
 
@@ -697,52 +916,37 @@ bgp_update_print(const u_char *dat, int length)
                        alen = bgp_attr_len(&bgpa);
                        aoff = bgp_attr_off(&bgpa);
 
                        alen = bgp_attr_len(&bgpa);
                        aoff = bgp_attr_off(&bgpa);
 
-                       if (vflag && newline)
-                               printf("\n\t\t");
-                       else
-                               printf(" ");
+                      printf("\n\t  %s (%u), length: %u",
+                              tok2str(bgp_attr_values, "Unknown Attribute", bgpa.bgpa_type),
+                              bgpa.bgpa_type,
+                              alen);
 
 
-                       printf("(%s", tok2str(bgp_attr_values, "Unknown Attribute", bgpa.bgpa_type));
                        if (bgpa.bgpa_flags) {
                        if (bgpa.bgpa_flags) {
-                               printf("[%s%s%s%s",
+                               printf(", flags [%s%s%s%s",
                                        bgpa.bgpa_flags & 0x80 ? "O" : "",
                                        bgpa.bgpa_flags & 0x40 ? "T" : "",
                                        bgpa.bgpa_flags & 0x20 ? "P" : "",
                                        bgpa.bgpa_flags & 0x10 ? "E" : "");
                                if (bgpa.bgpa_flags & 0xf)
                                        printf("+%x", bgpa.bgpa_flags & 0xf);
                                        bgpa.bgpa_flags & 0x80 ? "O" : "",
                                        bgpa.bgpa_flags & 0x40 ? "T" : "",
                                        bgpa.bgpa_flags & 0x20 ? "P" : "",
                                        bgpa.bgpa_flags & 0x10 ? "E" : "");
                                if (bgpa.bgpa_flags & 0xf)
                                        printf("+%x", bgpa.bgpa_flags & 0xf);
-                               printf("]");
+                               printf("]: ");
                        }
                        }
-
                        bgp_attr_print(&bgpa, &p[i + aoff], alen);
                        bgp_attr_print(&bgpa, &p[i + aoff], alen);
-                       newline = 1;
-
-                       /* ( */
-                       printf(")");
-
                        i += aoff + alen;
                }
                        i += aoff + alen;
                }
-
-               /* ( */
-               printf(")");
        }
        p += 2 + len;
 
        }
        p += 2 + len;
 
-       if (len && dat + length > p)
-               printf("\n\t\t");
        if (dat + length > p) {
        if (dat + length > p) {
-               printf("(NLRI:");       /* ) */
+            printf("\n\t  Updated routes:");
                while (dat + length > p) {
                        char buf[MAXHOSTNAMELEN + 100];
                        i = decode_prefix4(p, buf, sizeof(buf));
                while (dat + length > p) {
                        char buf[MAXHOSTNAMELEN + 100];
                        i = decode_prefix4(p, buf, sizeof(buf));
-                       printf(" %s", buf);
+                       printf("\n\t    %s", buf);
                        if (i < 0)
                                break;
                        p += i;
                }
                        if (i < 0)
                                break;
                        p += i;
                }
-
-               /* ( */
-               printf(")");
        }
        return;
 trunc:
        }
        return;
 trunc:
@@ -759,7 +963,7 @@ bgp_notification_print(const u_char *dat, int length)
        memcpy(&bgpn, dat, BGP_NOTIFICATION_SIZE);
        hlen = ntohs(bgpn.bgpn_len);
 
        memcpy(&bgpn, dat, BGP_NOTIFICATION_SIZE);
        hlen = ntohs(bgpn.bgpn_len);
 
-       printf(": error %s,", tok2str(bgp_notify_major_values, "Unknown", bgpn.bgpn_major));
+       printf(", Error - %s", tok2str(bgp_notify_major_values, "Unknown", bgpn.bgpn_major));
 
         switch (bgpn.bgpn_major) {
 
 
         switch (bgpn.bgpn_major) {
 
@@ -788,7 +992,10 @@ bgp_header_print(const u_char *dat, int length)
 
        TCHECK2(dat[0], BGP_SIZE);
        memcpy(&bgp, dat, BGP_SIZE);
 
        TCHECK2(dat[0], BGP_SIZE);
        memcpy(&bgp, dat, BGP_SIZE);
-       printf("(%s", tok2str(bgp_msg_values, "Unknown Message Type", bgp.bgp_type));
+       printf("\n\t%s Message (%u), length: %u ",
+               tok2str(bgp_msg_values, "Unknown", bgp.bgp_type),
+               bgp.bgp_type,
+               length);
 
        switch (bgp.bgp_type) {
        case BGP_OPEN:
 
        switch (bgp.bgp_type) {
        case BGP_OPEN:
@@ -800,10 +1007,14 @@ bgp_header_print(const u_char *dat, int length)
        case BGP_NOTIFICATION:
                bgp_notification_print(dat, length);
                break;
        case BGP_NOTIFICATION:
                bgp_notification_print(dat, length);
                break;
+        case BGP_KEEPALIVE:
+                break;
+        default:
+            /* we have no decoder for the BGP message */
+            printf("\n\t  no Message %u decoder",bgp.bgp_type);
+            print_unknown_data(dat,"\n\t  ",length);
+                break;
        }
        }
-
-       /* ( */
-       printf(")");
        return;
 trunc:
        printf("[|BGP]");
        return;
 trunc:
        printf("[|BGP]");
@@ -821,7 +1032,6 @@ bgp_print(const u_char *dat, int length)
        };
        struct bgp bgp;
        u_int16_t hlen;
        };
        struct bgp bgp;
        u_int16_t hlen;
-       int newline;
 
        ep = dat + length;
        if (snapend < dat + length)
 
        ep = dat + length;
        if (snapend < dat + length)
@@ -830,7 +1040,6 @@ bgp_print(const u_char *dat, int length)
        printf(": BGP");
 
        p = dat;
        printf(": BGP");
 
        p = dat;
-       newline = 0;
        start = p;
        while (p < snapend) {
                if (!TTEST2(p[0], 1))
        start = p;
        while (p < snapend) {
                if (!TTEST2(p[0], 1))
@@ -855,13 +1064,9 @@ bgp_print(const u_char *dat, int length)
                        printf(" [|BGP]");
 
                hlen = ntohs(bgp.bgp_len);
                        printf(" [|BGP]");
 
                hlen = ntohs(bgp.bgp_len);
-               if (vflag && newline)
-                       printf("\n\t");
-               else
-                       printf(" ");
+
                if (TTEST2(p[0], hlen)) {
                        bgp_header_print(p, hlen);
                if (TTEST2(p[0], hlen)) {
                        bgp_header_print(p, hlen);
-                       newline = 1;
                        p += hlen;
                        start = p;
                } else {
                        p += hlen;
                        start = p;
                } else {
@@ -881,3 +1086,8 @@ trunc:
 
 
 
 
 
 
+
+
+
+
+
[mirror] the TCPdump network dissector