lldp.c File Reference

Link Layer Discovery Protocol. More...

#include <stdlib.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/iobuf.h>
#include <ipxe/netdevice.h>
#include <ipxe/if_ether.h>
#include <ipxe/settings.h>
#include <ipxe/lldp.h>

Go to the source code of this file.

Data Structures
struct	lldp_settings
	An LLDP settings block. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static int	lldp_applies (struct settings *settings __unused, const struct setting *setting)
	Check applicability of LLDP setting. More...
static int	lldp_fetch (struct settings *settings, struct setting *setting, void *buf, size_t len)
	Fetch value of LLDP setting. More...
static int	lldp_rx (struct io_buffer *iobuf, struct net_device *netdev, const void *ll_dest, const void *ll_source, unsigned int flags __unused)
	Process LLDP packet. More...
static int	lldp_probe (struct net_device *netdev, void *priv)
	Create LLDP settings block. More...
static void	lldp_remove (struct net_device *netdev __unused, void *priv)
	Remove LLDP settings block. More...

Variables
struct net_driver lldp_driver	__net_driver
	LLDP driver. More...
static const struct settings_scope	lldp_settings_scope
	LLDP settings scope. More...
static struct settings_operations	lldp_settings_operations
	LLDP settings operations. More...
struct net_protocol lldp_protocol	__net_protocol
	LLDP protocol. More...

Detailed Description

Link Layer Discovery Protocol.

Definition in file lldp.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

lldp_applies()

static int lldp_applies ( struct settings *settings  __unused, const struct setting *  setting  )

static

Check applicability of LLDP setting.

Parameters

settings	Settings block
setting	Setting to fetch

Return values

applies

Setting applies within this settings block

Definition at line 66 of file lldp.c.

                                                          {

        return ( setting->scope == &lldp_settings_scope );
}

References lldp_settings_scope, and setting::scope.

lldp_fetch()

static int lldp_fetch ( struct settings *  settings, struct setting *  setting, void *  buf, size_t  len  )

static

Fetch value of LLDP setting.

Parameters

settings	Settings block
setting	Setting to fetch
buf	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 81 of file lldp.c.

                                                {
        struct lldp_settings *lldpset =
                container_of ( settings, struct lldp_settings, settings );
        union {
                uint32_t high;
                uint8_t raw[4];
        } tag_prefix;
        uint32_t tag_low;
        uint8_t tag_type;
        uint8_t tag_index;
        uint8_t tag_offset;
        uint8_t tag_length;
        const void *match;
        const void *data;
        size_t match_len;
        size_t remaining;
        const struct lldp_tlv *tlv;
        unsigned int tlv_type_len;
        unsigned int tlv_type;
        unsigned int tlv_len;

        /* Parse setting tag */
        tag_prefix.high = htonl ( setting->tag >> 32 );
        tag_low = setting->tag;
        tag_type = ( tag_low >> 24 );
        tag_index = ( tag_low >> 16 );
        tag_offset = ( tag_low >> 8 );
        tag_length = ( tag_low >> 0 );

        /* Identify match prefix */
        match_len = tag_offset;
        if ( match_len > sizeof ( tag_prefix ) )
                match_len = sizeof ( tag_prefix );
        if ( ! tag_prefix.high )
                match_len = 0;
        match = &tag_prefix.raw[ sizeof ( tag_prefix ) - match_len ];

        /* Locate matching TLV */
        for ( data = lldpset->data, remaining = lldpset->len ; remaining ;
              data += tlv_len, remaining -= tlv_len ) {

                /* Parse TLV header */
                if ( remaining < sizeof ( *tlv ) ) {
                        DBGC ( lldpset, "LLDP %s underlength TLV header\n",
                               lldpset->name );
                        DBGC_HDA ( lldpset, 0, data, remaining );
                        break;
                }
                tlv = data;
                data += sizeof ( *tlv );
                remaining -= sizeof ( *tlv );
                tlv_type_len = ntohs ( tlv->type_len );
                tlv_type = LLDP_TLV_TYPE ( tlv_type_len );
                if ( tlv_type == LLDP_TYPE_END )
                        break;
                tlv_len = LLDP_TLV_LEN ( tlv_type_len );
                if ( remaining < tlv_len ) {
                        DBGC ( lldpset, "LLDP %s underlength TLV value\n",
                               lldpset->name );
                        DBGC_HDA ( lldpset, 0, data, remaining );
                        break;
                }
                DBGC2 ( lldpset, "LLDP %s found type %d:\n",
                        lldpset->name, tlv_type );
                DBGC2_HDA ( lldpset, 0, data, tlv_len );

                /* Check for matching tag type */
                if ( tlv_type != tag_type )
                        continue;

                /* Check for matching prefix */
                if ( tlv_len < match_len )
                        continue;
                if ( memcmp ( data, match, match_len ) != 0 )
                        continue;

                /* Check for matching index */
                if ( tag_index-- )
                        continue;

                /* Skip offset */
                if ( tlv_len < tag_offset )
                        return 0;
                data += tag_offset;
                tlv_len -= tag_offset;

                /* Set type if not already specified */
                if ( ! setting->type ) {
                        setting->type = ( tag_length ? &setting_type_hex :
                                          &setting_type_string );
                }

                /* Extract value */
                if ( tag_length && ( tlv_len > tag_length ) )
                        tlv_len = tag_length;
                if ( len > tlv_len )
                        len = tlv_len;
                memcpy ( buf, data, len );
                return tlv_len;
        }

        return -ENOENT;
}

References container_of, data, lldp_settings::data, DBGC, DBGC2, DBGC2_HDA, DBGC_HDA, ENOENT, high, htonl, len, lldp_settings::len, LLDP_TLV_LEN, LLDP_TLV_TYPE, LLDP_TYPE_END, memcmp(), memcpy(), lldp_settings::name, ntohs, raw, setting::tag, tlv, and setting::type.

lldp_rx()

static int lldp_rx ( struct io_buffer *  iobuf, struct net_device *  netdev, const void *  ll_dest, const void *  ll_source, unsigned int flags  __unused  )

static

Process LLDP packet.

Parameters

iobuf	I/O buffer
netdev	Network device
ll_dest	Link-layer destination address
ll_source	Link-layer source address
flags	Packet flags

Return values

rc	Return status code

Definition at line 203 of file lldp.c.

                                                   {
        struct lldp_settings *lldpset;
        size_t len;
        void *data;
        int rc;

        /* Find matching LLDP settings block */
        lldpset = netdev_priv ( netdev, &lldp_driver );

        /* Create trimmed copy of received LLDP data */
        len = iob_len ( iobuf );
        data = malloc ( len );
        if ( ! data ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        memcpy ( data, iobuf->data, len );

        /* Free any existing LLDP data */
        free ( lldpset->data );

        /* Transfer data to LLDP settings block */
        lldpset->data = data;
        lldpset->len = len;
        data = NULL;
        DBGC2 ( lldpset, "LLDP %s src %s ",
                lldpset->name, netdev->ll_protocol->ntoa ( ll_source ) );
        DBGC2 ( lldpset, "dst %s\n", netdev->ll_protocol->ntoa ( ll_dest ) );
        DBGC2_HDA ( lldpset, 0, lldpset->data, lldpset->len );

        /* Success */
        rc = 0;

        free ( data );
 err_alloc:
        free_iob ( iobuf );
        return rc;
}

References data, io_buffer::data, lldp_settings::data, DBGC2, DBGC2_HDA, ENOMEM, free, free_iob(), iob_len(), len, lldp_settings::len, net_device::ll_protocol, malloc(), memcpy(), lldp_settings::name, netdev, netdev_priv(), ll_protocol::ntoa, NULL, and rc.

lldp_probe()

static int lldp_probe ( struct net_device *  netdev, void *  priv  )

static

Create LLDP settings block.

Parameters

netdev	Network device
priv	Private data

Return values

rc	Return status code

Definition at line 258 of file lldp.c.

                                                                {
        struct lldp_settings *lldpset = priv;
        int rc;

        /* Initialise LLDP settings block */
        settings_init ( &lldpset->settings, &lldp_settings_operations,
                        &netdev->refcnt, &lldp_settings_scope );
        lldpset->name = netdev->name;

        /* Register settings */
        if ( ( rc = register_settings ( &lldpset->settings,
                                        netdev_settings ( netdev ),
                                        LLDP_SETTINGS_NAME ) ) != 0 ) {
                DBGC ( lldpset, "LLDP %s could not register settings: %s\n",
                       lldpset->name, strerror ( rc ) );
                goto err_register;
        }
        DBGC ( lldpset, "LLDP %s registered\n", lldpset->name );

        return 0;

        unregister_settings ( &lldpset->settings );
 err_register:
        assert ( lldpset->data == NULL );
        return rc;
}

References assert(), lldp_settings::data, DBGC, LLDP_SETTINGS_NAME, lldp_settings_operations, lldp_settings_scope, lldp_settings::name, net_device::name, netdev, netdev_settings(), NULL, priv, rc, net_device::refcnt, register_settings(), lldp_settings::settings, settings_init(), strerror(), and unregister_settings().

lldp_remove()

static void lldp_remove ( struct net_device *netdev  __unused, void *  priv  )

static

Remove LLDP settings block.

Parameters

netdev	Network device
priv	Private data

Definition at line 291 of file lldp.c.

                                                                           {
        struct lldp_settings *lldpset = priv;

        /* Unregister settings */
        unregister_settings ( &lldpset->settings );
        DBGC ( lldpset, "LLDP %s unregistered\n", lldpset->name );

        /* Free any LLDP data */
        free ( lldpset->data );
        lldpset->data = NULL;
}

References lldp_settings::data, DBGC, free, lldp_settings::name, NULL, priv, lldp_settings::settings, and unregister_settings().

Variable Documentation

__net_driver

struct net_driver lldp_driver __net_driver

Initial value:

= {
        .name = "LLDP",
        .priv_len = sizeof ( struct lldp_settings ),
        .probe = lldp_probe,
        .remove = lldp_remove,
}

LLDP driver.

Definition at line 54 of file lldp.c.

lldp_settings_scope

const struct settings_scope lldp_settings_scope

static

LLDP settings scope.

Definition at line 57 of file lldp.c.

Referenced by lldp_applies(), and lldp_probe().

lldp_settings_operations

struct settings_operations lldp_settings_operations

static

Initial value:

= {
        .applies = lldp_applies,
        .fetch = lldp_fetch,
}

LLDP settings operations.

Definition at line 188 of file lldp.c.

Referenced by lldp_probe().

__net_protocol

struct net_protocol lldp_protocol __net_protocol

Initial value:

= {
        .name = "LLDP",
        .net_proto = htons ( ETH_P_LLDP ),
        .rx = lldp_rx,
}

LLDP protocol.

AoE protocol.

Definition at line 245 of file lldp.c.