net-snmp 3.16.1 → 3.18.0

package/index.js

@@ -587,81 +587,127 @@ function writeVarbinds (buffer, varbinds) {
 
 const ObjectTypeUtil = {};
 
-ObjectTypeUtil.castSetValue = function (type, value) {
+ObjectTypeUtil.castSetValue = function (type, value, constraints) {
 
 	switch (type) {
-		case ObjectType.Boolean:
+
+		case ObjectType.Boolean: {
 			return !! value;
+		}
 
 		case ObjectType.Integer:
+		case ObjectType.Integer32: {
 			if ( typeof value != "number" && typeof value != "string" ) {
 				throw new Error("Invalid Integer", value);
 			}
-			return typeof value == "number" ? value : parseInt(value, 10);
+			const parsedValue = typeof value == "number" ? value : parseInt(value, 10);
+			if ( isNaN(parsedValue) ) {
+				throw new Error("Invalid Integer", value);
+			}
+			if ( constraints && ObjectTypeUtil.doesIntegerMeetConstraints (parsedValue, constraints) ) {
+				throw new Error("Integer does not meet constraints", value);
+			}
+			return parsedValue;
+		}
 
-		case ObjectType.OctetString:
-			if ( value instanceof Buffer) {
-				return value.toString();
-			} else if ( typeof value != "string" ) {
+		case ObjectType.OctetString: {
+			if ( ! value instanceof Buffer && typeof value != "string" ) {
 				throw new Error("Invalid OctetString", value);
+			}
+			if ( constraints && ObjectTypeUtil.doesStringMeetConstraints (value, constraints) ) {
+				throw new Error("OctetString does not meet constraints", value);
+			}
+			if ( value instanceof Buffer ) {
+				return value.toString();
 			} else {
 				return value;
 			}
+		}
 
-		case ObjectType.OID:
+		case ObjectType.OID: {
 			if ( typeof value != "string" || ! value.match(/^([0-9]+)(\.[0-9]+)+$/) ) {
 				throw new Error("Invalid OID", value);
 			}
 			return value;
+		}
 
 		case ObjectType.Counter:
-		case ObjectType.Counter64:
+		case ObjectType.Counter32:
+		case ObjectType.Gauge:
+		case ObjectType.Gauge32:
+		case ObjectType.Unsigned32:
+		case ObjectType.Counter64: {
 			// Counters should be initialized to 0 (RFC2578, end of section 7.9)
 			// We'll do so.
 			return 0;
+		}
 
-		case ObjectType.IpAddress:
+		case ObjectType.IpAddress: {
 			// A 32-bit internet address represented as OCTET STRING of length 4
 			var bytes = value.split(".");
 			if ( typeof value != "string" || bytes.length != 4 ) {
 				throw new Error("Invalid IpAddress", value);
 			}
 			return value;
+		}
 
-		default :
+		default: {
 			// Assume the caller knows what he's doing
 			return value;
+		}
 	}
 
 };
 
-ObjectTypeUtil.isValid = function (type, value) {
+ObjectTypeUtil.isValid = function (type, value, constraints) {
 
 	switch (type) {
 		case ObjectType.Boolean: {
 			return typeof value == "boolean";
 		}
-		case ObjectType.Integer: {
+		case ObjectType.Integer:
+		case ObjectType.Integer32: {
 			// Allow strings that can be parsed as integers
-			const parsed = Number(value);
-			return ! isNaN (parsed) && Number.isInteger (parsed) && parsed >= MIN_SIGNED_INT32 && parsed <= MAX_SIGNED_INT32;
+			const parsedValue = Number(value);
+			if ( isNaN(parsedValue) || ! Number.isInteger(parsedValue) || parsedValue < MIN_SIGNED_INT32 || parsedValue > MAX_SIGNED_INT32 ) {
+				return false;
+			}
+			if ( constraints && ObjectTypeUtil.doesIntegerMeetConstraints (parsedValue, constraints) ) {
+				return false;
+			}
+			return true;
 		}
 		case ObjectType.OctetString: {
 			// Allow string or buffer
-			return typeof value == "string" || value instanceof Buffer;
+			if ( typeof value != "string" && ! (value instanceof Buffer) ) {
+				return false;
+			}
+			if ( constraints && ObjectTypeUtil.doesStringMeetConstraints (value, constraints) ) {
+				return false;
+			}
+			return true;
 		}
 		case ObjectType.OID: {
 			return typeof value == "string" && value.match (/^([0-9]+)(\.[0-9]+)+$/);
 		}
-		case ObjectType.Counter: {
+		case ObjectType.Counter:
+		case ObjectType.Counter32:
+		case ObjectType.Gauge:
+		case ObjectType.Gauge32:
+		case ObjectType.Unsigned32: {
 			// Allow strings that can be parsed as integers
 			const parsed = Number(value);
 			return ! isNaN (parsed) && Number.isInteger (parsed) && parsed >= 0 && parsed <= MAX_UNSIGNED_INT32;
 		}
 		case ObjectType.Counter64: {
-			// Allow strings that can be parsed as integers
-			const parsed = Number(value);
-			return ! isNaN (parsed) && Number.isInteger (parsed) && parsed >= 0;
+			if ( value instanceof Buffer ) {
+				// Allow buffers of 8 bytes - should do further check to see if it translates to a valid integer
+				return value.length == 8;
+			} else {
+				// Allow strings that can be parsed as integers
+				const parsed = Number(value);
+				return ! isNaN (parsed) && Number.isInteger (parsed) && parsed >= 0;
+			}
 		}
 		case ObjectType.IpAddress: {
 			const octets = value.split(".");
@@ -686,6 +732,57 @@ ObjectTypeUtil.isValid = function (type, value) {
 
 };
 
+ObjectTypeUtil.doesIntegerMeetConstraints = function (value, constraints) {
+
+	if ( ! constraints ) {
+		return true;
+	}
+
+	if ( constraints.enumeration ) {
+		if ( constraints.enumeration[value] ) {
+			return true;
+		} else {
+			return false;
+		}
+	} else if ( constraints.ranges ) {
+		for ( const range of constraints.ranges ) {
+			const min = "min" in range ? range.min : Number.MIN_SAFE_INTEGER;
+			const max = "max" in range ? range.max : Number.MAX_SAFE_INTEGER;
+			if ( value >= min && value <= max ) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	return true;
+};
+
+ObjectTypeUtil.doesStringMeetConstraints = function (value, constraints) {
+
+	if ( ! constraints ) {
+		return true;
+	}
+
+	if ( constraints.sizes ) {
+		// if size is constrained, value must have a length property
+		if ( value.length === undefined ) {
+			return false;
+		}
+		const len = value.length;
+		for ( const range of constraints.sizes ) {
+			const min = "min" in range ? range.min : Number.MIN_SAFE_INTEGER;
+			const max = "max" in range ? range.max : Number.MAX_SAFE_INTEGER;
+			if ( len >= min && len <= max ) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	return true;
+};
+
 /*****************************************************************************
  ** PDU class definitions
  **/
@@ -3760,53 +3857,17 @@ MibNode.prototype.getConstraintsFromProvider = function () {
 	}
 };
 
-MibNode.prototype.setValue = function (newValue) {
-	var len;
-	var min;
-	var max;
-	var range;
-	var found = false;
-	var constraints = this.getConstraintsFromProvider ();
-	if ( ! constraints ) {
-		this.value = newValue;
+MibNode.prototype.setValue = function (typeFromSet, valueFromSet) {
+	const constraints = this.getConstraintsFromProvider ();
+	try {
+		const castValue = ObjectTypeUtil.castSetValue (typeFromSet, valueFromSet, constraints);
+		this.value = castValue;
 		return true;
+	} catch (error) {
+		console.error ("Error setting value: " + error.message);
+		return false;
 	}
-	if ( constraints.enumeration ) {
-		if ( ! constraints.enumeration[newValue] ) {
-			return false;
-		}
-	} else if ( constraints.ranges ) {
-		for ( range of constraints.ranges ) {
-			min = "min" in range ? range.min : Number.MIN_SAFE_INTEGER;
-			max = "max" in range ? range.max : Number.MAX_SAFE_INTEGER;
-			if ( newValue >= min && newValue <= max ) {
-				found = true;
-				break;
-			}
-		}
-		if ( ! found ) {
-			return false;
-		}
-	} else if ( constraints.sizes ) {
-		// if size is constrained, value must have a length property
-		if ( newValue.length === undefined ) {
-			return false;
-		}
-		len = newValue.length;
-		for ( range of constraints.sizes ) {
-			min = "min" in range ? range.min : Number.MIN_SAFE_INTEGER;
-			max = "max" in range ? range.max : Number.MAX_SAFE_INTEGER;
-			if ( len >= min && len <= max ) {
-				found = true;
-				break;
-			}
-		}
-		if ( ! found ) {
-			return false;
-		}
-	}
-	this.value = newValue;
-	return true;
+
 };
 
 MibNode.prototype.getInstanceNodeForTableRow = function () {
@@ -3964,10 +4025,11 @@ MibNode.oidIsDescended = function (oid, ancestor) {
 	return isAncestor;
 };
 
-var Mib = function () {
+var Mib = function (options) {
 	var providersByOid;
 	this.root = new MibNode ([], null);
 	this.providerNodes = {};
+	this.options = options;
 
 	// this.providers will be modified throughout this code.
 	// Keep this.providersByOid in sync with it
@@ -4073,8 +4135,13 @@ Mib.prototype.addProviderToNode = function (provider) {
 	return node;
 };
 
-Mib.prototype.getColumnFromProvider = function (provider, indexEntry) {
-	var column = null;
+Mib.prototype.getColumnForColumnNumberFromTableProvider = function (provider, columnNumber) {
+	const column = provider.tableColumns.find (column => column.number == columnNumber );
+	return column;
+};
+
+Mib.prototype.getColumnForIndexEntryFromTableProvider = function (provider, indexEntry) {
+	let column = null;
 	if ( indexEntry.columnName ) {
 		column = provider.tableColumns.filter (column => column.name == indexEntry.columnName )[0];
 	} else if ( indexEntry.columnNumber !== undefined && indexEntry.columnNumber !== null  ) {
@@ -4091,16 +4158,16 @@ Mib.prototype.populateIndexEntryFromColumn = function (localProvider, indexEntry
 	}
 	if ( indexEntry.foreign ) {
 		// Explicit foreign table is first to search
-		column = this.getColumnFromProvider (this.providers[indexEntry.foreign], indexEntry);
+		column = this.getColumnForIndexEntryFromTableProvider (this.providers[indexEntry.foreign], indexEntry);
 	} else {
 		// If foreign table isn't given, search the local table next
-		column = this.getColumnFromProvider (localProvider, indexEntry);
+		column = this.getColumnForIndexEntryFromTableProvider (localProvider, indexEntry);
 		if ( ! column ) {
 			// as a last resort, try to find the column in a foreign table
 			tableProviders = Object.values(this.providers).
 					filter ( prov => prov.type == MibProviderType.Table );
 			for ( var provider of tableProviders ) {
-				column = this.getColumnFromProvider (provider, indexEntry);
+				column = this.getColumnForIndexEntryFromTableProvider (provider, indexEntry);
 				if ( column ) {
 					indexEntry.foreign = provider.name;
 					break;
@@ -4131,7 +4198,13 @@ Mib.prototype.populateIndexEntryFromColumn = function (localProvider, indexEntry
 
 Mib.prototype.registerProvider = function (provider) {
 	this.providers[provider.name] = provider;
-	if ( provider.type == MibProviderType.Table ) {
+	if ( provider.type == MibProviderType.Scalar ) {
+		if ( this.options?.addScalarDefaultsOnRegistration ) {
+			if ( provider.defVal ) {
+				this.setScalarValue (provider.name, provider.defVal);
+			}
+		}
+	} else if ( provider.type == MibProviderType.Table ) {
 		if ( provider.tableAugments ) {
 			if ( provider.tableAugments == provider.name ) {
 				throw new Error ("Table " + provider.name + " cannot augment itself");
@@ -4278,7 +4351,7 @@ Mib.prototype.setScalarValue = function (scalarName, newValue) {
 		instanceNode = this.lookup (instanceAddress);
 		instanceNode.valueType = provider.scalarType;
 	}
-	const isValidValue = ObjectTypeUtil.isValid(instanceNode.valueType, newValue);
+	const isValidValue = ObjectTypeUtil.isValid(instanceNode.valueType, newValue, provider.constraints);
 	if ( ! isValidValue ) {
 		throw new TypeError(`Invalid value for ${scalarName} of type ${instanceNode.valueType}: ${newValue}`);
 	}
@@ -4415,13 +4488,13 @@ Mib.prototype.validateTableRow = function (table, row) {
 	const tableIndex = provider.tableIndex;
 	const foreignIndexOffset = tableIndex.filter ( indexPart => indexPart.foreign ).length;
 	for ( let i = 0; i < provider.tableColumns.length ; i++ ) {
-		const column = provider.tableColumns[i];
-		const isColumnIndex = tableIndex.some ( indexPart => indexPart.columnNumber == column.number );
-		if ( ! isColumnIndex || ! (column.maxAccess === MaxAccess['not-accessible'] || column.maxAccess === MaxAccess['accessible-for-notify']) ) {
+		const providerColumn = provider.tableColumns[i];
+		const isColumnIndex = tableIndex.some ( indexPart => indexPart.columnNumber == providerColumn.number );
+		if ( ! isColumnIndex || ! (providerColumn.maxAccess === MaxAccess['not-accessible'] || providerColumn.maxAccess === MaxAccess['accessible-for-notify']) ) {
 			const rowValueIndex = foreignIndexOffset + i;
-			const isValidValue = ObjectTypeUtil.isValid(column.type, row[rowValueIndex]);
+			const isValidValue = ObjectTypeUtil.isValid(providerColumn.type, row[rowValueIndex], providerColumn.constraints);
 			if ( ! isValidValue ) {
-				throw new TypeError(`Invalid value for ${table} column ${column.name} (index ${rowValueIndex}): ${row[rowValueIndex]} (in row [${row}])`);
+				throw new TypeError(`Invalid value for ${table} column ${providerColumn.name} (index ${rowValueIndex}): ${row[rowValueIndex]} (in row [${row}])`);
 			}
 		}
 	}
@@ -4461,11 +4534,7 @@ Mib.prototype.addTableRow = function (table, row) {
 };
 
 Mib.prototype.getTableColumnDefinitions = function (table) {
-	var providerNode;
-	var provider;
-
-	providerNode = this.getProviderNodeForTable (table);
-	provider = providerNode.provider;
+	const provider = this.providers[table];
 	return provider.tableColumns;
 };
 
@@ -4574,7 +4643,8 @@ Mib.prototype.setTableSingleCell = function (table, columnNumber, rowIndex, valu
 	const instanceAddress = this.getTableRowInstanceFromRowIndex (provider, rowIndex);
 	const columnNode = providerNode.children[columnNumber];
 	const instanceNode = columnNode.getInstanceNodeForTableRowIndex (instanceAddress);
-	const isValidValue = ObjectTypeUtil.isValid(instanceNode.valueType, value);
+	const providerColumn = this.getColumnForColumnNumberFromTableProvider (provider, columnNumber);
+	const isValidValue = ObjectTypeUtil.isValid(instanceNode.valueType, value, providerColumn?.constraints);
 	if ( ! isValidValue ) {
 		throw new TypeError(`Invalid value for ${table} column ${columnNumber} of type ${instanceNode.valueType}: ${value}`);
 	}
@@ -4699,8 +4769,8 @@ Mib.getSubOidFromBaseOid = function (oid, base) {
 	return oid.substring (base.length + 1);
 };
 
-Mib.create = function () {
-	return new Mib (); 
+Mib.create = function (options) {
+	return new Mib (options);
 };
 
 var MibRequest = function (requestDefinition) {
@@ -5287,10 +5357,10 @@ Agent.prototype.request = function (socket, requestMessage, rinfo) {
 
 						} else {
 							// No special handling required. Just save the new value.
-							let setResult = mibRequests[savedIndex].instanceNode.setValue (ObjectTypeUtil.castSetValue (
+							const setResult = mibRequests[savedIndex].instanceNode.setValue (
 								requestPdu.varbinds[savedIndex].type,
 								requestPdu.varbinds[savedIndex].value
-							));
+							);
 							if ( ! setResult ) {
 								if ( typeof responsePdu.errorStatus == "undefined" || responsePdu.errorStatus == ErrorStatus.NoError ) {
 									responsePdu.errorStatus = ErrorStatus.WrongValue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "net-snmp",
-  "version": "3.16.1",
+  "version": "3.18.0",
   "description": "JavaScript implementation of the Simple Network Management Protocol (SNMP)",
   "main": "index.js",
   "directories": {

package/test/TEST-MIB.mib

@@ -0,0 +1,210 @@
+TEST-MIB DEFINITIONS ::= BEGIN
+
+IMPORTS
+    MODULE-IDENTITY, OBJECT-TYPE, Integer32, IpAddress, TimeTicks
+        FROM SNMPv2-SMI
+    DisplayString, TEXTUAL-CONVENTION
+        FROM SNMPv2-TC;
+
+testMIB MODULE-IDENTITY
+    LAST-UPDATED "202501060000Z"
+    ORGANIZATION "Example Organization"
+    CONTACT-INFO "support@example.org"
+    DESCRIPTION "A test MIB for node-net-snmp library"
+    REVISION "202501060000Z"
+    DESCRIPTION "Initial version of the test MIB"
+    ::= { enterprises 99999 }
+
+-- Scalars
+testScalarInteger OBJECT-TYPE
+    SYNTAX Integer32
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "An integer scalar"
+    ::= { testMIB 1 }
+
+testScalarEnum OBJECT-TYPE
+    SYNTAX INTEGER { up(1), down(2), unknown(3) }
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "An integer scalar with enumerated type"
+    ::= { testMIB 2 }
+
+testScalarRange OBJECT-TYPE
+    SYNTAX Integer32 (1..100)
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "An integer scalar with a range constraint"
+    ::= { testMIB 3 }
+
+testScalarString OBJECT-TYPE
+    SYNTAX DisplayString
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "A string scalar"
+    ::= { testMIB 4 }
+
+testScalarStringSize OBJECT-TYPE
+    SYNTAX OCTET STRING (SIZE(1..32))
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "A string scalar with a size constraint"
+    ::= { testMIB 5 }
+
+testScalarIntegerDefval OBJECT-TYPE
+    SYNTAX Integer32
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "An integer scalar"
+    DEFVAL { 49 }
+    ::= { testMIB 6 }
+
+
+-- Tables
+testTable1 OBJECT-TYPE
+    SYNTAX SEQUENCE OF TestEntry1
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "A table with a single integer index"
+    ::= { testMIB 10 }
+
+testEntry1 OBJECT-TYPE
+    SYNTAX TestEntry1
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "An entry in testTable1"
+    INDEX { testTable1Index }
+    ::= { testTable1 1 }
+
+TestEntry1 ::= SEQUENCE {
+    testTable1Index Integer32,
+    testTable1Value DisplayString
+}
+
+testTable1Index OBJECT-TYPE
+    SYNTAX Integer32
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "Index for testTable1"
+    ::= { testEntry1 1 }
+
+testTable1Value OBJECT-TYPE
+    SYNTAX DisplayString
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "Value in testTable1"
+    ::= { testEntry1 2 }
+
+testTable2 OBJECT-TYPE
+    SYNTAX SEQUENCE OF TestEntry2
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "A table with a string index"
+    ::= { testMIB 11 }
+
+testEntry2 OBJECT-TYPE
+    SYNTAX TestEntry2
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "An entry in testTable2"
+    INDEX { testTable2Index }
+    ::= { testTable2 1 }
+
+TestEntry2 ::= SEQUENCE {
+    testTable2Index DisplayString,
+    testTable2Value Integer32
+}
+
+testTable2Index OBJECT-TYPE
+    SYNTAX DisplayString
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "String index for testTable2"
+    ::= { testEntry2 1 }
+
+testTable2Value OBJECT-TYPE
+    SYNTAX Integer32
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "Value in testTable2"
+    ::= { testEntry2 2 }
+
+testTableForeignKey OBJECT-TYPE
+    SYNTAX SEQUENCE OF TestEntryForeignKey
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "A table with a foreign key"
+    ::= { testMIB 12 }
+
+testEntryForeignKey OBJECT-TYPE
+    SYNTAX TestEntryForeignKey
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "An entry with a foreign key"
+    INDEX { testTable1Index }
+    ::= { testTableForeignKey 1 }
+
+TestEntryForeignKey ::= SEQUENCE {
+    testForeignKeyValue DisplayString
+}
+
+testForeignKeyValue OBJECT-TYPE
+    SYNTAX DisplayString
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "Foreign key value"
+    ::= { testEntryForeignKey 2 }
+
+testTableComposite OBJECT-TYPE
+    SYNTAX SEQUENCE OF TestEntryComposite
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "A table with a composite key"
+    ::= { testMIB 13 }
+
+testEntryComposite OBJECT-TYPE
+    SYNTAX TestEntryComposite
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "An entry in the composite key table"
+    INDEX { testTable1Index, testTable2Index }
+    ::= { testTableComposite 1 }
+
+TestEntryComposite ::= SEQUENCE {
+    testCompositeValue Integer32
+}
+
+testCompositeValue OBJECT-TYPE
+    SYNTAX Integer32
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "Composite key value"
+    ::= { testEntryComposite 2 }
+
+testTableAugment OBJECT-TYPE
+    SYNTAX SEQUENCE OF TestEntryAugment
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "A table that augments testTable1"
+    ::= { testMIB 14 }
+
+testEntryAugment OBJECT-TYPE
+    SYNTAX TestEntryAugment
+    MAX-ACCESS not-accessible
+    STATUS current
+    DESCRIPTION "An augmented entry"
+    AUGMENTS { testEntry1 }
+    ::= { testTableAugment 1 }
+
+TestEntryAugment ::= SEQUENCE {
+    testAugmentValue TimeTicks
+}
+
+testAugmentValue OBJECT-TYPE
+    SYNTAX TimeTicks
+    MAX-ACCESS read-write
+    STATUS current
+    DESCRIPTION "Augmented value"
+    ::= { testEntryAugment 2 }
+
+END