]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-egp.c
DNS: Sync types with IANA
[tcpdump] / print-egp.c
index b4a5a970e07fbef8f7012228f497497d59440e31..cc9f44e3c09e182ed78e4bef74f0545b44f59a21 100644 (file)
 /* specification: RFC 827 */
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
 #endif
 
-#include <string.h>
-
-#include <netdissect-stdinc.h>
+#include "netdissect-stdinc.h"
 
 #include "netdissect.h"
 #include "addrtoname.h"
@@ -132,7 +130,7 @@ static const char *egp_reasons[] = {
 };
 
 static void
-egpnrprint(netdissect_options *ndo,
+egpnr_print(netdissect_options *ndo,
            const struct egp_packet *egp, u_int length)
 {
        const uint8_t *cp;
@@ -143,7 +141,7 @@ egpnrprint(netdissect_options *ndo,
        u_int intgw, extgw, t_gateways;
        const char *comma;
 
-       addr = EXTRACT_IPV4_TO_NETWORK_ORDER(egp->egp_sourcenet);
+       addr = GET_IPV4_TO_NETWORK_ORDER(egp->egp_sourcenet);
        if (IN_CLASSA(addr)) {
                net = addr & IN_CLASSA_NET;
                netlen = 1;
@@ -160,8 +158,8 @@ egpnrprint(netdissect_options *ndo,
        cp = (const uint8_t *)(egp + 1);
        length -= sizeof(*egp);
 
-       intgw = EXTRACT_U_1(egp->egp_intgw);
-       extgw = EXTRACT_U_1(egp->egp_extgw);
+       intgw = GET_U_1(egp->egp_intgw);
+       extgw = GET_U_1(egp->egp_extgw);
        t_gateways = intgw + extgw;
        for (gateways = 0; gateways < t_gateways; ++gateways) {
                /* Pickup host part of gateway address */
@@ -172,15 +170,15 @@ egpnrprint(netdissect_options *ndo,
                switch (netlen) {
 
                case 1:
-                       addr = EXTRACT_U_1(cp);
+                       addr = GET_U_1(cp);
                        cp++;
                        /* fall through */
                case 2:
-                       addr = (addr << 8) | EXTRACT_U_1(cp);
+                       addr = (addr << 8) | GET_U_1(cp);
                        cp++;
                        /* fall through */
                case 3:
-                       addr = (addr << 8) | EXTRACT_U_1(cp);
+                       addr = (addr << 8) | GET_U_1(cp);
                        cp++;
                        break;
                }
@@ -188,61 +186,56 @@ egpnrprint(netdissect_options *ndo,
                length -= 4 - netlen;
                if (length < 1)
                        goto trunc;
-               ND_TCHECK_1(cp);
-               distances = EXTRACT_U_1(cp);
+               distances = GET_U_1(cp);
                cp++;
                length--;
-               ND_PRINT((ndo, " %s %s ",
+               ND_PRINT(" %s %s ",
                       gateways < intgw ? "int" : "ext",
-                      ipaddr_string(ndo, &addr)));
+                      ipaddr_string(ndo, (const u_char *)&addr)); /* local buffer, not packet data; don't use GET_IPADDR_STRING() */
 
                comma = "";
-               ND_PRINT((ndo, "("));
+               ND_PRINT("(");
                while (distances != 0) {
                        if (length < 2)
                                goto trunc;
-                       ND_TCHECK_2(cp);
-                       ND_PRINT((ndo, "%sd%u:", comma, EXTRACT_U_1(cp)));
+                       ND_PRINT("%sd%u:", comma, GET_U_1(cp));
                        cp++;
                        comma = ", ";
-                       networks = EXTRACT_U_1(cp);
+                       networks = GET_U_1(cp);
                        cp++;
                        length -= 2;
                        while (networks != 0) {
                                /* Pickup network number */
                                if (length < 1)
                                        goto trunc;
-                               ND_TCHECK_1(cp);
-                               addr = ((uint32_t) EXTRACT_U_1(cp)) << 24;
+                               addr = ((uint32_t) GET_U_1(cp)) << 24;
                                cp++;
                                length--;
                                if (IN_CLASSB(addr)) {
                                        if (length < 1)
                                                goto trunc;
-                                       ND_TCHECK_1(cp);
-                                       addr |= ((uint32_t) EXTRACT_U_1(cp)) << 16;
+                                       addr |= ((uint32_t) GET_U_1(cp)) << 16;
                                        cp++;
                                        length--;
                                } else if (!IN_CLASSA(addr)) {
                                        if (length < 2)
                                                goto trunc;
-                                       ND_TCHECK_2(cp);
-                                       addr |= ((uint32_t) EXTRACT_U_1(cp)) << 16;
+                                       addr |= ((uint32_t) GET_U_1(cp)) << 16;
                                        cp++;
-                                       addr |= ((uint32_t) EXTRACT_U_1(cp)) << 8;
+                                       addr |= ((uint32_t) GET_U_1(cp)) << 8;
                                        cp++;
                                        length -= 2;
                                }
-                               ND_PRINT((ndo, " %s", ipaddr_string(ndo, &addr)));
+                               ND_PRINT(" %s", ipaddr_string(ndo, (const u_char *)&addr)); /* local buffer, not packet data; don't use GET_IPADDR_STRING() */
                                networks--;
                        }
                        distances--;
                }
-               ND_PRINT((ndo, ")"));
+               ND_PRINT(")");
        }
        return;
 trunc:
-       ND_PRINT((ndo, "[|]"));
+       nd_print_trunc(ndo);
 }
 
 void
@@ -255,61 +248,62 @@ egp_print(netdissect_options *ndo,
        u_int code;
        u_int status;
 
+       ndo->ndo_protocol = "egp";
        egp = (const struct egp_packet *)bp;
-       if (length < sizeof(*egp) || !ND_TTEST(*egp)) {
-               ND_PRINT((ndo, "[|egp]"));
+       if (length < sizeof(*egp) || !ND_TTEST_SIZE(egp)) {
+               nd_print_trunc(ndo);
                return;
        }
 
-       version = EXTRACT_U_1(egp->egp_version);
+       version = GET_U_1(egp->egp_version);
         if (!ndo->ndo_vflag) {
-            ND_PRINT((ndo, "EGPv%u, AS %u, seq %u, length %u",
+            ND_PRINT("EGPv%u, AS %u, seq %u, length %u",
                    version,
-                   EXTRACT_BE_U_2(egp->egp_as),
-                   EXTRACT_BE_U_2(egp->egp_sequence),
-                   length));
+                   GET_BE_U_2(egp->egp_as),
+                   GET_BE_U_2(egp->egp_sequence),
+                   length);
             return;
         } else
-            ND_PRINT((ndo, "EGPv%u, length %u",
+            ND_PRINT("EGPv%u, length %u",
                    version,
-                   length));
+                   length);
 
        if (version != EGP_VERSION) {
-               ND_PRINT((ndo, "[version %u]", version));
+               ND_PRINT("[version %u]", version);
                return;
        }
 
-       type = EXTRACT_U_1(egp->egp_type);
-       code = EXTRACT_U_1(egp->egp_code);
-       status = EXTRACT_U_1(egp->egp_status);
+       type = GET_U_1(egp->egp_type);
+       code = GET_U_1(egp->egp_code);
+       status = GET_U_1(egp->egp_status);
 
        switch (type) {
        case EGPT_ACQUIRE:
-               ND_PRINT((ndo, " acquire"));
+               ND_PRINT(" acquire");
                switch (code) {
                case EGPC_REQUEST:
                case EGPC_CONFIRM:
-                       ND_PRINT((ndo, " %s", egp_acquire_codes[code]));
+                       ND_PRINT(" %s", egp_acquire_codes[code]);
                        switch (status) {
                        case EGPS_UNSPEC:
                        case EGPS_ACTIVE:
                        case EGPS_PASSIVE:
-                               ND_PRINT((ndo, " %s", egp_acquire_status[status]));
+                               ND_PRINT(" %s", egp_acquire_status[status]);
                                break;
 
                        default:
-                               ND_PRINT((ndo, " [status %u]", status));
+                               ND_PRINT(" [status %u]", status);
                                break;
                        }
-                       ND_PRINT((ndo, " hello:%u poll:%u",
-                              EXTRACT_BE_U_2(egp->egp_hello),
-                              EXTRACT_BE_U_2(egp->egp_poll)));
+                       ND_PRINT(" hello:%u poll:%u",
+                              GET_BE_U_2(egp->egp_hello),
+                              GET_BE_U_2(egp->egp_poll));
                        break;
 
                case EGPC_REFUSE:
                case EGPC_CEASE:
                case EGPC_CEASEACK:
-                       ND_PRINT((ndo, " %s", egp_acquire_codes[code]));
+                       ND_PRINT(" %s", egp_acquire_codes[code]);
                        switch (status ) {
                        case EGPS_UNSPEC:
                        case EGPS_NORES:
@@ -317,17 +311,17 @@ egp_print(netdissect_options *ndo,
                        case EGPS_GODOWN:
                        case EGPS_PARAM:
                        case EGPS_PROTO:
-                               ND_PRINT((ndo, " %s", egp_acquire_status[status]));
+                               ND_PRINT(" %s", egp_acquire_status[status]);
                                break;
 
                        default:
-                               ND_PRINT((ndo, "[status %u]", status));
+                               ND_PRINT("[status %u]", status);
                                break;
                        }
                        break;
 
                default:
-                       ND_PRINT((ndo, "[code %u]", code));
+                       ND_PRINT("[code %u]", code);
                        break;
                }
                break;
@@ -337,61 +331,62 @@ egp_print(netdissect_options *ndo,
 
                case EGPC_HELLO:
                case EGPC_HEARDU:
-                       ND_PRINT((ndo, " %s", egp_reach_codes[code]));
+                       ND_PRINT(" %s", egp_reach_codes[code]);
                        if (status <= EGPS_DOWN)
-                               ND_PRINT((ndo, " state:%s", egp_status_updown[status]));
+                               ND_PRINT(" state:%s", egp_status_updown[status]);
                        else
-                               ND_PRINT((ndo, " [status %u]", status));
+                               ND_PRINT(" [status %u]", status);
                        break;
 
                default:
-                       ND_PRINT((ndo, "[reach code %u]", code));
+                       ND_PRINT("[reach code %u]", code);
                        break;
                }
                break;
 
        case EGPT_POLL:
-               ND_PRINT((ndo, " poll"));
+               ND_PRINT(" poll");
                if (status <= EGPS_DOWN)
-                       ND_PRINT((ndo, " state:%s", egp_status_updown[status]));
+                       ND_PRINT(" state:%s", egp_status_updown[status]);
                else
-                       ND_PRINT((ndo, " [status %u]", status));
-               ND_PRINT((ndo, " net:%s", ipaddr_string(ndo, &egp->egp_sourcenet)));
+                       ND_PRINT(" [status %u]", status);
+               ND_PRINT(" net:%s", GET_IPADDR_STRING(egp->egp_sourcenet));
                break;
 
        case EGPT_UPDATE:
-               ND_PRINT((ndo, " update"));
+               ND_PRINT(" update");
                if (status & EGPS_UNSOL) {
                        status &= ~EGPS_UNSOL;
-                       ND_PRINT((ndo, " unsolicited"));
+                       ND_PRINT(" unsolicited");
                }
                if (status <= EGPS_DOWN)
-                       ND_PRINT((ndo, " state:%s", egp_status_updown[status]));
+                       ND_PRINT(" state:%s", egp_status_updown[status]);
                else
-                       ND_PRINT((ndo, " [status %u]", status));
-               ND_PRINT((ndo, " %s int %u ext %u",
-                      ipaddr_string(ndo, &egp->egp_sourcenet),
-                      EXTRACT_U_1(egp->egp_intgw),
-                      EXTRACT_U_1(egp->egp_extgw)));
+                       ND_PRINT(" [status %u]", status);
+               ND_PRINT(" %s int %u ext %u",
+                      GET_IPADDR_STRING(egp->egp_sourcenet),
+                      GET_U_1(egp->egp_intgw),
+                      GET_U_1(egp->egp_extgw));
                if (ndo->ndo_vflag)
-                       egpnrprint(ndo, egp, length);
+                       egpnr_print(ndo, egp, length);
                break;
 
        case EGPT_ERROR:
-               ND_PRINT((ndo, " error"));
+               ND_PRINT(" error");
                if (status <= EGPS_DOWN)
-                       ND_PRINT((ndo, " state:%s", egp_status_updown[status]));
+                       ND_PRINT(" state:%s", egp_status_updown[status]);
                else
-                       ND_PRINT((ndo, " [status %u]", status));
+                       ND_PRINT(" [status %u]", status);
 
-               if (EXTRACT_BE_U_2(egp->egp_reason) <= EGPR_UVERSION)
-                       ND_PRINT((ndo, " %s", egp_reasons[EXTRACT_BE_U_2(egp->egp_reason)]));
+               if (GET_BE_U_2(egp->egp_reason) <= EGPR_UVERSION)
+                       ND_PRINT(" %s",
+                                egp_reasons[GET_BE_U_2(egp->egp_reason)]);
                else
-                       ND_PRINT((ndo, " [reason %u]", EXTRACT_BE_U_2(egp->egp_reason)));
+                       ND_PRINT(" [reason %u]", GET_BE_U_2(egp->egp_reason));
                break;
 
        default:
-               ND_PRINT((ndo, "[type %u]", type));
+               ND_PRINT("[type %u]", type);
                break;
        }
 }