print-lldp.c

TCPDUMP的C语言源代码,是在数据链路层的应用

            lci_len = lci_len-3;
            tptr = tptr + 9;

            /* Decode each civic address element */	
            while (lci_len > 0) {
		ca_type = *(tptr);
                ca_len = *(tptr+1);

		tptr += 2;
                lci_len -= 2; 

                printf("\n\t      CA type \'%s\' (%u), length %u: ",
                       tok2str(lldp_tia_location_lci_catype_values, "unknown", ca_type),
                       ca_type, ca_len);

		/* basic sanity check */
		if ( ca_type == 0 || ca_len == 0) {
                    return hexdump;
		}

                safeputs((const char *)tptr, ca_len);
                tptr += ca_len;
                lci_len -= ca_len;
            }
            break;

        case LLDP_TIA_LOCATION_DATA_FORMAT_ECS_ELIN:
            printf("\n\t    ECS ELIN id ");
            safeputs((const char *)tptr+5, tlv_len-5);       
            break;

        default:
            printf("\n\t    Location ID ");
            print_unknown_data(tptr+5, "\n\t      ", tlv_len-5);
        }
        break;

    case LLDP_PRIVATE_TIA_SUBTYPE_EXTENDED_POWER_MDI:
        printf("\n\t    Power type [%s]",
               (*(tptr+4)&0xC0>>6) ? "PD device" : "PSE device");
        printf(", Power source [%s]",
               tok2str(lldp_tia_power_source_values, "none", (*(tptr+4)&0x30)>>4));
        printf("\n\t    Power priority [%s] (0x%02x)",
               tok2str(lldp_tia_power_priority_values, "none", *(tptr+4)&0x0f),
               *(tptr+4)&0x0f);
        power_val = EXTRACT_16BITS(tptr+5);
        if (power_val < LLDP_TIA_POWER_VAL_MAX) {
            printf(", Power %.1f Watts", ((float)power_val)/10);
        } else {
            printf(", Power %u (Reserved)", power_val);
        }
        break;

    case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_HARDWARE_REV:
    case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_FIRMWARE_REV:
    case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SOFTWARE_REV:
    case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SERIAL_NUMBER:
    case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MANUFACTURER_NAME:
    case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MODEL_NAME:
    case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_ASSET_ID:
        printf("\n\t  %s ",
               tok2str(lldp_tia_inventory_values, "unknown", subtype));
        safeputs((const char *)tptr+4, tlv_len-4);
        break;

    default:
        hexdump = TRUE;
        break;
    }

    return hexdump;
}

static char *
lldp_network_addr_print(const u_char *tptr) {

    u_int8_t af;
    static char buf[BUFSIZE];
    const char * (*pfunc)(const u_char *);

    af = *tptr;
    switch (af) {
    case AFNUM_INET:
        pfunc = getname; 
        break;
#ifdef INET6
    case AFNUM_INET6:
        pfunc = getname6;
        break;
#endif
    case AFNUM_802:
        pfunc = etheraddr_string;
        break;
    default:
        pfunc = NULL;
        break;
    }

    if (!pfunc) {
        snprintf(buf, sizeof(buf), "AFI %s (%u), no AF printer !",
                 tok2str(af_values, "Unknown", af), af);
    } else {
        snprintf(buf, sizeof(buf), "AFI %s (%u): %s",
                 tok2str(af_values, "Unknown", af), af, (*pfunc)(tptr+1));
    }

    return buf;
}

static int
lldp_mgmt_addr_tlv_print(const u_char *pptr, u_int len) {

    u_int8_t mgmt_addr_len, intf_num_subtype, oid_len;
    const u_char *tptr;
    u_int tlen;
    
    tlen = len;
    tptr = pptr;

    mgmt_addr_len = *tptr++;
    tlen--;

    if (tlen < mgmt_addr_len) {
        return 0;
    }

    printf("\n\t  Management Address length %u, %s",
           mgmt_addr_len,
           lldp_network_addr_print(tptr));
    tptr += mgmt_addr_len;
    tlen -= mgmt_addr_len;

    if (tlen < LLDP_INTF_NUM_LEN) {
        return 0;
    }

    intf_num_subtype = *tptr;
    printf("\n\t  %s Interface Numbering (%u): %u",
           tok2str(lldp_intf_numb_subtype_values, "Unknown", intf_num_subtype),
           intf_num_subtype,
           EXTRACT_32BITS(tptr+1));

    tptr += LLDP_INTF_NUM_LEN;
    tlen -= LLDP_INTF_NUM_LEN;

    /*
     * The OID is optional.
     */
    if (tlen) {
        oid_len = *tptr;

        if (oid_len) {
            printf("\n\t  OID length %u", oid_len);
            safeputs((const char *)tptr+1, oid_len);
        }
    }

    return 1;
} 

void
lldp_print(register const u_char *pptr, register u_int len) {

    u_int8_t subtype;
    u_int16_t tlv, cap, ena_cap;
    u_int oui, tlen, hexdump, tlv_type, tlv_len;
    const u_char *tptr;
    
    tptr = pptr;
    tlen = len;

    if (vflag) {
        printf("LLDP, length %u", len);
    }

    while (tlen >= sizeof(tlv)) {

        TCHECK2(*tptr, sizeof(tlv));

        tlv = EXTRACT_16BITS(tptr);

        tlv_type = LLDP_EXTRACT_TYPE(tlv);
        tlv_len = LLDP_EXTRACT_LEN(tlv);
        hexdump = FALSE;

        tlen -= sizeof(tlv);
        tptr += sizeof(tlv);

        if (vflag) {
            printf("\n\t%s TLV (%u), length %u",
                   tok2str(lldp_tlv_values, "Unknown", tlv_type),
                   tlv_type, tlv_len);
        }

        /* infinite loop check */
        if (!tlv_type || !tlv_len) {
            break;
        }

        TCHECK2(*tptr, tlv_len);

        switch (tlv_type) {
        case LLDP_TTL_TLV:
            if (vflag) {
                printf(": TTL %us", EXTRACT_16BITS(tptr));
            }
            break;

        case LLDP_SYSTEM_NAME_TLV:

            /*
             * The system name is also print in non-verbose mode
             * similar to the CDP printer.
             */
            if (vflag) {
                printf(": ");
                safeputs((const char *)tptr, tlv_len);
            } else {
                printf("LLDP, name ");
                safeputs((const char *)tptr, tlv_len);
                printf(", length %u", len);
            }
            break;

        case LLDP_PORT_DESCR_TLV:
            if (vflag) {
                printf(": ");
                safeputs((const char *)tptr, tlv_len);
            }
            break;

        case LLDP_SYSTEM_DESCR_TLV:
            if (vflag) {
                printf("\n\t  ");
                safeputs((const char *)tptr, tlv_len);
            }
            break;


        case LLDP_CHASSIS_ID_TLV:
            if (vflag) {
                subtype = *tptr;
                printf("\n\t  Subtype %s (%u): ",
                       tok2str(lldp_chassis_subtype_values, "Unknown", subtype),
                       subtype);

                switch (subtype) {
                case LLDP_CHASSIS_MAC_ADDR_SUBTYPE:
                    printf("%s", etheraddr_string(tptr+1));
                    break;

                case LLDP_CHASSIS_INTF_NAME_SUBTYPE: /* fall through */
                case LLDP_CHASSIS_LOCAL_SUBTYPE:
                case LLDP_CHASSIS_CHASSIS_COMP_SUBTYPE:
                case LLDP_CHASSIS_INTF_ALIAS_SUBTYPE:
                case LLDP_CHASSIS_PORT_COMP_SUBTYPE:
                    safeputs((const char *)tptr+1, tlv_len-1);
                    break;

                case LLDP_CHASSIS_NETWORK_ADDR_SUBTYPE:
                    printf("%s", lldp_network_addr_print(tptr+1));
                    break;

                default:
                    hexdump = TRUE;
                    break;
                }
            }
            break;

        case LLDP_PORT_ID_TLV:
            if (vflag) {
                subtype = *tptr;
                printf("\n\t  Subtype %s (%u): ",
                       tok2str(lldp_port_subtype_values, "Unknown", subtype),
                       subtype);

                switch (subtype) {
                case LLDP_PORT_MAC_ADDR_SUBTYPE:
                    printf("%s", etheraddr_string(tptr+1));
                    break;

                case LLDP_PORT_INTF_NAME_SUBTYPE: /* fall through */
                case LLDP_PORT_LOCAL_SUBTYPE:
                case LLDP_PORT_AGENT_CIRC_ID_SUBTYPE:
                case LLDP_PORT_INTF_ALIAS_SUBTYPE:
                case LLDP_PORT_PORT_COMP_SUBTYPE:
                    safeputs((const char *)tptr+1, tlv_len-1);
                    break;

                case LLDP_PORT_NETWORK_ADDR_SUBTYPE:
                    printf("%s", lldp_network_addr_print(tptr+1));
                    break;

                default:
                    hexdump = TRUE;
                    break;
                }
            }
            break;

        case LLDP_PRIVATE_TLV:
            if (vflag) {
                oui = EXTRACT_24BITS(tptr);
                printf(": OUI %s (0x%06x)", tok2str(oui_values, "Unknown", oui), oui);
                
                switch (oui) {
                case OUI_IEEE_8021_PRIVATE:
                    hexdump = lldp_private_8021_print(tptr);
                    break;
                case OUI_IEEE_8023_PRIVATE:
                    hexdump = lldp_private_8023_print(tptr);
                    break;
                case OUI_TIA:
                    hexdump = lldp_private_tia_print(tptr, tlv_len);
                    break;
                default:
                    hexdump = TRUE;
                    break;
                }
            }
            break;

        case LLDP_SYSTEM_CAP_TLV:
            if (vflag) {
                cap = EXTRACT_16BITS(tptr);
                ena_cap = EXTRACT_16BITS(tptr+2);
                printf("\n\t  System  Capabilities [%s] (0x%04x)",
                       bittok2str(lldp_cap_values, "none", cap), cap);
                printf("\n\t  Enabled Capabilities [%s] (0x%04x)",
                       bittok2str(lldp_cap_values, "none", ena_cap), ena_cap);
            }
            break;

        case LLDP_MGMT_ADDR_TLV:
            if (vflag) {
                if (!lldp_mgmt_addr_tlv_print(tptr, tlen)) {
                    goto trunc;
                }
            }
            break;

        default:
            hexdump = TRUE;
            break;
        }

        /* do we also want to see a hex dump ? */
        if (vflag > 1 || (vflag && hexdump)) {
            print_unknown_data(tptr,"\n\t  ", tlv_len);
        }

        tlen -= tlv_len;
        tptr += tlv_len;
    }
    return;
 trunc:
    printf("\n\t[|LLDP]");
}

/*
 * Local Variables:
 * c-style: whitesmith
 * c-basic-offset: 4
 * End:
 */