check-mk-server 1.2.2p3-1 / usr / share / check_mk / checks / if.include

#!/usr/bin/python
# -*- encoding: utf-8; py-indent-offset: 4 -*-
# +------------------------------------------------------------------+
# |             ____ _               _        __  __ _  __           |
# |            / ___| |__   ___  ___| | __   |  \/  | |/ /           |
# |           | |   | '_ \ / _ \/ __| |/ /   | |\/| | ' /            |
# |           | |___| | | |  __/ (__|   <    | |  | | . \            |
# |            \____|_| |_|\___|\___|_|\_\___|_|  |_|_|\_\           |
# |                                                                  |
# | Copyright Mathias Kettner 2013             mk@mathias-kettner.de |
# +------------------------------------------------------------------+
#
# This file is part of Check_MK.
# The official homepage is at http://mathias-kettner.de/check_mk.
#
# check_mk is free software;  you can redistribute it and/or modify it
# under the  terms of the  GNU General Public License  as published by
# the Free Software Foundation in version 2.  check_mk is  distributed
# in the hope that it will be useful, but WITHOUT ANY WARRANTY;  with-
# out even the implied warranty of  MERCHANTABILITY  or  FITNESS FOR A
# PARTICULAR PURPOSE. See the  GNU General Public License for more de-
# ails.  You should have  received  a copy of the  GNU  General Public
# License along with GNU Make; see the file  COPYING.  If  not,  write
# to the Free Software Foundation, Inc., 51 Franklin St,  Fifth Floor,
# Boston, MA 02110-1301 USA.

# Functions and definitions used by if and if64

if_inventory_porttypes = [ '6', '32', '62', '117' ]
if_inventory_portstates = [ '1' ]
if_inventory_uses_description = False
if_inventory_uses_alias = False
if_inventory_pad_portnumbers = True
if_inventory_monitor_speed = True
if_inventory_monitor_state = True
inventory_if_rules = []

factory_settings["if_default_levels"] = {
    "errors" : (0.01, 0.1),
}


# Grouping of if ports
#if_groups = [
#   ( [{"name" : "VLAN", "iftype" : 53, "single" : True}], [ ], ALL_HOSTS ),
#   ( [{"name" : "Group WLAN", "iftype" : 6, "single" : True}], [ "lan" ], ALL_HOSTS )
#   ]
#
if_groups = []

# Obsolete variable, but needed as contained in autochecks of
# older checks. We need to keep this up for a few years...
if_default_error_levels = factory_settings["if_default_levels"]["errors"]
if_default_traffic_levels = None, None
if_default_average = None

if_disable_if64_hosts = [] # Binary host list for disabling if64 on some broken devices

def if64_disabled(hostname):
    return in_binary_hostlist(hostname, if_disable_if64_hosts)

# Remove 0 bytes from strings. They lead to problems e.g. here:
# On windows hosts the labels of network interfaces in oid
# iso.3.6.1.2.1.2.2.1.2.1 are given as hex strings with tailing
# 0 byte. When this string is part of the data which is sent to
# the nagios pipe all chars after the 0 byte are stripped of.
# Stupid fix: Remove all 0 bytes. Hope this causes no problems.
def cleanup_if_strings(s):
    if s and s != '':
        return "".join([ c for c in s if c not in nagios_illegal_chars+chr(0) ]).strip()
    else:
        return s

# make sure, that configuration variable is present in precompiled host checks
check_config_variables.append("nagios_illegal_chars")

# Name of state (lookup SNMP enum)
def if_statename(st):
    names = { '1': 'up',      '2': 'down',
              '3': 'testing', '4': 'unknown',
              '5': 'dormant', '6': 'notPresent',
              '7': 'lowerLayerDown' }
    return names.get(st, st)


# Pads port numbers with zeroes, so that items
# nicely sort alphabetically
def if_pad_with_zeroes(info, ifIndex):
    if if_inventory_pad_portnumbers:
        max_index = max([int(line[0]) for line in info])
        digits = len(str(max_index))
        return ("%0"+str(digits)+"d") % int(ifIndex)
    else:
        return ifIndex


def inventory_if_common(info):
    if len(info) == 0 or len(info[0]) != 20:
        return []

    settings = host_extra_conf_merged(g_hostname, inventory_if_rules)
    uses_description    = settings.get('use_desc', if_inventory_uses_description)
    uses_alias          = settings.get('use_alias', if_inventory_uses_alias)
    porttypes           = settings.get('porttypes', if_inventory_porttypes)
    portstates          = settings.get('portstates', if_inventory_portstates)

    pre_inventory        = []
    pre_inventory_groups = []
    group_patterns = {}

    for line in host_extra_conf(g_hostname, if_groups):
        for entry in line:
            if str(entry["iftype"]) in porttypes:
                group_patterns[entry["name"]] = entry

    seen_items  = set([])
    duplicate   = set([])
    have_groups = {}


    # Determine whether single, grouped or both
    for ifIndex, ifDescr, ifType, ifSpeed, ifOperStatus, ifInOctets, \
            inucast, inmcast, inbcast, ifInDiscards, ifInErrors, ifOutOctets, \
            outucast, outmcast, outbcast, ifOutDiscards, ifOutErrors, \
            ifOutQLen, ifAlias, ifPhysAddress in info:
        ifDescr = cleanup_if_strings(ifDescr)
        ifAlias = cleanup_if_strings(ifAlias)

        # compute item now - also for unmonitored ports - in order to see if it is unique.
        if uses_description and ifDescr:
            item = ifDescr
        elif uses_alias and ifAlias:
            item = ifAlias
        else:
            item = if_pad_with_zeroes(info, ifIndex)

        # Prepare grouped interfaces
        is_only_in_group = False
        for group_name, pattern in group_patterns.items():
            if pattern["iftype"] == saveint(ifType):
                have_groups.setdefault(group_name, {"interfaces": []})["iftype"] = pattern["iftype"]
                have_groups[group_name]["interfaces"].append((saveint(ifSpeed), ifOperStatus))
                if pattern.get("single"):
                    is_only_in_group = True

        # Prepare single interfaces
        if not is_only_in_group:
            if item in seen_items: # duplicate
                duplicate.add(item)
            seen_items.add(item)

            if ifType in porttypes and ifOperStatus in portstates:
                params = {}
                if if_inventory_monitor_state:
                    params["state"] = [ifOperStatus]

                if ifSpeed != "" and if_inventory_monitor_speed:
                    params["speed"] = int(ifSpeed)
                pre_inventory.append( (item, "%r" % params, int(ifIndex)) )

    # create pseudo interfaces out of groups
    for group_name, values in have_groups.items():
        # total maximum speed of all interfaces in this group
        total_speed = sum([pair[0] for pair in values["interfaces"]])
        # operation status, default is down(2)
        # if at least one is up(1) then up is considered as valid
        one_up = "1" in [pair[1] for pair in values["interfaces"]]
        group_operStatus = one_up and "1" or "2"

        ifType = group_patterns[group_name]["iftype"]
        if str(ifType) in porttypes and group_operStatus in portstates:
            params = { "iftype": ifType, "aggregate": True }
            if if_inventory_monitor_state:
                params["state"] = [ group_operStatus ]

            if ifSpeed != "" and if_inventory_monitor_speed:
                params["speed"] = total_speed
            pre_inventory.append( (group_name, "%r" % params, int(ifIndex)) )

    inventory = []
    # Check for duplicate items (e.g. when using Alias as item and the alias is not unique)
    for item, params, index in pre_inventory:
        if item in duplicate:
            new_item = "%s %d" % (item, index)
        else:
            new_item = item
        inventory.append((new_item, params))

    return inventory

def check_if_common(item, params, info):
    # If this item is in an ifgroup create a pseudo interface and pass its data to the common instance
    # This is done by simply adding the additional group_info data to the already existing info table
    if params.get("aggregate"):
        matching_interfaces = []
        for element in info:
            if params["iftype"] == saveint(element[2]):
                matching_interfaces.append(element)

        # Accumulate info over matching_interfaces
        wrapped = False
        this_time = time.time()

        group_info = {
            "ifSpeed" : 0, "ifInOctets" : 0, "inucast" : 0, "inmcast" : 0 , "inbcast" : 0,
            "ifInDiscards" : 0, "ifInErrors" : 0, "ifOutOctets" : 0, "outucast" : 0, "outmcast" : 0,
            "outbcast" : 0, "ifOutDiscards" : 0, "ifOutErrors" : 0, "ifOutQLen" : 0
        }

        for ifIndex, ifDescr, ifType, ifSpeed, ifOperStatus, ifInOctets, \
                inucast, inmcast, inbcast, ifInDiscards, ifInErrors, ifOutOctets, \
                outucast, outmcast, outbcast, ifOutDiscards, ifOutErrors, \
                ifOutQLen, ifAlias, ifPhysAddress in matching_interfaces:
            if if_inventory_uses_description and ifDescr:
                group_item = ifDescr
            elif if_inventory_uses_alias and ifAlias:
                group_item = ifAlias
            else:
                group_item = if_pad_with_zeroes(info, ifIndex)

            perfdata = []

            # Only these values are packed into counters
            # We might need to enlarge this table
            # However, more values leads to more MKCounterWrapped...
            for name, counter in [
                ( "in",        ifInOctets),
                ( "inucast",   inucast),
                ( "inmcast",   inmcast),
                ( "inbcast",   inbcast),
                ( "indisc",    ifInDiscards),
                ( "inerr",     ifInErrors),

                ( "out",       ifOutOctets),
                ( "outucast",  outucast),
                ( "outmcast",  outmcast),
                ( "outbcast",  outbcast),
                ( "outdisc",   ifOutDiscards),
                ( "outerr",    ifOutErrors) ]:
                try:
                    get_counter("if.%s.%s.%s" % (name, item, group_item), this_time, saveint(counter))
                except MKCounterWrapped:
                    wrapped = True
                    # continue, other counters might wrap as well

            # Add interface info to group info
            group_info["ifSpeed"]       += saveint(ifSpeed)
            group_info["ifInOctets"]    += saveint(ifInOctets)
            group_info["inucast"]       += saveint(inucast)
            group_info["inmcast"]       += saveint(inmcast)
            group_info["inbcast"]       += saveint(inbcast)
            group_info["ifInDiscards"]  += saveint(ifInDiscards)
            group_info["ifInErrors"]    += saveint(ifInErrors)
            group_info["ifOutOctets"]   += saveint(ifOutOctets)
            group_info["outucast"]      += saveint(outucast)
            group_info["outmcast"]      += saveint(outmcast)
            group_info["outbcast"]      += saveint(outbcast)
            group_info["ifOutDiscards"] += saveint(ifOutDiscards)
            group_info["ifOutErrors"]   += saveint(ifOutErrors)
            group_info["ifOutQLen"]     += saveint(ifOutQLen)



        # Append an additional entry to the info table containing the calculated group_info
        one_up = "1" in [element[4] for element in matching_interfaces]
        group_operStatus = one_up and "1" or "2"

        group_entry = [
                    "ifgroup%s" % item,         # ifIndex
                    item,                       # ifDescr
                    params["iftype"],           # ifType
                    group_info["ifSpeed"],      # ifSpeed
                    group_operStatus,           # ifOperStatus
                    group_info["ifInOctets"],   # ifInOctets
                    group_info["inucast"],      # inucast
                    group_info["inmcast"],      # inmcast
                    group_info["inbcast"],      # inbcast
                    group_info["ifInDiscards"], # ifInDiscards
                    group_info["ifInErrors"],   # ifInErrors

                    group_info["ifOutOctets"],  # ifOutOctets
                    group_info["outucast"],     # outucast
                    group_info["outmcast"],     # outmcast
                    group_info["outbcast"],     # outbcast
                    group_info["ifOutDiscards"],# ifOutDiscards
                    group_info["ifOutErrors"],  # ifOutErrors
                    group_info["ifOutQLen"],    # ifOutQLen
                    "iftype %s" % params["iftype"],        # ifAlias
                    "",                         # ifPhysAddress
        ]
        info.append(group_entry)
        # If applicable, signal the check_if_common_single if the counter of the
        # given interface has wrapped. Actually a wrap of the if group itself is unlikely,
        # however any counter wrap of one of its members causes the accumulation being invalid
        return check_if_common_single(item, params, info, wrapped)

    return check_if_common_single(item, params,info)

def check_if_common_single(item, params, info, force_counter_wrap = False):
    # Params now must be a dict. Some keys might
    # be set to None
    targetspeed        = params.get("speed")
    targetstate        = params.get("state")
    average            = params.get("average")
    unit               = params.get("unit") in ["Bit", "bit"] and "Bit" or "B"
    unit_multiplier    = unit == "Bit" and 8.0 or 1.0

    # error checking might be turned off
    if params["errors"]:
        err_warn, err_crit = params["errors"]
    else:
        err_warn, err_crit = None, None

    # Traffic checking might be turned off
    if "traffic" in params:
        bw_warn, bw_crit = params["traffic"]
    else:
        bw_warn, bw_crit = None, None


    for ifIndex, ifDescr, ifType, ifSpeed, ifOperStatus, ifInOctets,  \
            inucast, inmcast, inbcast, ifInDiscards, ifInErrors, ifOutOctets, \
            outucast, outmcast, outbcast, ifOutDiscards, ifOutErrors, \
            ifOutQLen, ifAlias, ifPhysAddress in info:
        ifDescr = cleanup_if_strings(ifDescr)
        ifAlias = cleanup_if_strings(ifAlias)

        if item.lstrip("0") == ifIndex \
            or (item == "0" * len(item) and saveint(ifIndex) == 0) \
            or item == ifAlias \
            or item == ifDescr \
            or item == "%s %s" % (ifAlias, ifIndex) \
            or item == "%s %s" % (ifDescr, ifIndex):

            # Display port number or alias in infotext if that is not part
            # of the service description anyway
            if item.lstrip("0") == ifIndex \
                and (item == ifAlias or ifAlias == '') \
                and (item == ifDescr or ifDescr == ''): # description trivial
                infotext = ""
            elif item == "%s %s" % (ifAlias, ifIndex) and ifDescr != '': # non-unique Alias
                infotext = "[%s/%s]" % (ifAlias, ifDescr)
            elif item != ifAlias and ifAlias != '': # alias useful
                infotext = "[%s] " % ifAlias
            elif item != ifDescr and ifDescr != '': # description useful
                infotext = "[%s] " % ifDescr
            else:
                infotext = "[%s] " % ifIndex

            state = 0

            operstatus = if_statename(str(ifOperStatus))
            if targetstate and  \
                (ifOperStatus != targetstate
                and not (type(targetstate) in [ list, tuple ] and ifOperStatus in targetstate)):
                state = 2
                infotext += "(%s)(!!) " % operstatus
            else:
                infotext += "(%s) " % operstatus


            # prepare reference speed for computing relative bandwidth usage
            speed = saveint(ifSpeed)

            if speed:
                ref_speed = speed / 8.0
            elif targetspeed:
                ref_speed = targetspeed / 8.0
            else:
                ref_speed = None

	    if ifPhysAddress:
                mac = ":".join(["%02s" % hex(ord(m))[2:] for m in ifPhysAddress]).replace(' ', '0')
                infotext += 'MAC: %s, ' % mac

            # Check speed settings of interface, but only if speed information
            # is available. This is not always the case.
            if speed:
                infotext += get_nic_speed_human_readable(speed)
                if not targetspeed is None and speed != targetspeed:
                    infotext += " (wrong speed, expected: %s)(!)" % get_nic_speed_human_readable(targetspeed)
                    state = max(state, 1)
            elif targetspeed:
                infotext += "assuming %s" % get_nic_speed_human_readable(targetspeed)
            else:
                infotext += "speed unknown"

            # convert percentages to absolute values if levels are float
            # this is only possible if a reference speed is available.
            if ref_speed:
                if bw_warn != None and type(bw_warn) == float:
                    bw_warn = bw_warn / 100.0 * ref_speed * unit_multiplier
                if bw_crit != None and type(bw_crit) == float:
                    bw_crit = bw_crit / 100.0 * ref_speed * unit_multiplier

            # Ignore percentual levels if no reference speed is available
            else:
                if bw_warn != None and type(bw_warn) == float:
                    bw_warn = None

                if bw_crit != None and type(bw_crit) == float:
                    bw_crit = None

            # Even if the measurement unit is set to "bit" the WARN and CRIT levels are
            # still reported as bytes to stay compatible with older rrd data
            if unit == "Bit":
                if bw_crit and bw_crit != None:
                    bw_crit = bw_crit / 8
                if bw_warn and bw_warn != None:
                    bw_warn = bw_warn / 8

            # Performance counters
            this_time = time.time()
            rates = []
            wrapped = False
            perfdata = []
            for name, counter, warn, crit, mmin, mmax in [
                ( "in",        ifInOctets, bw_warn, bw_crit, 0, ref_speed),
                ( "inucast",   inucast, None, None, None, None),
                ( "innucast",  saveint(inmcast) + saveint(inbcast), None, None, None, None),
                ( "indisc",    ifInDiscards, None, None, None, None),
                ( "inerr",     ifInErrors, err_warn, err_crit, None, None),

                ( "out",       ifOutOctets, bw_warn, bw_crit, 0, ref_speed),
                ( "outucast",  outucast, None, None, None, None),
                ( "outnucast", saveint(outmcast) + saveint(outbcast), None, None, None, None),
                ( "outdisc",   ifOutDiscards, None, None, None, None),
                ( "outerr",    ifOutErrors, err_warn, err_crit, None, None) ]:

                try:
                    timedif, rate = get_counter("if.%s.%s" % (name, item), this_time, saveint(counter))
                    if force_counter_wrap:
                        raise MKCounterWrapped("if.%s.%s" % (name, item), "Forced counter wrap")
                    rates.append(rate)
                    perfdata.append( (name, rate, warn, crit, mmin, mmax) )
                except MKCounterWrapped:
                    wrapped = True
                    # continue, other counters might wrap as well

            # if at least one counter wrapped, we do not handle the counters at all
            if wrapped:
                # If there is a threshold on the bandwidth, we cannot proceed
                # further (the check would be flapping to green on a wrap)
                if bw_crit != None:
                    raise MKCounterWrapped("", "Counter wrap, skipping checks this time")
                perfdata = []
            else:
                perfdata.append(("outqlen", saveint(ifOutQLen),"","", unit == "Bit" and "0.0" or "0"))
                get_human_readable = lambda traffic: get_bytes_human_readable(traffic * unit_multiplier, 1024, True, unit)
                for what, errorrate, okrate, traffic in \
                   [ ("in",  rates[4], rates[1] + rates[2], rates[0]),
                     ("out", rates[9], rates[6] + rates[7], rates[5]) ]:

                    infotext += ", %s: %s/s" % (what, get_human_readable(traffic))

                    if ref_speed:
                        perc_used = 100.0 * traffic / ref_speed
                        infotext += "(%.1f%%)" % perc_used

                    # handle computation of average
                    if average:
                        timedif, traffic_avg = get_average("if.%s.%s.avg" % (what, item), this_time, traffic, average)
                        infotext += ", %dmin avg: %s/s" % (average, get_human_readable(traffic_avg))
                        perfdata.append( ("%s_avg_%d" % (what, average), traffic_avg, bw_warn, bw_crit, 0, ref_speed) )
                        traffic = traffic_avg # apply levels to average traffic

                    # Check bandwidth thresholds
                    if bw_crit != None and traffic >= bw_crit:
                        state = 2
                        infotext += ' (!!) >= ' + get_human_readable(bw_crit / unit_multiplier) + "/s"
                    elif bw_warn != None and traffic >= bw_warn:
                        state = max(state, 1)
                        infotext += ' (!) >= ' + get_human_readable(bw_warn / unit_multiplier) + "/s"

                    pacrate = okrate + errorrate
                    if pacrate > 0.0: # any packets transmitted?
                        errperc = 100.0 * errorrate / (okrate + errorrate)

                        if errperc > 0:
                            infotext += ", %s-errors: %.2f%%" % (what, errperc)

                        if   err_crit != None and errperc >= err_crit:
                            state = 2
                            infotext += "(!!) >= " + str(err_crit)
                        elif err_warn != None and errperc >= err_warn:
                            state = max(state, 1)
                            infotext += "(!) >= " + str(err_warn)

            return (state, "%s - %s" % (nagios_state_names[state], infotext), perfdata)

    return (3, "UNKNOWN - no such interface")



# possible port types are:

# other(1), regular1822(2), hdh1822(3), ddnX25(4), rfc877x25(5),
# ethernetCsmacd(6), iso88023Csmacd(7), iso88024TokenBus(8),
# iso88025TokenRing(9), iso88026Man(10), starLan(11), proteon10Mbit(12),
# proteon80Mbit(13), hyperchannel(14), fddi(15), lapb(16), sdlc(17), ds1(18),
# e1(19), basicISDN(20), primaryISDN(21), propPointToPointSerial(22),
# ppp(23), softwareLoopback(24), eon(25), ethernet3Mbit(26),
# nsip(27), slip(28), ultra(29), ds3(30), sip(31), frameRelay(32),
# rs232(33), para(34), arcnet(35), arcnetPlus(36), atm(37), miox25(38),
# sonet(39), x25ple(40), iso88022llc(41), localTalk(42), smdsDxi(43),
# frameRelayService(44), v35(45), hssi(46), hippi(47), modem(48),
# aal5(49), sonetPath(50), sonetVT(51), smdsIcip(52), propVirtual(53),
# propMultiplexor(54), ieee80212(55), fibreChannel(56), hippiInterface(57),
# frameRelayInterconnect(58), aflane8023(59), aflane8025(60), cctEmul(61),
# fastEther(62), isdn(63), v11(64), v36(65), g703at64k(66), g703at2mb(67),
# qllc(68), fastEtherFX(69), channel(70), ieee80211(71), ibm370parChan(72),
# escon(73), dlsw(74), isdns(75), isdnu(76), lapd(77), ipSwitch(78),
# rsrb(79), atmLogical(80), ds0(81), ds0Bundle(82), bsc(83), async(84),
# cnr(85), iso88025Dtr(86), eplrs(87), arap(88), propCnls(89), hostPad(90),
# termPad(91), frameRelayMPI(92), x213(93), adsl(94), radsl(95), sdsl(96),
# vdsl(97), iso88025CRFPInt(98), myrinet(99), voiceEM(100), voiceFXO(101),
# voiceFXS(102), voiceEncap(103), voiceOverIp(104), atmDxi(105), atmFuni(106),
# atmIma(107), pppMultilinkBundle(108), ipOverCdlc(109), ipOverClaw(110),
# stackToStack(111), virtualIpAddress(112), mpc(113), ipOverAtm(114),
# iso88025Fiber(115), tdlc(116), gigabitEthernet(117), hdlc(118), lapf(119),
# v37(120), x25mlp(121), x25huntGroup(122), trasnpHdlc(123), interleave(124),
# fast(125), ip(126), docsCableMaclayer(127), docsCableDownstream(128),
# docsCableUpstream(129), a12MppSwitch(130), tunnel(131), coffee(132),
# ces(133), atmSubInterface(134), l2vlan(135), l3ipvlan(136), l3ipxvlan(137),
# digitalPowerline(138), mediaMailOverIp(139), dtm(140), dcn(141),
# ipForward(142), msdsl(143), ieee1394(144), if-gsn(145), dvbRccMacLayer(146),
# dvbRccDownstream(147), dvbRccUpstream(148), atmVirtual(149), mplsTunnel(150),
# srp(151), voiceOverAtm(152), voiceOverFrameRelay(153), idsl(154),
# compositeLink(155), ss7SigLink(156), propWirelessP2P(157), frForward(158),
# rfc1483(159), usb(160), ieee8023adLag(161), bgppolicyaccounting(162),
# frf16MfrBundle(163), h323Gatekeeper(164), h323Proxy(165), mpls(166),
# mfSigLink(167), hdsl2(168), shdsl(169), ds1FDL(170), pos(171), dvbAsiIn(172),
# dvbAsiOut(173), plc(174), nfas(175), tr008(176), gr303RDT(177), gr303IDT(178),
# isup(179), propDocsWirelessMaclayer(180), propDocsWirelessDownstream(181),
# propDocsWirelessUpstream(182), hiperlan2(183), propBWAp2Mp(184),
# sonetOverheadChannel(185), digitalWrapperOverheadChannel(186),
# aal2(187), radioMAC(188), atmRadio(189), imt(190), mvl(191), reachDSL(192),
# frDlciEndPt(193), atmVciEndPt(194), opticalChannel(195), opticalTransport(196),
# propAtm(197), voiceOverCable(198), infiniband(199), teLink(200), q2931(201),
# virtualTg(202), sipTg(203), sipSig(204), docsCableUpstreamChannel(205),
# econet(206), pon155(207), pon622(208), bridge(209), linegroup(210),
# voiceEMFGD(211), voiceFGDEANA(212), voiceDID(213), mpegTransport(214),
# sixToFour(215), gtp(216), pdnEtherLoop1(217), pdnEtherLoop2(218),
# opticalChannelGroup(219), homepna(220), gfp(221), ciscoISLvlan(222),
# actelisMetaLOOP(223), fcipLink(224), rpr(225), qam(226), lmp(227),
# cblVectaStar(228), docsCableMCmtsDownstream(229), adsl2(230)