-- *********************************************************************
-- CISCO-LICENSE-MGMT-MIB.my: Cisco MIB to manage licenses on
-- Cisco devices
--   
-- July 2006, Sunil Gudurvalmiki
--   
-- Copyright (c) 2006-2007 by Cisco Systems Inc.
-- All rights reserved.
--   
-- ********************************************************************

CISCO-LICENSE-MGMT-MIB DEFINITIONS ::= BEGIN

IMPORTS
    OBJECT-TYPE,
    MODULE-IDENTITY,
    Unsigned32,
    NOTIFICATION-TYPE
        FROM SNMPv2-SMI
    MODULE-COMPLIANCE,
    OBJECT-GROUP,
    NOTIFICATION-GROUP
        FROM SNMPv2-CONF
    TEXTUAL-CONVENTION,
    TruthValue,
    RowStatus,
    StorageType
        FROM SNMPv2-TC
    SnmpAdminString
        FROM SNMP-FRAMEWORK-MIB
    entPhysicalIndex,
    PhysicalIndexOrZero
        FROM ENTITY-MIB
    InetAddressType,
    InetAddress
        FROM INET-ADDRESS-MIB
    ciscoMgmt
        FROM CISCO-SMI;


ciscoLicenseMgmtMIB MODULE-IDENTITY
    LAST-UPDATED    "200610030000Z"
    ORGANIZATION    "Cisco Systems Inc."
    CONTACT-INFO
            "Cisco Systems
            Customer Service
            Postal: 170 W Tasman Drive
            San Jose, CA  95134
            USA
            Tel: +1 800 553 -NETS
            E-mail: cs-snmp@cisco.com"
    DESCRIPTION
        "The MIB module for managing licenses on the system.
        The licensing mechanism provides flexibility to
        enforce licensing for various features in the system.

        The following text introduces different concepts and
        terms those are necessary to understand the MIB definition
        and to perform license management.

        UDI
            Universal Device Identifier that uniquely identifies a
            device. It comprises of product ID, version ID and serial
            number of the device.

        NODE LOCKED LICENSE:
            Node locked licenses are locked to one of the device
            identifiers in the system. For example, the license
            can be locked to the UDI value of one of the devices
            in the system. Locking a license to an UDI guarantees
            that the license will not be moved to a device with a
            different UDI.

        NON-NODE LOCKED LICENSE:
            Non-node locked licenses are not locked to any device
            identifier. They can be used on other similar devices.

        METERED LICENSE:
            Metered licenses are valid for limited period of time
            and they expire after that. This period is the usage
            period of a license and it is not based on real time
            clock, but system clock.

        EULA:
            End User License Agreement.

        EVALUATION LICENSE:
            Evaluation licenses are non-node locked metered
            licenses which are valid only for a limited period.
            They are used only when there are no permanent,
            extension or grace period licenses for a feature.
            User will have to accept EULA (End User License
            Agreement) before using an evaluation license. Even
            though they are not node locked, their usage is
            recorded on the device.

        EXTENSION LICENSE:
            Extension licenses are node locked metered licenses.
            These licenses are issued by Cisco's licensing portal.
            These licenses need to be installed using management
            interfaces on the device. User will have to accept an
            EULA as part of installation of extension license.

        GRACE PERIOD LICENSE:
            Grace period licenses are node locked metered licenses.
            These licenses are issued by Cisco's licensing portal
            as part of the permission ticket to rehost a license.
            These licenses are installed on the device as part of
            the rehost operation. User will have to accept an
            EULA as part of the rehost operation for this type
            of license. Details on permission ticket, rehost
            operations are provided further down in this
            description clause.

        PERMANENT LICENSE:
            Permanent licenses are node locked licenses that have
            no usage period associated with them. These licenses
            are issued by Cisco's licensing portal. These licenses
            need to be installed using management interfaces on
            the device. Once these licenses are installed, they
            will provide needed permission for the feature/image
            across different versions.

        COUNTED LICENSE:
            Counted licenses limit the number of similar entities
            that can use the license. For example, a counted
            license when used by a feature can limit the number
            of IP phones that can connect or the number of tunnels
            that can be created.

        UNCOUNTED LICENSE:
            Uncounted licenses do not limit the number of similar
            entities that can use the licenses.

        License can be enforced at the image level or at the feature
        level and this MIB module supports both.

        IMAGE LEVEL LICENSING:
            A universal image that contains all levels of
            software packages is loaded on to the device. At boot
            time, the device determines the highest level of license
            and brings up the appropriate software features or
            subsystems.

        FEATURE LEVEL LICENSING:
            Feature level licensing will support enforcement of
            license at individual feature. Features have to check
            for their licenses before enabling themselves. If it
            does not have a license, the feature should disable
            itself.

            There is a one-to-one relationship between
            a feature and a license. That is, a feature can use
            only one license at a time and a license can be used
            by only one feature at a time.

        LICENSE LINE:
            A License line is an atomic set of ASCII characters
            arranged in a particular format that holds the license
            for a single feature within it. A line has all the
            necessary fields and attributes that make it a valid,
            non-tamper able and complete license.

        LICENSE FILE:
            File generated by Cisco licensing portal. It is used
            to install license on product. It has a user readable
            part and it contains one or more license lines.

        DEVICE CREDENTIALS:
            Device credentials file is a document that is generated
            by a licensed device. This document establishes the
            identity of the device and proves that the sender/user
            has/had authorized access to the device.

        REHOST:
            Rehost operation allows a node locked license that
            is installed on a device to be installed on other
            similar device. As part of rehost operation, a device
            processes the permission ticket, revokes the license(s)
            on the device and generates a rehost ticket as the
            proof of revocation. This rehost ticket needs to be
            presented to the Cisco's licensing portal to get the
            license transferred on to a new similar device.

        PERMISSION TICKET:
            Permission ticket is a document generated by Cisco
            licensing portal that allows a device to rehost its
            licenses.

        REHOST TICKET:
            Rehost ticket is document generated by a device after
            it has applied a permission ticket. The rehost ticket
            is a proof of revocation.

        LICENSING PORTAL:
            Generates licenses, permission tickets and verifies
            device credentials and rehost tickets.

        This MIB module provides MIB objects to install, clear,
        revoke licenses. It also provides objects to regenerate
        last rehost ticket, backup all the licenses installed
        on a device, generate & export EULA for licenses.

        STEPS TO INSTALL A LICENSE:
            To install a license, the management application
            1. Retrieves device credentials of the device.
            2. Communicates with Cisco's licensing portal to get
               the license file, uses device credentials to identify
               the device
            3. Executes the license install action.

        STEPS TO CLEAR A LICENSE:
            To clear a license, the management application
            1. Identifies the license to be cleared using license
               index.
            2. Executes the license clear action.

        STEPS TO REHOST A LICENSE:
            To rehost a license, the management application
            1. Retrieves device credentials of the device.
            2. Communicates with Cisco's licensing portal to get
               the permission ticket, uses device credentials to
               identify the device.
            3. Executes the processPermissionTicket action. Device
               revokes the license and generates rehost ticket to be
               submitted as proof of revocation.
            4. Retrieves device credentials of the device where the
               license needs to be transferred to.
            5. Submits rehost ticket as proof of revocation to
               Cisco's licensing portal, uses device credentials of
               the new device to identify the device, gets license
               file.
            6. Executes the license install action on the new
               device.

        STEPS TO REGENERATE LAST REHOST TICKET:
            To regenerate last rehost ticket, the management
        application
            1. Retrieves device credentials of the device.
            2. Uses already obtained permission ticket or
               communicates with Cisco's licensing portal to get
               the permission ticket, uses device credentials to
               identify the device.
            3. Executes the regenerateLastRehostTicket action.
               Device generates rehost ticket to be submitted as
               proof of revocation.

        STEPS TO BACKUP ALL LICENSES:
            To backup all licenses installed in the device, the
            management application
            1. Specifies the backup file path.
            2. Executes the license backup action.

        STEPS TO GENERATE & EXPORT EULA:
            To install certain kind of licenses, the management
            application must accept EULA first. The management
            application can generate and export EULA for one or
            more licenses with out installing licenses as follows.
            1. Specifies the license file path that has licenses to be
               installed
            2. Specifies the EULA file path where EULA need to be
               exported to
            3. Executes the generate EULA action.

        To support the various license actions, this MIB module
        also defines MIB objects to know if a device supports
        licensing, retrieve device credentials, retrieve
        information on license stores in the device.

        It also defines MIB objects to expose management
        information associated with the licenses installed on the
        device, with the licensable features in the software image.

        This MIB module also defines various notifications that
        will be triggered to asynchronously notify the management
        application of any critical events.

        This MIB module is defined generically so it can be
        implemented on stand alone devices or stack of devices.
        In stack of devices, one device in the stack acts as
        master agent and rest are slave agents. Each device in the
        stack has its own UDI. The master agent receives requests
        on behalf of all the devices in the stack including itself
        and delegates it to other devices as needed. It also
        collects responses from other devices and sends them to
        the management application. Examples of such devices include
        stackable switches, devices with route processor and line
        cards. On the other hand, stand alone device is a single
        device and has only one UDI associated with it.

        entPhysicalIndex imported from ENTITY-MIB is used to
        identify the device uniquely. It is specified as the index
        or one of the index for tables in this MIB as needed."
    REVISION        "200610030000Z"
    DESCRIPTION
        "Initial version of this MIB module."
    ::= { ciscoMgmt 543 }


ciscoLicenseMgmtMIBNotifs  OBJECT IDENTIFIER
    ::= { ciscoLicenseMgmtMIB 0 }

ciscoLicenseMgmtMIBObjects  OBJECT IDENTIFIER
    ::= { ciscoLicenseMgmtMIB 1 }

ciscoLicenseMgmtMIBConform  OBJECT IDENTIFIER
    ::= { ciscoLicenseMgmtMIB 2 }

clmgmtLicenseConfiguration  OBJECT IDENTIFIER
    ::= { ciscoLicenseMgmtMIBObjects 1 }

clmgmtLicenseInformation  OBJECT IDENTIFIER
    ::= { ciscoLicenseMgmtMIBObjects 2 }

clmgmtLicenseDeviceInformation  OBJECT IDENTIFIER
    ::= { ciscoLicenseMgmtMIBObjects 3 }

clmgmtLicenseNotifObjects  OBJECT IDENTIFIER
    ::= { ciscoLicenseMgmtMIBObjects 4 }


ClmgmtLicenseIndex ::= TEXTUAL-CONVENTION
    STATUS          current
    DESCRIPTION
        "A unique value, for each license in the managed system.
        It is not necessary to have values assigned contiguously.
        The value for each license must remain constant
        at least from one re-initialization of the entity's
        network management system to the next re-initialization"
    SYNTAX          Unsigned32 (1..4294967295 )

ClmgmtLicenseIndexOrZero ::= TEXTUAL-CONVENTION
    STATUS          current
    DESCRIPTION
        "This textual convention is an extension of the ClmgmtLicenseIndex
        convention.  The latter defines a greater than zero value
        used to identify a license in the managed system.  This
        extension permits the additional value of zero. The value
        zero is object-specific and must therefore be defined as
        part of the description of any object which uses this
        syntax. Examples of the usage of zero might include
        situations where license was not present or unknown."
    SYNTAX          Unsigned32

ClmgmtLicenseTransferProtocol ::= TEXTUAL-CONVENTION
    STATUS          current
    DESCRIPTION
        "The transfer protocol that should be used for copying files
        when performing license management. When the protocol is
        set to local(2), local file system (flash or disk) is used.
        Different agents may support different transfer protocols
        and the management application is expected to some how determine
        which protocol is supported and use."
    SYNTAX          INTEGER  {
                        none(1),
                        local(2),
                        tftp(3),
                        ftp(4),
                        rcp(5),
                        http(6),
                        scp(7),
                        sftp(8)
                    }

ClmgmtLicenseActionState ::= TEXTUAL-CONVENTION
    STATUS          current
    DESCRIPTION
        "The state of license action execution.

        none(1)                - action is not yet scheduled to be
                                 executed.

        pending(2)             - All the required parameters for the
                                 action are set and the action is
                                 scheduled to be executed.

        inProgress(3)          - action execution has started and is
                                 in progress.

        successful(4)          - action has completed successfully.

        partiallySuccessful(5) - action has completed, but was
                                 partially successful. Management
                                 application can query additional MIB
                                 objects to know what is successful
                                 and what has failed. These addtional
                                 objects are listed in the
                                 description of the corresponding
                                 action tables.

        failed(6)              - action has failed."
    SYNTAX          INTEGER  {
                        none(1),
                        pending(2),
                        inProgress(3),
                        successful(4),
                        partiallySuccessful(5),
                        failed(6)
                    }

ClmgmtLicenseActionFailCause ::= TEXTUAL-CONVENTION
    STATUS          current
    DESCRIPTION
        "Reason for license action failure. Defines error codes for
        all the license actions.

        none(1)                    - action execution has not
                                     started yet. If the action
                                     is completed and the action
                                     is successful, then also
                                     none(1) is returned to
                                     indicate that there are no
                                     errors.
        generalFailure(2)          - General licensing failure.
                                     This will be used for resource
                                     unavailability failures.
                                     Ex: Lack of memory.
        transferProtocolNotSupported(3) - protocol selected is not
                                          supported.
        fileServerNotReachable(4) - file server is not reachable.
        unrecognizedEntPhysicalIndex(5) - entPhysicalIndex is not
                                          valid
        invalidLicenseFilePath(6)  - The license file path is not
                                     accessible.
        invalidLicenseFile(7)      - Contents of license file are
                                     not valid.
        invalidLicenseLine(8)      - License string in the license
                                     file is not valid.
        licenseAlreadyExists(9)    - Management application is trying
                                     to install a license that already
                                     exists.
        licenseNotValidForDevice(10) - This license is not valid for
                                      the device/entPhysicalIndex
                                      specified.
        invalidLicenseCount(11)     - Invalid count for this counted
                                     license.
        invalidLicensePeriod(12)   - Validity period is invalid for
                                     this expiring license.
        licenseInUse(13)           - License file is in use by a
                                     feature/image.
        invalidLicenseStore(14)    - License store is not valid.
        licenseStorageFull(15)     - There is no more space in the
                                     license storage.
        invalidPermissionTicketFile(16) - The permission ticket file
                                          path is not accecssible.
        invalidPermissionTicket(17) - The permission ticket file
                                      contents are not valid.
        invalidRehostTicketFile(18) - The rehost ticket file path is
                                      not accessible.
        invalidRehostTicket(19)     - The rehost ticket file contents
                                      are not valid.
        invalidLicenseBackupFile(20) - License backup store path
                                       is not accessible.
        licenseClearInProgress(21)  - When license clear action is
                                      in progress, license backup
                                      action is not permitted to
                                      avoid race conditions. This
                                      error code is sent back in
                                      response to a license backup
                                      action when a license clear
                                      action is in progress or in
                                      pending state. Try again in few
                                      seconds.
        invalidLicenseEULAFile(22) -  EULA file path is not accessible."
    SYNTAX          INTEGER  {
                        none(1),
                        generalFailure(2),
                        transferProtocolNotSupported(3),
                        fileServerNotReachable(4),
                        unrecognizedEntPhysicalIndex(5),
                        invalidLicenseFilePath(6),
                        invalidLicenseFile(7),
                        invalidLicenseLine(8),
                        licenseAlreadyExists(9),
                        licenseNotValidForDevice(10),
                        invalidLicenseCount(11),
                        invalidLicensePeriod(12),
                        licenseInUse(13),
                        invalidLicenseStore(14),
                        licenseStorageFull(15),
                        invalidPermissionTicketFile(16),
                        invalidPermissionTicket(17),
                        invalidRehostTicketFile(18),
                        invalidRehostTicket(19),
                        invalidLicenseBackupFile(20),
                        licenseClearInProgress(21),
                        invalidLicenseEULAFile(22)
                    }

clmgmtNextFreeLicenseActionIndex OBJECT-TYPE
    SYNTAX          Unsigned32 (1..4294967295 )
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object contains appropriate value for
        clmgmtLicenseActionIndex that can be used to create
        an entry in clmgmtLicenseActionTable. The management application
        should read this object first and then use this as the
        value for clmgmtLicenseActionIndex to avoid collisions
        when creating entries in clmgmtLicenseActionTable.
        Following this approach does not guarantee collision free
        row creation, but will reduce the probability. The
        collision will happen if two management applications read this
        object at the same time and attempt to create an entry
        with this value at the same time. In this case, the
        management application whose request is processed after the first
        request will get an error and the process of reading this object
        and entry creation needs to be repeated." 
    ::= { clmgmtLicenseConfiguration 1 }
-- Table for executing license management actions.

clmgmtLicenseActionTable OBJECT-TYPE
    SYNTAX          SEQUENCE OF ClmgmtLicenseActionEntry 
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "A table for invoking license management actions. Management
        application must create a row in this table to trigger any of
        the license management actions. The following are different
        actions that can be executed using this table.
            1. install
            2. clear
            3. processPermissionTicket
            4. regenerateLastRehostTicket
            5. backup
            6. generateEULA

        Refer to the description of clmgmtLicenseAction for more
        information on what these actions do on the device.
        Once the request completes, the management application should
        retrieve the values of the objects of interest, and then
        delete the entry.  In order to prevent old entries from
        clogging the table, entries will be aged out, but an entry
        will never be deleted within 5 minutes of completion."
    ::= { clmgmtLicenseConfiguration 2 }

clmgmtLicenseActionEntry OBJECT-TYPE
    SYNTAX          ClmgmtLicenseActionEntry
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "An entry for each action that is being executed or was
        executed recently. The management application executes an
        action
        by creating this entry. This can be done in the following
        2 methods

        1. CREATE-AND-GO method
            Management application sets clmgmtLicenseActionRowStatus to
            createAndGo(4) and all other required objects to valid
            values in a single SNMP SET request. If all the values
            are valid, the device creates the entry and executes the
            action. If the SET request fails, the entry will not be
            created.
        2. CREATE-AND-WAIT method
            Management application sets clmgmtLicenseActionRowStatus to
            createAndWait(5) to create an entry. Management application
            can set all other required objects to valid
            values in more than one SNMP SET request. If SET request
            for any of the objects fails, management application can
        set
            just only that object. Once all the required objects
            are set to valid values, management application triggers
        action
            execution by setting clmgmtLicenseActionRowStatus to
            active(1).

        To stop the action from being executed, the management
        application
        can delete the entry by setting clmgmtLicenseActionRowStatus
        to destroy(6) when clmgmtLicenseActionState is pending(2).

        The status of action execution can be known by querying
        clmgmtLicenseActionState. If the action is still in
        pending(2) or in inProgress(3) state, the management
        application need to check back again after few seconds.
        Once the action completes and status of the action is
        failed(6), the reason for failure can be retrieved
        from clmgmtLicenseActionFailCause. If the status of the
        action is partiallySuccessful(5), results of individual
        licenses can be queried from clmgmtLicenseActionResultTable.

        Not all objects in the entry are needed to execute every
        action. Below is the list of actions and the required
        objects that are needed to be set for executing that
        action.

        1. Installing a license
           The following MIB objects need to be set for installing a
           license
             a. clmgmtLicenseActionTransferProtocol
             b. clmgmtLicenseServerAddressType
             c. clmgmtLicenseServerAddress
             d. clmgmtLicenseServerUsername
             e. clmgmtLicenseServerPassword
             f. clmgmtLicenseFile
             g. clmgmtLicenseStore
             h. clmgmtLicenseStopOnFailure
             i. clmgmtLicenseAcceptEULA
             j. clmgmtLicenseAction

           clmgmtLicenseActionEntPhysicalIndex need not be set
           explicitly for license installs. License itself identifes
           the device where the license needs to be installed.

           clmgmtLicenseStore need to be set to store the licenses
           in a non-default license store. But, if a license file
           has more than one license and licenses need to be
           installed on multiple devices (for example to multiple
           members with in a stack), then value of clmgmtLicenseStore
           is ignored and the licenses will be installed in default
           license stores of the respective devices.

        2. Clearing a license
           The following MIB objects need to be set for clearing a
           license
             a. clmgmtLicenseActionEntPhysicalIndex
             b. clmgmtLicenseActionLicenseIndex
             c. clmgmtLicenseStore
             d. clmgmtLicenseAction

        3. Revoking a license
           The following MIB objects need to be set for revoking a
           license
             a. clmgmtLicenseActionTransferProtocol
             b. clmgmtLicenseServerAddressType
             c. clmgmtLicenseServerAddress
             d. clmgmtLicenseServerUsername
             e. clmgmtLicenseServerPassword
             f. clmgmtLicensePermissionTicketFile
             g. clmgmtLicenseRehostTicketFile
             h. clmgmtLicenseStopOnFailure
             i. clmgmtLicenseAction

        4. Regenerate last rehost ticket
           The following MIB objects need to be set for regenerating
           last rehost ticket
             a. clmgmtLicenseActionTransferProtocol
             b. clmgmtLicenseServerAddressType
             c. clmgmtLicenseServerAddress
             d. clmgmtLicenseServerUsername
             e. clmgmtLicenseServerPassword
             f. clmgmtLicensePermissionTicketFile
             g. clmgmtLicenseRehostTicketFile
             h. clmgmtLicenseStopOnFailure
             i. clmgmtLicenseAction


        5. Save all licenses to a backup storage
           The following MIB objects need to be set for storing all
           licenses to a backup store
             a. clmgmtLicenseActionEntPhysicalIndex
             b. clmgmtLicenseActionTransferProtocol
             c. clmgmtLicenseServerAddressType
             d. clmgmtLicenseServerAddress
             e. clmgmtLicenseServerUsername
             f. clmgmtLicenseServerPassword
             g. clmgmtLicenseBackupFile
             h. clmgmtLicenseAction

        6. Generate and export EULA if the licenses need EULA to be
           accepted for installing.
           The following MIB objects need to be set exporting required
           EULAs
             a. clmgmtLicenseActionTransferProtocol
             b. clmgmtLicenseServerAddressType
             c. clmgmtLicenseServerAddress
             d. clmgmtLicenseServerUsername
             e. clmgmtLicenseServerPassword
             f. clmgmtLicenseFile
             g. clmgmtLicenseEULAFile
             h. clmgmtLicenseAction

        For any action, if clmgmtLicenseActionTransferProtocol
        is set to local(2), the following objects need not be set.
             a. clmgmtLicenseServerAddressType
             b. clmgmtLicenseServerAddress
             c. clmgmtLicenseServerUsername
             d. clmgmtLicenseServerPassword

        Entry can be deleted except when clmgmtLicenseAction is set
        to pending(2). All entries are volatile and are cleared
        on agent reset."
    INDEX           { clmgmtLicenseActionIndex } 
    ::= { clmgmtLicenseActionTable 1 }

ClmgmtLicenseActionEntry ::= SEQUENCE {
        clmgmtLicenseActionIndex            Unsigned32,
        clmgmtLicenseActionEntPhysicalIndex PhysicalIndexOrZero,
        clmgmtLicenseActionTransferProtocol ClmgmtLicenseTransferProtocol,
        clmgmtLicenseServerAddressType      InetAddressType,
        clmgmtLicenseServerAddress          InetAddress,
        clmgmtLicenseServerUsername         SnmpAdminString,
        clmgmtLicenseServerPassword         SnmpAdminString,
        clmgmtLicenseFile                   SnmpAdminString,
        clmgmtLicenseStore                  Unsigned32,
        clmgmtLicenseActionLicenseIndex     ClmgmtLicenseIndexOrZero,
        clmgmtLicensePermissionTicketFile   SnmpAdminString,
        clmgmtLicenseRehostTicketFile       SnmpAdminString,
        clmgmtLicenseBackupFile             SnmpAdminString,
        clmgmtLicenseStopOnFailure          TruthValue,
        clmgmtLicenseAction                 INTEGER ,
        clmgmtLicenseActionState            ClmgmtLicenseActionState,
        clmgmtLicenseJobQPosition           Unsigned32,
        clmgmtLicenseActionFailCause        ClmgmtLicenseActionFailCause,
        clmgmtLicenseActionStorageType      StorageType,
        clmgmtLicenseActionRowStatus        RowStatus,
        clmgmtLicenseAcceptEULA             TruthValue,
        clmgmtLicenseEULAFile               SnmpAdminString
}

clmgmtLicenseActionIndex OBJECT-TYPE
    SYNTAX          Unsigned32 (1..4294967295 )
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This object uniquely identifies a row in
        clmgmtLicenseActionTable. The management application should choose
        this value by reading clmgmtNextFreeLicenseActionIndex
        while creating an entry in this table. If an entry already
        exists with this index, the creation of the entry will not
        continue and error will be returned. The management application
        should read the value of clmgmtNextFreeLicenseActionIndex
        again and retry with the new value for this object." 
    ::= { clmgmtLicenseActionEntry 1 }

clmgmtLicenseActionEntPhysicalIndex OBJECT-TYPE
    SYNTAX          PhysicalIndexOrZero
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object represents the entPhysicalIndex of the device
        where the action is being executed. This object is mainly
        used in devices where one device is acting as a master and
        rest of the devices as slaves. The master device is
        responsible for SNMP communication with the management
        application. Examples include stackable switches, devices
        with route processor and line card configuration. If this
        object is not set, the license action will be executed on
        the master device. Note: This object need not be set if
        there is a stand alone device"
    DEFVAL          { 0 } 
    ::= { clmgmtLicenseActionEntry 2 }

clmgmtLicenseActionTransferProtocol OBJECT-TYPE
    SYNTAX          ClmgmtLicenseTransferProtocol
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object represents the transfer protocol to be used
        when copying files as specified in the following objects.
        1. clmgmtLicenseFile
        2. clmgmtLicensePermissionTicketFile
        3. clmgmtLicenseRehostTicketFile
        4. clmgmtLicenseBackupFile

        Note: This object need not be set if the all the files
        required for the action are in device's local file system."
    DEFVAL          { none } 
    ::= { clmgmtLicenseActionEntry 3 }

clmgmtLicenseServerAddressType OBJECT-TYPE
    SYNTAX          InetAddressType
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the transport type of the
        address contained in clmgmtLicenseServerAddress object.
        This must be set when clmgmtLicenseActionTransferProtocol
        is not none(1) or local(2)."
    DEFVAL          { unknown } 
    ::= { clmgmtLicenseActionEntry 4 }

clmgmtLicenseServerAddress OBJECT-TYPE
    SYNTAX          InetAddress
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the ip address of the server from
        which the files must be read or written to if
        clmgmtLicenseActionTransferProtocol is not none(1) or
        local(2).

        All bits as 0s or 1s for clmgmtLicenseServerAddress are not
        allowed.

        The format of this address depends on the value of the
        clmgmtLicenseServerAddressType object"
    DEFVAL          { "" } 
    ::= { clmgmtLicenseActionEntry 5 }

clmgmtLicenseServerUsername OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..96))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the remote user name for accessing
        files via ftp, rcp, sftp or scp protocols. This object must
        be set when the clmgmtLicenseActionTransferProtocol is
        ftp(4), rcp(5), scp(7) or sftp(8). If
        clmgmtLicenseActionTransferProtocol is rcp(5), the remote
        username is sent as the server username in an rcp command
        request sent by the system to a remote rcp server."
    DEFVAL          { "" } 
    ::= { clmgmtLicenseActionEntry 6 }

clmgmtLicenseServerPassword OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..96))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the password used by ftp, sftp or
        scp for copying a file to/from an ftp/sftp/scp server.
        This object must be set when the
        clmgmtLicenseActionTransferProtocol is ftp(4) or scp(7)
        or sftp(8). Reading it returns a zero-length string for
        security reasons."
    DEFVAL          { "" } 
    ::= { clmgmtLicenseActionEntry 7 }

clmgmtLicenseFile OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..255))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object represents the location of the license file
        on the server identified by clmgmtLicenseServerAddress. This
        object MUST be set to a valid value before or concurrently
        with setting the value of the clmgmtLicenseAction object to
        install(2). For other operations, the value of this
        object is not considered, it is irrelevant."
    DEFVAL          { "" } 
    ::= { clmgmtLicenseActionEntry 8 }

clmgmtLicenseStore OBJECT-TYPE
    SYNTAX          Unsigned32
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object represents the clmgmtLicenseStoreIndex of the
        license store to use within the device. The license store
        can be a local disk or flash. A device can have more than
        one license stores. If this object is not set, the license
        will be stored in the default license store as exposed by
        clmgmtDefaultLicenseStore object."
    DEFVAL          { 0 } 
    ::= { clmgmtLicenseActionEntry 9 }

clmgmtLicenseActionLicenseIndex OBJECT-TYPE
    SYNTAX          ClmgmtLicenseIndexOrZero
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the the license index of the license
        that is the subject of this action. This is used for
        identifying a license for performing actions specific to
        that license. This object need to be set only if
        clmgmtLicenseAction is set to clear(4). The value of this
        object is same as the clmgmtLicenseIndex object in
        clmgmtLicenseInfoEntry for license that is subject of this
        action."
    DEFVAL          { 0 } 
    ::= { clmgmtLicenseActionEntry 10 }

clmgmtLicensePermissionTicketFile OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..255))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the file name of the permission
        ticket. This object need to be set only if
        clmgmtLicenseAction is set to processPermissionTicket(4)
        or regenerateLastRehostTicket(5) actions. The permission
        ticket is obtained from Cisco licensing portal to revoke
        a license. The management application must set this object
        to valid value before invoking the action."
    DEFVAL          { "" } 
    ::= { clmgmtLicenseActionEntry 11 }

clmgmtLicenseRehostTicketFile OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..255))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the file where the rehost ticket
        generated by the device need to be exported to. The rehost
        ticket is generated as a result of processPermissionTicket
        and regenerateLastRehostTicket actions. After generating
        the rehost ticket, the device exports the rehost ticket
        contents to this file. This object need to be set only
        if clmgmtLicenseAction is set to processPermissionTicket(4)
        or regenerateLastRehostTicket(5) actions."
    DEFVAL          { "" } 
    ::= { clmgmtLicenseActionEntry 12 }

clmgmtLicenseBackupFile OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..255))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the file where all the licenses in
        the device need to be backed up. This object need to be set
        only if clmgmtLicenseAction is set to backup(6) and the
        management application must set the value of this  object
        to valid value before invoking action."
    DEFVAL          { "" } 
    ::= { clmgmtLicenseActionEntry 13 }

clmgmtLicenseStopOnFailure OBJECT-TYPE
    SYNTAX          TruthValue
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates whether the license action should
        stop if the action on a license fails. This object is
        applicable only if there are more than one licenses
        involved in an action."
    DEFVAL          { false } 
    ::= { clmgmtLicenseActionEntry 14 }

clmgmtLicenseAction OBJECT-TYPE
    SYNTAX          INTEGER  {
                        noOp(1),
                        install(2),
                        clear(3),
                        processPermissionTicket(4),
                        regenerateLastRehostTicket(5),
                        backup(6),
                        generateEULA(7)
                    }
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the the command/action to be executed.

        Command                        Remarks
        -------                        -------
        noOp(1)                        No operation will be
                                       performed.

        install(2)                     Installs the license.

        clear(3)                       Clears the license.

        processPermissionTicket(4)     Processes thee permission
                                       ticket and generates and
                                       exports rehost ticket.

        regenerateLastRehostTicket(5)  Generates and exports the
                                       last generated rehost
                                       ticket.

        backup(6)                      Backs up all the licenses
                                       installed currently onto a
                                       backup store.

        generateEULA(7)                Checks whether the licenses
                                       in the license file need EULA
                                       acceptance and uploads the
                                       needed EULA contents to a file."
    DEFVAL          { noOp } 
    ::= { clmgmtLicenseActionEntry 15 }

clmgmtLicenseActionState OBJECT-TYPE
    SYNTAX          ClmgmtLicenseActionState
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the state of this license action." 
    ::= { clmgmtLicenseActionEntry 16 }

clmgmtLicenseJobQPosition OBJECT-TYPE
    SYNTAX          Unsigned32
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object represents the position of the action
        in the license action job queue that is maintained
        internally. Only actions in pending(2) state will
        be put in the queue until they are executed. By
        reading this object, the management application can make
        intelligent decision on whether to execute another
        action that it is planning on. For example, if there
        is already a license clear action in the queue in
        pending(2) state, management application can choose to
        defer its license back up action to a later time. This
        object will return a value of 0 if the action is not in
        pending(2) state." 
    ::= { clmgmtLicenseActionEntry 17 }

clmgmtLicenseActionFailCause OBJECT-TYPE
    SYNTAX          ClmgmtLicenseActionFailCause
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the reason for this license action
        failure. The value of this object is valid only when
        clmgmtLicenseActionState is failed(6)." 
    ::= { clmgmtLicenseActionEntry 18 }

clmgmtLicenseActionStorageType OBJECT-TYPE
    SYNTAX          StorageType
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the storage type for this conceptual
        row. Conceptual rows having the value 'permanent' need not
        allow write-access to any columnar objects in the row."
    DEFVAL          { volatile } 
    ::= { clmgmtLicenseActionEntry 19 }

clmgmtLicenseActionRowStatus OBJECT-TYPE
    SYNTAX          RowStatus
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the the status of this table entry.
        Once the entry status is set to active(1), the associated
        entry cannot be modified until the action completes
        (clmgmtLicenseConfigCommandStatus is set to a value
        other than inProgress(3)). Once the action completes
        the only operation possible after this is to delete
        the row. It is recommended that the management application
        should delete entries in this table after reading
        the result. In order to prevent old entries from
        clogging the table, entries will be aged out, but an
        entry will never be deleted within 5 minutes of
        completion" 
    ::= { clmgmtLicenseActionEntry 20 }

clmgmtLicenseAcceptEULA OBJECT-TYPE
    SYNTAX          TruthValue
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates whether the End User License Agreement
        needed for installing the licenses is accepted.

        true(1) - EULA is read and accepted
        false(2) - EULA is not accepted

        Management application should set this object to true(1) when
        installing licenses that need EULA acceptance."
    DEFVAL          { false } 
    ::= { clmgmtLicenseActionEntry 21 }

clmgmtLicenseEULAFile OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..255))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the file where all the End User License
        Agreements (EULAs) need to be exported to. This object need to
        be set only if clmgmtLicenseAction is set to generateEULA(7) and
        the management application must set the value of this object to
        valid value before invoking action."
    DEFVAL          { "" } 
    ::= { clmgmtLicenseActionEntry 22 }
 

-- License action results table.

clmgmtLicenseActionResultTable OBJECT-TYPE
    SYNTAX          SEQUENCE OF ClmgmtLicenseActionResultEntry 
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This table contains results of license action if the
        license action involves multiple licenses. Entries in this
        table are not created for actions where there is
        only license that is subject of the action. For
        example, if there are 3 licenses in a license file
        when executing license install action, 3 entries will
        be created in this table, one for each license."
    ::= { clmgmtLicenseConfiguration 3 }

clmgmtLicenseActionResultEntry OBJECT-TYPE
    SYNTAX          ClmgmtLicenseActionResultEntry
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "An entry in clmgmtLicenseActionResultTable. Each entry
        contains result of the action for a single license.
        These entries are created immediately after action
        execution when the action involves multiple licenses.
        These entries get automatically deleted when the
        corresponding entry in clmgmtLicenseActionTable
        is deleted."
    INDEX           {
                        clmgmtLicenseActionIndex,
                        clmgmtLicenseNumber
                    } 
    ::= { clmgmtLicenseActionResultTable 1 }

ClmgmtLicenseActionResultEntry ::= SEQUENCE {
        clmgmtLicenseNumber               Unsigned32,
        clmgmtLicenseIndivActionState     ClmgmtLicenseActionState,
        clmgmtLicenseIndivActionFailCause ClmgmtLicenseActionFailCause
}

clmgmtLicenseNumber OBJECT-TYPE
    SYNTAX          Unsigned32 (1..4294967295 )
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This object indicates the sequence number of this license
        in the list of licenses on which the action is executed.
        For example, if there are 3 licenses in a license file
        when executing license install action, this object will
        have values 1, 2 and 3 respectively as ordered in the
        license file." 
    ::= { clmgmtLicenseActionResultEntry 1 }

clmgmtLicenseIndivActionState OBJECT-TYPE
    SYNTAX          ClmgmtLicenseActionState
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the state of action on this
        individual license." 
    ::= { clmgmtLicenseActionResultEntry 2 }

clmgmtLicenseIndivActionFailCause OBJECT-TYPE
    SYNTAX          ClmgmtLicenseActionFailCause
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the reason for action failure on this
        individual license" 
    ::= { clmgmtLicenseActionResultEntry 3 }
 

-- License Store Info Table

clmgmtLicenseStoreInfoTable OBJECT-TYPE
    SYNTAX          SEQUENCE OF ClmgmtLicenseStoreInfoEntry 
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This table contains information about all the license
        stores allocated on the device."
    ::= { clmgmtLicenseInformation 1 }

clmgmtLicenseStoreInfoEntry OBJECT-TYPE
    SYNTAX          ClmgmtLicenseStoreInfoEntry
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "An entry in clmgmtLicenseStoreInfoTable. Each entry
        contains information about a license store allocated
        on the device"
    INDEX           {
                        entPhysicalIndex,
                        clmgmtLicenseStoreIndex
                    } 
    ::= { clmgmtLicenseStoreInfoTable 1 }

ClmgmtLicenseStoreInfoEntry ::= SEQUENCE {
        clmgmtLicenseStoreIndex         Unsigned32,
        clmgmtLicenseStoreName          SnmpAdminString,
        clmgmtLicenseStoreTotalSize     Unsigned32,
        clmgmtLicenseStoreSizeRemaining Unsigned32
}

clmgmtLicenseStoreIndex OBJECT-TYPE
    SYNTAX          Unsigned32 (1..4294967295 )
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This object uniquely identifies a license store within
        the device." 
    ::= { clmgmtLicenseStoreInfoEntry 1 }

clmgmtLicenseStoreName OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..255))
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the name of the license store
        within the device. It is a file in device's local file
        system i.e., either on a local disk or flash or some
        other storage media. For example, the value of this
        object can be 'disk1:lic_store_1.txt' or
        'flash:lic_store_2.txt" 
    ::= { clmgmtLicenseStoreInfoEntry 2 }

clmgmtLicenseStoreTotalSize OBJECT-TYPE
    SYNTAX          Unsigned32
    UNITS           "bytes"
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the total number of bytes that are
        allocated to the license store." 
    ::= { clmgmtLicenseStoreInfoEntry 3 }

clmgmtLicenseStoreSizeRemaining OBJECT-TYPE
    SYNTAX          Unsigned32
    UNITS           "bytes"
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the number of bytes still remaining
        to be used for new license installations in the license
        store." 
    ::= { clmgmtLicenseStoreInfoEntry 4 }
 

-- License Device Info Table

clmgmtLicenseDeviceInfoTable OBJECT-TYPE
    SYNTAX          SEQUENCE OF ClmgmtLicenseDeviceInfoEntry 
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This table contains objects that provide licensing related
        information at the device level. Entries will exist
        only for entities that support licensing. For example,
        if it is a stand alone device and supports licensing,
        then there will be only one entry in this table. If
        it is stackable switch then there will be multiple
        entries with one entry for each device in the stack."
    ::= { clmgmtLicenseInformation 2 }

clmgmtLicenseDeviceInfoEntry OBJECT-TYPE
    SYNTAX          ClmgmtLicenseDeviceInfoEntry
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "An entry in clmgmtLicenseDeviceInfoTable. Each entry
        contains device level licensing information for a device."
    INDEX           { entPhysicalIndex } 
    ::= { clmgmtLicenseDeviceInfoTable 1 }

ClmgmtLicenseDeviceInfoEntry ::= SEQUENCE {
        clmgmtDefaultLicenseStore Unsigned32
}

clmgmtDefaultLicenseStore OBJECT-TYPE
    SYNTAX          Unsigned32 (1..4294967295 )
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the clmgmtLicenseStoreIndex of
        default store in the device. There will be only one
        default license store per device. If no license store
        is specified during license install, this default license
        store will be used." 
    ::= { clmgmtLicenseDeviceInfoEntry 1 }
 

-- License Info Table

clmgmtLicenseInfoTable OBJECT-TYPE
    SYNTAX          SEQUENCE OF ClmgmtLicenseInfoEntry 
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This table contains information about all the licenses
        installed on the device."
    ::= { clmgmtLicenseInformation 3 }

clmgmtLicenseInfoEntry OBJECT-TYPE
    SYNTAX          ClmgmtLicenseInfoEntry
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "An entry in clmgmtLicenseInfoTable. Each entry contains
        information about a license installed on the device. This
        entry gets created when a license is installed successfully.
        Management application can not create these entries directly, but
        will do so indirectly by executing license install action.
        Some of these entries may already exist that correspond to
        demo licenses even before management application installs any
        licenses."
    INDEX           {
                        entPhysicalIndex,
                        clmgmtLicenseStoreUsed,
                        clmgmtLicenseIndex
                    } 
    ::= { clmgmtLicenseInfoTable 1 }

ClmgmtLicenseInfoEntry ::= SEQUENCE {
        clmgmtLicenseStoreUsed               Unsigned32,
        clmgmtLicenseIndex                   ClmgmtLicenseIndex,
        clmgmtLicenseFeatureName             SnmpAdminString,
        clmgmtLicenseFeatureVersion          SnmpAdminString,
        clmgmtLicenseType                    INTEGER ,
        clmgmtLicenseCounted                 TruthValue,
        clmgmtLicenseValidityPeriod          Unsigned32,
        clmgmtLicenseValidityPeriodRemaining Unsigned32,
        clmgmtLicenseExpiredPeriod           Unsigned32,
        clmgmtLicenseMaxUsageCount           Unsigned32,
        clmgmtLicenseUsageCountRemaining     Unsigned32,
        clmgmtLicenseEULAStatus              TruthValue,
        clmgmtLicenseComments                SnmpAdminString,
        clmgmtLicenseStatus                  INTEGER 
}

clmgmtLicenseStoreUsed OBJECT-TYPE
    SYNTAX          Unsigned32 (1..4294967295 )
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This object represents the license store that is used for
        storing this license. This object will have the same value
        as clmgmtLicenseStoreIndex in clmgmtLicenseStoreInfoEntry
        of the license store used." 
    ::= { clmgmtLicenseInfoEntry 1 }

clmgmtLicenseIndex OBJECT-TYPE
    SYNTAX          ClmgmtLicenseIndex
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This object uniquely identifies a license within
        the device." 
    ::= { clmgmtLicenseInfoEntry 2 }

clmgmtLicenseFeatureName OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..128))
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the name of the feature that is
        using or can use this license. A license can be used by
        only one feature. Examples of feature name are: 'IPBASE',
        'ADVIPSERVICE'." 
    ::= { clmgmtLicenseInfoEntry 3 }

clmgmtLicenseFeatureVersion OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..128))
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the version of the feature that is
        using or can use this license. Examples of feature version
        are: '1.0', '2.0'" 
    ::= { clmgmtLicenseInfoEntry 4 }

clmgmtLicenseType OBJECT-TYPE
    SYNTAX          INTEGER  {
                        demo(1),
                        extension(2),
                        gracePeriod(3),
                        permanent(4)
                    }
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object identifies type of license.

        demo(1)        - demo(evaluation license) license.
        extension(2)   - Extension(expiring) license.
        gracePeriod(3) - Grace period license.
        permanent(4)   - permanent license, the license has no
                         expiry date." 
    ::= { clmgmtLicenseInfoEntry 5 }

clmgmtLicenseCounted OBJECT-TYPE
    SYNTAX          TruthValue
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates whether the license is counted
        license.
        true(1)  - counted license
        false(2) - uncounted license" 
    ::= { clmgmtLicenseInfoEntry 6 }

clmgmtLicenseValidityPeriod OBJECT-TYPE
    SYNTAX          Unsigned32
    UNITS           "seconds"
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the time period the license is valid for.
        This object is applicable only if clmgmtLicenseType is demo(1),
        or extension(2) or gracePeriod(3). The object will return 0 for
        other license types." 
    ::= { clmgmtLicenseInfoEntry 7 }

clmgmtLicenseValidityPeriodRemaining OBJECT-TYPE
    SYNTAX          Unsigned32
    UNITS           "seconds"
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the time period remaining before
        the license expires. This object is applicable only if
        clmgmtLicenseType is demo(1), or extension(2) or
        gracePeriod(3). The object will contain 0 for other license
        types." 
    ::= { clmgmtLicenseInfoEntry 8 }

clmgmtLicenseExpiredPeriod OBJECT-TYPE
    SYNTAX          Unsigned32
    UNITS           "seconds"
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the elapsed time period since the license
        expired. This object is applicable only if clmgmtLicenseType
        is demo(1), or extension(2) or gracePeriod(3). Also, this
        value of this object will be valid only after the license
        expires. The object will return 0 for other license types
        or before the license expiry." 
    ::= { clmgmtLicenseInfoEntry 9 }

clmgmtLicenseMaxUsageCount OBJECT-TYPE
    SYNTAX          Unsigned32
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the maximum number of entities that
        can use this license. This object is applicable only if
        clmgmtLicenseCounted is true(1). The entity that is being
        counted can be anything and it depends on the licensable
        feature." 
    ::= { clmgmtLicenseInfoEntry 10 }

clmgmtLicenseUsageCountRemaining OBJECT-TYPE
    SYNTAX          Unsigned32
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the number of entities that can
        still use this license. This object is applicable only
        if clmgmtLicenseCounted is true(1)." 
    ::= { clmgmtLicenseInfoEntry 11 }

clmgmtLicenseEULAStatus OBJECT-TYPE
    SYNTAX          TruthValue
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates whether the user accepted
        End User License Agreement for this license.

        true(1)  - EULA accpeted
        false(2) - EULA not accepted" 
    ::= { clmgmtLicenseInfoEntry 12 }

clmgmtLicenseComments OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..255))
    MAX-ACCESS      read-write
    STATUS          current
    DESCRIPTION
        "This object represents the user modifiable comments
        about the license. This object is initially populated
        with comments from the license file." 
    ::= { clmgmtLicenseInfoEntry 13 }

clmgmtLicenseStatus OBJECT-TYPE
    SYNTAX          INTEGER  {
                        inactive(1),
                        notInUse(2),
                        inUse(3),
                        expiredInUse(4),
                        expiredNotInUse(5),
                        usageCountConsumed(6)
                    }
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object represents status of the license.

        inactive(1)           - license is installed, but
                                not active.
        notInUse(2)           - license is installed and
                                available for use.
        inUse(3)              - the license is being used (by
                                a feature).
        expiredInUse(4)       - license is expired but still
                                being held by the feature.
        expiredNotInUse(5)    - license is expired and not being
                                held by any feature.
        usageCountConsumed(6) - number of entities using this
                                licenses has reached the allowed
                                limit, no new entities are allowed
                                to use this license." 
    ::= { clmgmtLicenseInfoEntry 14 }
 

-- Licensable features information table.

clmgmtLicensableFeatureTable OBJECT-TYPE
    SYNTAX          SEQUENCE OF ClmgmtLicensableFeatureEntry 
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This table contains list of licensable features in the
        image. All the licensable features will have an entry each
        in this table irrespective of whether they are using any
        licenses currently. Entries in this table are created by
        the agent one for each licensable feature in the image.
        These entries remain in the table permanently and can not
        be deleted. Management application can not create or delete
        entries from this table."
    ::= { clmgmtLicenseInformation 4 }

clmgmtLicensableFeatureEntry OBJECT-TYPE
    SYNTAX          ClmgmtLicensableFeatureEntry
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "An entry in clmgmtLicensableFeatureTable. Each entry represents
        a licensable feature."
    INDEX           {
                        entPhysicalIndex,
                        clmgmtFeatureIndex
                    } 
    ::= { clmgmtLicensableFeatureTable 1 }

ClmgmtLicensableFeatureEntry ::= SEQUENCE {
        clmgmtFeatureIndex                   Unsigned32,
        clmgmtFeatureName                    SnmpAdminString,
        clmgmtFeatureVersion                 SnmpAdminString,
        clmgmtFeatureValidityPeriodRemaining Unsigned32,
        clmgmtFeatureWhatIsCounted           SnmpAdminString
}

clmgmtFeatureIndex OBJECT-TYPE
    SYNTAX          Unsigned32 (1..4294967295 )
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This object uniquely identifies a licensable feature in
        the device." 
    ::= { clmgmtLicensableFeatureEntry 1 }

clmgmtFeatureName OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..128))
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the name of the licensable feature
        in the device. Examples of feature names are: 'IPBASE',
        'ADVIPSERVICE'" 
    ::= { clmgmtLicensableFeatureEntry 2 }

clmgmtFeatureVersion OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..32))
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the version of the licensable
        feature in the device. Examples of feature versions
        are: '1.0' or '2.0'" 
    ::= { clmgmtLicensableFeatureEntry 3 }

clmgmtFeatureValidityPeriodRemaining OBJECT-TYPE
    SYNTAX          Unsigned32
    UNITS           "seconds"
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the time period remaining before
        the feature's license expires. This object is applicable
        only if clmgmtLicenseType of the license used by this
        feature is demo(1), or extension(2) or gracePeriod(3).

        The object will contain 0 if other types of license is used
        or if the feature does not use any license. If the
        feature is using multiple licenses, this period will
        represent the cumulative period remaining from all the
        licenses used by this feature." 
    ::= { clmgmtLicensableFeatureEntry 4 }

clmgmtFeatureWhatIsCounted OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..128))
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object represents the entity that is being counted
        by this feature. Examples of entities are IP Phones, number
        of sessions etc. This object is only applicable for
        features that use counting licenses. For other features,
        this object will return empty string." 
    ::= { clmgmtLicensableFeatureEntry 5 }
 


-- MIB objects for exporting device credentials

clmgmtNextFreeDevCredExportActionIndex OBJECT-TYPE
    SYNTAX          Unsigned32
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object contains appropriate value for
        clmgmtDevCredExportActionIndex that can be used to create
        an entry in clmgmtDevCredExportActionTable. The management
        application should read this object first and then use this
        as the value for clmgmtDevCredExportActionIndex to avoid
        collisions when creating entries in
        clmgmtDevCredExportActionTable. Following this approach does
        not guarantee collision free row creation, but will reduce
        the probability. The collision will happen if two
        management applications read this object at the same time and
        attempt to create an entry with this value at the same time.
        In this case, the management application whose request is
        processed after the first request will get an error and the
        process of reading this object and entry creation needs to be
        repeated." 
    ::= { clmgmtLicenseDeviceInformation 1 }
-- Table for triggering action to export device credentials.

clmgmtDevCredExportActionTable OBJECT-TYPE
    SYNTAX          SEQUENCE OF ClmgmtDevCredExportActionEntry 
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "A table for triggering device credentials export action.
        Management application must create this entry to trigger the
        export of device credentials from the device to a file.

        Once the request completes, the management application should
        retrieve the values of the objects of interest, and then
        delete the entry.  In order to prevent old entries from
        clogging the table, entries will be aged out, but an entry
        will never be deleted within 5 minutes of completion."
    ::= { clmgmtLicenseDeviceInformation 2 }

clmgmtDevCredExportActionEntry OBJECT-TYPE
    SYNTAX          ClmgmtDevCredExportActionEntry
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "An entry for each device credential export action that
        is being executed or was executed recently. The management
        application triggers the export by creating an entry in this
        table. This can be done in the following 2 methods

        1. CREATE-AND-GO method
            Management application sets clmgmtDevCredExportActionStatus
            to createAndGo(4) and all other required objects to valid
            values in a single SNMP SET request. If all the values
            are valid, the device creates the entry and executes the
            action. If the SET request fails, the entry will not be
            created.
        2. CREATE-AND-WAIT method
            Management application sets clmgmtDevCredExportActionStatus to
            createAndWait(5) to create an entry. Management application
            can set all other required objects to valid
            values in more than one SNMP SET request. If SET request
            for any of the objects fails, management application can set
            just only that object. Once all the required objects
            are set to valid values, management application triggers action
            execution by setting clmgmtDevCredExportActionStatus to
            active(1).

        To stop the action from being executed, the management application
        can delete the entry by setting clmgmtDevCredExportActionStatus
        to destroy(6) when clmgmtDevCredCommandState is pending(2).

        The status of action execution can be known by querying
        clmgmtDevCredCommandState. If the action is still in
        pending(2) or inProgress(3), the management application need to
        check back again after few seconds. Once the action completes
        and if status of the action is failed(6), the reason for
        failure can be retrieved from clmgmtDevCredCommandFailCause.

        Entry can be deleted except when clmgmtLicenseAction is set
        to inProgress(3). All entries in this table are volatile
        and are cleared on agent reset."
    INDEX           { clmgmtDevCredExportActionIndex } 
    ::= { clmgmtDevCredExportActionTable 1 }

ClmgmtDevCredExportActionEntry ::= SEQUENCE {
        clmgmtDevCredExportActionIndex Unsigned32,
        clmgmtDevCredEntPhysicalIndex  PhysicalIndexOrZero,
        clmgmtDevCredTransferProtocol  ClmgmtLicenseTransferProtocol,
        clmgmtDevCredServerAddressType InetAddressType,
        clmgmtDevCredServerAddress     InetAddress,
        clmgmtDevCredServerUsername    SnmpAdminString,
        clmgmtDevCredServerPassword    SnmpAdminString,
        clmgmtDevCredExportFile        SnmpAdminString,
        clmgmtDevCredCommand           INTEGER ,
        clmgmtDevCredCommandState      ClmgmtLicenseActionState,
        clmgmtDevCredCommandFailCause  INTEGER ,
        clmgmtDevCredStorageType       StorageType,
        clmgmtDevCredRowStatus         RowStatus
}

clmgmtDevCredExportActionIndex OBJECT-TYPE
    SYNTAX          Unsigned32 (1..4294967295 )
    MAX-ACCESS      not-accessible
    STATUS          current
    DESCRIPTION
        "This object uniquely identifies a row in
        clmgmtDevCredExportActionTable. The management application
        chooses this value by reading
        clmgmtNextFreeDevCredExportActionIndex while creating an
        entry in this table. If an entry already exists with this
        index, the creation of the entry will not continue and
        error will be returned. The management application should
        read the value of clmgmtNextFreeDevCredExportActionIndex
        again and retry with the new value for this object." 
    ::= { clmgmtDevCredExportActionEntry 1 }

clmgmtDevCredEntPhysicalIndex OBJECT-TYPE
    SYNTAX          PhysicalIndexOrZero
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object represents the entPhysicalIndex of the device
        for which the device credentials are being retrieved. This
        object is mainly used in devices where one device is acting
        as a master and rest of the devices as slaves. The master
        device is responsible for SNMP communication with the
        manager. Examples include stackable switches, devices with
        router processor and line cards.

        Note: This object need not be set if it is a stand alone
        device"
    DEFVAL          { 0 } 
    ::= { clmgmtDevCredExportActionEntry 2 }

clmgmtDevCredTransferProtocol OBJECT-TYPE
    SYNTAX          ClmgmtLicenseTransferProtocol
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the transfer protocol to be used when
        copying files as specified in the following objects.
        1. clmgmtDevCredExportFile
        ."
    DEFVAL          { none } 
    ::= { clmgmtDevCredExportActionEntry 3 }

clmgmtDevCredServerAddressType OBJECT-TYPE
    SYNTAX          InetAddressType
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the transport type of the
        address contained in clmgmtDevCredServerAddress object.
        This must be set when clmgmtDevCredTransferProtocol
        is not none(1) or local(2)."
    DEFVAL          { unknown } 
    ::= { clmgmtDevCredExportActionEntry 4 }

clmgmtDevCredServerAddress OBJECT-TYPE
    SYNTAX          InetAddress
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the the ip address of the server
        from which the files must be read or written to if 
        clmgmtDevCredTransferProtocol is not none(1) or local(2).

        All bits as 0s or 1s for clmgmtDevCredServerAddress are not
        allowed.

        The format of this address depends on the value of the
        clmgmtDevCredServerAddressType object"
    DEFVAL          { "" } 
    ::= { clmgmtDevCredExportActionEntry 5 }

clmgmtDevCredServerUsername OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..96))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the remote user name for accessing
        files via ftp, rcp, sftp or scp protocols. This object
        must be set when the clmgmtDevCredTransferProtocol is
        ftp(4), rcp(5), scp(7) or sftp(8). If
        clmgmtDevCredTransferProtocol is rcp(5), the remote
        username is sent as the server username in an rcp command
        request sent by the system to a remote rcp server."
    DEFVAL          { "" } 
    ::= { clmgmtDevCredExportActionEntry 6 }

clmgmtDevCredServerPassword OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..96))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the password used by ftp, sftp or
        scp for copying a file to/from an ftp/sftp/scp server. 
        This object must be set when the
        clmgmtDevCredTransferProtocol is ftp(4) or scp(7) or
        sftp(8). Reading it returns a zero-length string for 
        security reasons."
    DEFVAL          { "" } 
    ::= { clmgmtDevCredExportActionEntry 7 }

clmgmtDevCredExportFile OBJECT-TYPE
    SYNTAX          SnmpAdminString (SIZE  (0..255))
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object represents file where device credentials needs
        to be exported to." 
    ::= { clmgmtDevCredExportActionEntry 8 }

clmgmtDevCredCommand OBJECT-TYPE
    SYNTAX          INTEGER  {
                        noOp(1),
                        getDeviceCredentials(2)
                    }
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the the command to be executed.

        Command                          Remarks
        -------                          -------
        noOp(1)                         No operation will be
                                        performed.

        getDeviceCredentials(2)         Exports device credentials"
    DEFVAL          { noOp } 
    ::= { clmgmtDevCredExportActionEntry 9 }

clmgmtDevCredCommandState OBJECT-TYPE
    SYNTAX          ClmgmtLicenseActionState
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the state of the action that is
        executed as a result of setting clmgmtDevCredRowStatus
        to active(1)." 
    ::= { clmgmtDevCredExportActionEntry 10 }

clmgmtDevCredCommandFailCause OBJECT-TYPE
    SYNTAX          INTEGER  {
                        none(1),
                        unknownError(2),
                        transferProtocolNotSupported(3),
                        fileServerNotReachable(4),
                        unrecognizedEntPhysicalIndex(5),
                        invalidFile(6)
                    }
    MAX-ACCESS      read-only
    STATUS          current
    DESCRIPTION
        "This object indicates the the reason for device
        credentials export operation failure.

        The value of this object is valid only when
        clmgmtDevCredCommandState is failed(6).

        none(1)         - action execution has not started yet.
                          If the action is completed and the 
                          action is successful, then also
                          none(1) is returned to indicate that
                          there are no errors.
        unknownError(2) - reason for failure is unknown,
                          operation failed, no operation is
                          performed
        transferProtocolNotSupported(3) - clmgmtDevCredTransferProtocol
                                          given is not supported.
        fileServerNotReachable(4)       - file server is not reachable.
        unrecognizedEntPhysicalIndex(5) - entPhysicalIndex is not
                                          valid
        invalidFile(6)  - The target file specified is not valid." 
    ::= { clmgmtDevCredExportActionEntry 11 }

clmgmtDevCredStorageType OBJECT-TYPE
    SYNTAX          StorageType
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the storage type for this conceptual
        row. Conceptual rows having the value 'permanent' need not
        allow write-access to any columnar objects in the row."
    DEFVAL          { volatile } 
    ::= { clmgmtDevCredExportActionEntry 12 }

clmgmtDevCredRowStatus OBJECT-TYPE
    SYNTAX          RowStatus
    MAX-ACCESS      read-create
    STATUS          current
    DESCRIPTION
        "This object indicates the the status of this table entry.
        Once the entry status is set to active(1), the associated
        entry cannot be modified until the action completes
        (clmgmtDevCredCommandStatus is set to a value
        other than inProgress(3)). Once the action completes
        the only operation possible after this is to delete
        the row.

        clmgmtDevCredExportFile is a mandatory object to be
        set when creating this entry." 
    ::= { clmgmtDevCredExportActionEntry 13 }
 


-- Objects for enabling/disabling notifications

clmgmtLicenseUsageNotifEnable OBJECT-TYPE
    SYNTAX          TruthValue
    MAX-ACCESS      read-write
    STATUS          current
    DESCRIPTION
        "This object indicates whether the device should generate
        notifications related to usage of licenses."
    DEFVAL          { true } 
    ::= { clmgmtLicenseNotifObjects 1 }

clmgmtLicenseDeploymentNotifEnable OBJECT-TYPE
    SYNTAX          TruthValue
    MAX-ACCESS      read-write
    STATUS          current
    DESCRIPTION
        "This object indicates whether the device should generate
        notifications related to license deployment."
    DEFVAL          { true } 
    ::= { clmgmtLicenseNotifObjects 2 }

clmgmtLicenseErrorNotifEnable OBJECT-TYPE
    SYNTAX          TruthValue
    MAX-ACCESS      read-write
    STATUS          current
    DESCRIPTION
        "This object indicates whether the device should generate
        notifications related to error conditions in enforcing
        licensing."
    DEFVAL          { true } 
    ::= { clmgmtLicenseNotifObjects 3 }

-- Notifications

clmgmtLicenseExpired NOTIFICATION-TYPE
    OBJECTS         {
                        clmgmtFeatureName,
                        clmgmtFeatureVersion
                    }
    STATUS          current
    DESCRIPTION
        "This notification is sent, when a feature license
        expires. This notification will be sent continuously
        every week even after the expiry to alert the management
        application."
   ::= { ciscoLicenseMgmtMIBNotifs 1 }

clmgmtLicenseExpiryWarning NOTIFICATION-TYPE
    OBJECTS         {
                        clmgmtFeatureName,
                        clmgmtFeatureVersion,
                        clmgmtFeatureValidityPeriodRemaining
                    }
    STATUS          current
    DESCRIPTION
        "This notification is sent when a license is about to
        expire. This notification will go out multiple times.
        First notification goes out when expiry day is 4 weeks
        ahead, second notification when expiry day is 3 weeks
        ahead, third notification when expiry day is 2 weeks
        ahead. This notification will go out daily in the
        last week of license expiry."
   ::= { ciscoLicenseMgmtMIBNotifs 2 }

clmgmtLicenseUsageCountExceeded NOTIFICATION-TYPE
    OBJECTS         {
                        clmgmtLicenseFeatureName,
                        clmgmtLicenseFeatureVersion,
                        clmgmtLicenseMaxUsageCount,
                        clmgmtFeatureWhatIsCounted,
                        clmgmtLicenseComments
                    }
    STATUS          current
    DESCRIPTION
        "This notification is sent when clmgmtLicenseUsageCountRemaining
        has reached clmgmtLicenseMaxUsageCount for a counting license."
   ::= { ciscoLicenseMgmtMIBNotifs 3 }

clmgmtLicenseUsageCountAboutToExceed NOTIFICATION-TYPE
    OBJECTS         {
                        clmgmtLicenseFeatureName,
                        clmgmtLicenseFeatureVersion,
                        clmgmtLicenseMaxUsageCount,
                        clmgmtLicenseUsageCountRemaining,
                        clmgmtFeatureWhatIsCounted,
                        clmgmtLicenseComments
                    }
    STATUS          current
    DESCRIPTION
        "This notification is sent when clmgmtLicenseUsageCountRemaining
        has reached 80% of clmgmtLicenseMaxUsageCount for a counting
        license. This is a warning notification to the management
        application that very soon the maximum count will be reached
        and after that the device will not allow new entities to
        make use of this license."
   ::= { ciscoLicenseMgmtMIBNotifs 4 }

clmgmtLicenseInstalled NOTIFICATION-TYPE
    OBJECTS         {
                        clmgmtLicenseFeatureName,
                        clmgmtLicenseFeatureVersion,
                        clmgmtLicenseType,
                        clmgmtLicenseComments
                    }
    STATUS          current
    DESCRIPTION
        "This notification is sent when a license is installed
        successfully."
   ::= { ciscoLicenseMgmtMIBNotifs 5 }

clmgmtLicenseCleared NOTIFICATION-TYPE
    OBJECTS         {
                        clmgmtLicenseFeatureName,
                        clmgmtLicenseFeatureVersion,
                        clmgmtLicenseType,
                        clmgmtLicenseComments
                    }
    STATUS          current
    DESCRIPTION
        "This notification is sent when a license is cleared
        successfully."
   ::= { ciscoLicenseMgmtMIBNotifs 6 }

clmgmtLicenseRevoked NOTIFICATION-TYPE
    OBJECTS         {
                        clmgmtLicenseFeatureName,
                        clmgmtLicenseFeatureVersion,
                        clmgmtLicenseType,
                        clmgmtLicenseComments
                    }
    STATUS          current
    DESCRIPTION
        "This notification is sent when a license is revoked
        successfully."
   ::= { ciscoLicenseMgmtMIBNotifs 7 }

clmgmtLicenseEULAAccepted NOTIFICATION-TYPE
    OBJECTS         {
                        clmgmtFeatureName,
                        clmgmtFeatureVersion
                    }
    STATUS          current
    DESCRIPTION
        "This notification is sent when a user accepts End User
        License Agreement (EULA) for a license."
   ::= { ciscoLicenseMgmtMIBNotifs 8 }

clmgmtLicenseNotEnforced NOTIFICATION-TYPE
    OBJECTS         {
                        clmgmtFeatureName,
                        clmgmtFeatureVersion
                    }
    STATUS          current
    DESCRIPTION
        "This notification is sent when a license does not
        exist for a feature, but the feature is a mandatory
        feature and it should run. This notification will be
        sent out periodically to indicate that there is no
        license installed for this feature and it needs to
        be done as soon as possible."
   ::= { ciscoLicenseMgmtMIBNotifs 9 }
-- Conformance

ciscoLicenseMgmtCompliances  OBJECT IDENTIFIER
    ::= { ciscoLicenseMgmtMIBConform 1 }

ciscoLicenseMgmtGroups  OBJECT IDENTIFIER
    ::= { ciscoLicenseMgmtMIBConform 2 }


ciscoLicenseMgmtCompliance MODULE-COMPLIANCE
    STATUS          current
    DESCRIPTION
        "Compliance statement for Cisco license mgmt MIB."
    MODULE          -- this module
    MANDATORY-GROUPS {
                        clmgmtLicenseDeploymentGroup,
                        clmgmtLicenseDeviceInformationGroup,
                        clmgmtLicenseInformationGroup,
                        clmgmtLicensableFeatureInformationGroup,
                        clmgmtLicenseDevCredGroup,
                        clmgmtLicenseNotificationEnableGroup,
                        clmgmtLicenseUsageNotifGroup,
                        clmgmtLicenseDeploymentNotifGroup,
                        clmgmtLicenseErrorNotifGroup
                    }

    GROUP           clmgmtLicenseStoreInformationGroup
    DESCRIPTION
        "This group is mandatory for all devices where
        multiple license stores are supported."
    ::= { ciscoLicenseMgmtCompliances 1 }

-- Units of Conformance

clmgmtLicenseDeploymentGroup OBJECT-GROUP
    OBJECTS         {
                        clmgmtNextFreeLicenseActionIndex,
                        clmgmtLicenseActionEntPhysicalIndex,
                        clmgmtLicenseActionTransferProtocol,
                        clmgmtLicenseServerAddressType,
                        clmgmtLicenseServerAddress,
                        clmgmtLicenseServerUsername,
                        clmgmtLicenseServerPassword,
                        clmgmtLicenseFile,
                        clmgmtLicenseStore,
                        clmgmtLicenseActionLicenseIndex,
                        clmgmtLicensePermissionTicketFile,
                        clmgmtLicenseRehostTicketFile,
                        clmgmtLicenseBackupFile,
                        clmgmtLicenseStopOnFailure,
                        clmgmtLicenseAction,
                        clmgmtLicenseActionState,
                        clmgmtLicenseJobQPosition,
                        clmgmtLicenseActionFailCause,
                        clmgmtLicenseActionStorageType,
                        clmgmtLicenseActionRowStatus,
                        clmgmtLicenseIndivActionState,
                        clmgmtLicenseIndivActionFailCause,
                        clmgmtLicenseAcceptEULA,
                        clmgmtLicenseEULAFile
                    }
    STATUS          current
    DESCRIPTION
        "A collection of objects for performing license deployment
        i.e., license installation, clear and revoke"
    ::= { ciscoLicenseMgmtGroups 1 }

clmgmtLicenseStoreInformationGroup OBJECT-GROUP
    OBJECTS         {
                        clmgmtLicenseStoreName,
                        clmgmtLicenseStoreTotalSize,
                        clmgmtLicenseStoreSizeRemaining
                    }
    STATUS          current
    DESCRIPTION
        "A collection of objects that provide information about
        license storages in the device."
    ::= { ciscoLicenseMgmtGroups 2 }

clmgmtLicenseDeviceInformationGroup OBJECT-GROUP
    OBJECTS         { clmgmtDefaultLicenseStore }
    STATUS          current
    DESCRIPTION
        "A collection of objects that provide information about
        device level licensing support information in the device."
    ::= { ciscoLicenseMgmtGroups 3 }

clmgmtLicenseInformationGroup OBJECT-GROUP
    OBJECTS         {
                        clmgmtLicenseFeatureName,
                        clmgmtLicenseFeatureVersion,
                        clmgmtLicenseType,
                        clmgmtLicenseCounted,
                        clmgmtLicenseValidityPeriod,
                        clmgmtLicenseValidityPeriodRemaining,
                        clmgmtLicenseExpiredPeriod,
                        clmgmtLicenseMaxUsageCount,
                        clmgmtLicenseUsageCountRemaining,
                        clmgmtLicenseEULAStatus,
                        clmgmtLicenseComments,
                        clmgmtLicenseStatus
                    }
    STATUS          current
    DESCRIPTION
        "A collection of objects that provide information about
        licenses and its state."
    ::= { ciscoLicenseMgmtGroups 4 }

clmgmtLicensableFeatureInformationGroup OBJECT-GROUP
    OBJECTS         {
                        clmgmtFeatureName,
                        clmgmtFeatureVersion,
                        clmgmtFeatureValidityPeriodRemaining,
                        clmgmtFeatureWhatIsCounted
                    }
    STATUS          current
    DESCRIPTION
        "A collection of objects that provide information about
        licensable features in the software image."
    ::= { ciscoLicenseMgmtGroups 5 }

clmgmtLicenseDevCredGroup OBJECT-GROUP
    OBJECTS         {
                        clmgmtNextFreeDevCredExportActionIndex,
                        clmgmtDevCredEntPhysicalIndex,
                        clmgmtDevCredTransferProtocol,
                        clmgmtDevCredServerAddressType,
                        clmgmtDevCredServerAddress,
                        clmgmtDevCredServerUsername,
                        clmgmtDevCredServerPassword,
                        clmgmtDevCredExportFile,
                        clmgmtDevCredCommand,
                        clmgmtDevCredCommandState,
                        clmgmtDevCredCommandFailCause,
                        clmgmtDevCredStorageType,
                        clmgmtDevCredRowStatus
                    }
    STATUS          current
    DESCRIPTION
        "A collection of objects for exporting device credentials
        from the device."
    ::= { ciscoLicenseMgmtGroups 6 }

clmgmtLicenseNotificationEnableGroup OBJECT-GROUP
    OBJECTS         {
                        clmgmtLicenseUsageNotifEnable,
                        clmgmtLicenseDeploymentNotifEnable,
                        clmgmtLicenseErrorNotifEnable
                    }
    STATUS          current
    DESCRIPTION
        "A collection of objects for controlling
        (enabling/disabling) license notifications to a management
        application."
    ::= { ciscoLicenseMgmtGroups 7 }

clmgmtLicenseUsageNotifGroup NOTIFICATION-GROUP
   NOTIFICATIONS    {
                        clmgmtLicenseExpired,
                        clmgmtLicenseExpiryWarning,
                        clmgmtLicenseUsageCountExceeded,
                        clmgmtLicenseUsageCountAboutToExceed
                    }
    STATUS          current
    DESCRIPTION
        "A collection of notifications related to license usage."
    ::= { ciscoLicenseMgmtGroups 8 }

clmgmtLicenseDeploymentNotifGroup NOTIFICATION-GROUP
   NOTIFICATIONS    {
                        clmgmtLicenseInstalled,
                        clmgmtLicenseCleared,
                        clmgmtLicenseRevoked,
                        clmgmtLicenseEULAAccepted
                    }
    STATUS          current
    DESCRIPTION
        "A collection of notifications related to license deployment."
    ::= { ciscoLicenseMgmtGroups 9 }

clmgmtLicenseErrorNotifGroup NOTIFICATION-GROUP
   NOTIFICATIONS    { clmgmtLicenseNotEnforced }
    STATUS          current
    DESCRIPTION
        "A collection of notifications related to license errors."
    ::= { ciscoLicenseMgmtGroups 10 }

END