net-snmp 3.9.5 → 3.9.7

package/README.md

@@ -3297,6 +3297,14 @@ Example programs are included under the module's `example` directory.
 
  * Normalize whitespace parsing for OBJECT IDENTIFIER value
 
+## Version 3.9.6 - 30/05/2023
+
+ * Add type constraint support for textual conventions
+
+## Version 3.9.7 - 13/07/2023
+
+ * Add tolerance for reading malformed 32-bit unsigned integers
+
 # License
 
 Copyright (c) 2020 Mark Abrahams <mark@abrahams.co.nz>

package/index.js

@@ -88,22 +88,6 @@ ObjectType.Integer32 = ObjectType.Integer;
 ObjectType.Counter32 = ObjectType.Counter;
 ObjectType.Gauge32 = ObjectType.Gauge;
 ObjectType.Unsigned32 = ObjectType.Gauge32;
-// SNMPv2-TC
-ObjectType.AutonomousType = ObjectType["OBJECT IDENTIFIER"];
-ObjectType.DateAndTime = ObjectType["OCTET STRING"];
-ObjectType.DisplayString = ObjectType["OCTET STRING"];
-ObjectType.InstancePointer = ObjectType["OBJECT IDENTIFIER"];
-ObjectType.MacAddress = ObjectType["OCTET STRING"];
-ObjectType.PhysAddress = ObjectType["OCTET STRING"];
-ObjectType.RowPointer = ObjectType["OBJECT IDENTIFIER"];
-ObjectType.RowStatus = ObjectType.INTEGER;
-ObjectType.StorageType = ObjectType.INTEGER;
-ObjectType.TestAndIncr = ObjectType.INTEGER;
-ObjectType.TimeStamp = ObjectType.TimeTicks;
-ObjectType.TruthValue = ObjectType.INTEGER;
-ObjectType.TAddress = ObjectType["OCTET STRING"];
-ObjectType.TDomain = ObjectType["OBJECT IDENTIFIER"];
-ObjectType.VariablePointer = ObjectType["OBJECT IDENTIFIER"];
 
 var PduType = {
 	160: "GetRequest",
@@ -408,6 +392,7 @@ function readUint32 (buffer) {
 	if ( ! Number.isInteger(parsedInt) ) {
 		throw new TypeError('Value read as integer ' + parsedInt + ' is not an integer');
 	}
+	parsedInt = (parsedInt>>>0);
 	if ( parsedInt < MIN_UNSIGNED_INT32 || parsedInt > MAX_UNSIGNED_INT32 ) {
 		throw new RangeError('Read integer ' + parsedInt + ' is outside the unsigned 32-bit range');
 	}
@@ -3174,7 +3159,7 @@ ModuleStore.prototype.getSyntaxTypes = function () {
 			if ( mibEntry.MACRO == "TEXTUAL-CONVENTION" ) {
 				if ( mibEntry.SYNTAX && ! syntaxTypes[mibEntry.ObjectName] ) {
 					if ( typeof mibEntry.SYNTAX == "object" ) {
-						syntaxTypes[mibEntry.ObjectName] = syntaxTypes.Integer;
+						syntaxTypes[mibEntry.ObjectName] = mibEntry.SYNTAX;
 					} else {
 						syntaxTypes[mibEntry.ObjectName] = syntaxTypes[mibEntry.SYNTAX];
 					}
@@ -3239,7 +3224,7 @@ ModuleStore.prototype.getProvidersForModule = function (moduleName) {
 		var defVal = mibEntry["DEFVAL"];
 
 		if ( syntax ) {
-			constraintsResults = ModuleStore.getConstraintsFromSyntax (syntax);
+			constraintsResults = ModuleStore.getConstraintsFromSyntax (syntax, syntaxTypes);
 			syntax = constraintsResults.syntax;
 			constraints = constraintsResults.constraints;
 
@@ -3269,7 +3254,7 @@ ModuleStore.prototype.getProvidersForModule = function (moduleName) {
 					maxAccess = (typeof mibEntry["MAX-ACCESS"] != "undefined" ? mibEntry["MAX-ACCESS"] : (access ? AccessToMaxAccess[access] : "not-accessible"));
 					defVal = mibEntry["DEFVAL"];
 
-					constraintsResults = ModuleStore.getConstraintsFromSyntax (syntax);
+					constraintsResults = ModuleStore.getConstraintsFromSyntax (syntax, syntaxTypes);
 					syntax = constraintsResults.syntax;
 					constraints = constraintsResults.constraints;
 
@@ -3349,11 +3334,14 @@ ModuleStore.prototype.getProvidersForModule = function (moduleName) {
 				}
 			} else if ( mibEntry.MACRO == "OBJECT-TYPE" ) {
 				// OBJECT-TYPE entries not in a table are scalars
+				let scalarType = syntaxTypes[syntax];
+				if (typeof scalarType === 'object')
+					scalarType = syntaxTypes[Object.keys(scalarType)[0]];
 				var scalarDefinition = {
 					name: mibEntry.ObjectName,
 					type: MibProviderType.Scalar,
 					oid: mibEntry.OID,
-					scalarType: syntaxTypes[syntax],
+					scalarType: scalarType,
 					maxAccess: MaxAccess[maxAccess]
 				};
 
@@ -3379,9 +3367,11 @@ ModuleStore.prototype.loadBaseModules = function () {
 	this.parser.Serialize ();
 };
 
-ModuleStore.getConstraintsFromSyntax = function (syntax) {
+ModuleStore.getConstraintsFromSyntax = function (syntax, syntaxTypes) {
 	let constraints;
-
+	if ( typeof syntaxTypes[syntax] === 'object' ) {
+		syntax = syntaxTypes[syntax];
+	}
 	// detect INTEGER ranges, OCTET STRING sizes, and INTEGER enumerations
 	if ( typeof syntax == "object" ) {
 		let firstSyntaxKey = syntax[Object.keys(syntax)[0]];

package/lib/mib.js

@@ -60,7 +60,7 @@ var MIB = function (dir) {
                 var R = this.RowIndex;
                 var C = this.ColumnIndex;
 
-                if (!this.Table[FileName][R]) {
+                if (!this.Table[FileName][R] || C === 0) {
                     this.Table[FileName][R] = Object.defineProperty([], "line", {
                         enumerable: false,
                         value: row + 1
@@ -143,11 +143,14 @@ var MIB = function (dir) {
             }
         },
         ParseLine: function (FileName, line, row) {
-            line = line + "\n";
-            for (var i = 0; i < line.length; i++) {
+            let len = line.length;
+            if (line[len - 1] === '\r')
+                --len;
+            for (var i = 0; i < len; i++) {
                 var char = line.charAt(i);
                 this.ParseChar(FileName, char, row, i);
             }
+            this.ParseChar(FileName, '\n', row, len);
         },
         ParseChar: function (FileName, char, row, column) {
             switch (char) {
@@ -310,7 +313,7 @@ var MIB = function (dir) {
                                 lastGoodDeclaration = row;
                                 break;
                             default:
-                                if (symbol.indexOf('--') == 0) {//REMOVE COMMENTS
+                                if (symbol.startsWith('--')) {//REMOVE COMMENTS
                                     //console.log(ModuleName, symbol);
                                     addSymbol = false;
                                 } else {
@@ -670,35 +673,34 @@ var MIB = function (dir) {
         },
         BuildObject: function (Object, ObjectName, macro, i, Symbols) {
 
-            var r = i;
-            var m = Symbols.indexOf('SYNTAX', r) - r;
-            var SYNTAX = Symbols[Symbols.indexOf('SYNTAX', r) + 1];
-            var val = Symbols[Symbols.indexOf('SYNTAX', r) + 2];
-            var c1 = Symbols.indexOf('SYNTAX', r) + 1;
+            var syntaxKeyword = Symbols.indexOf('SYNTAX', i);
+            var m = syntaxKeyword - i;
+            var c1 = syntaxKeyword + 1;
+            var SYNTAX = Symbols[c1];
+            var val = Symbols[c1 + 1];
 
             if (this.MACROS.indexOf(macro) > -1 && m < 10) {
-                switch (SYNTAX) {
-                    case "INTEGER":
-                        if (val.indexOf("{") == 0) {
-                            c1++;
-                            while (Symbols[c1].indexOf("}") == -1) {
-                                c1++;
-                                val += Symbols[c1].trim();
-                            }
-                            val = val.replace("{", "").replace("}", "").split(",");
-
-                            Object[ObjectName]['SYNTAX'] = {};
-                            Object[ObjectName]['SYNTAX'][SYNTAX] = {};
+                if (val[0] === "{") {
+                    c1++;
+                    while (Symbols[c1].indexOf("}") == -1) {
+                        c1++;
+                        val += Symbols[c1].trim();
+                    }
+                    val = val.replace("{", "").replace("}", "").split(",");
 
-                            for (var TC = 0; TC < val.length; TC++) {
-                                Object[ObjectName]['SYNTAX'][SYNTAX][val[TC].split("(")[1].replace(")", "")] = val[TC].split("(")[0];
-                            }
-                        }
-                        break;
-                    default:
-                        Object[ObjectName]['SYNTAX'] = SYNTAX;
-                        break;
+                    Object[ObjectName]['SYNTAX'] = {};
+                    Object[ObjectName]['SYNTAX'][SYNTAX] = {};
 
+                    for (var TC = 0; TC < val.length; TC++) {
+                        let openParenSplit = val[TC].split(/\s*\(\s*/);
+                        Object[ObjectName]['SYNTAX'][SYNTAX][openParenSplit[1].replace(/\s*\)\s*$/, '')] = openParenSplit[0].trimStart();
+                    }
+                } else if (val[0] === '(') {
+                    const key = val.startsWith('(SIZE')? 'sizes' : 'ranges';
+                    Object[ObjectName]['SYNTAX'] = {};
+                    Object[ObjectName]['SYNTAX'][SYNTAX] = { [key]: this.GetRanges(val) };
+                } else {
+                    Object[ObjectName]['SYNTAX'] = SYNTAX;
                 }
             }
         },

package/package.json

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

package/test/varbinds.js

@@ -1,43 +1,49 @@
-/* eslint-disable no-unused-expressions */
-
-var ber    = require ('asn1-ber').Ber;
-var assert = require('assert');
-var snmp   = require('../');
+const ber    = require ('asn1-ber').Ber;
+const assert = require('assert');
+const snmp   = require('../');
 
 describe('parseInt()', function() {
 	describe('given a negative integer', function() {
-		var writer = new ber.Writer();
+		const writer = new ber.Writer();
 		writer.writeInt(-3);
-		var reader = new ber.Reader(writer.buffer);
+		const reader = new ber.Reader(writer.buffer);
 		it('returns a negative integer', function() {
-			assert.equal(-3, snmp.ObjectParser.readInt(reader));
+			assert.equal(snmp.ObjectParser.readInt32(reader), -3);
 		});
-	}),
+	});
 	describe('given a positive integer', function() {
-		var writer = new ber.Writer();
+		const writer = new ber.Writer();
 		writer.writeInt(3245689);
-		var reader = new ber.Reader(writer.buffer);
+		const reader = new ber.Reader(writer.buffer);
 		it('returns a positive integer', function() {
-			assert.equal(3245689, snmp.ObjectParser.readInt(reader));
+			assert.equal(snmp.ObjectParser.readInt32(reader), 3245689);
 		});
 	});
 });
 
 describe('parseUint()', function() {
 	describe('given a positive integer', function() {
-		var writer = new ber.Writer();
+		const writer = new ber.Writer();
 		writer.writeInt(3242425);
-		var reader = new ber.Reader(writer.buffer);
+		const reader = new ber.Reader(writer.buffer);
 		it('returns a positive integer', function() {
-			assert.equal(3242425, snmp.ObjectParser.readUint(reader));
+			assert.equal(snmp.ObjectParser.readUint32(reader), 3242425);
 		});
-	}),
+	});
 	describe('given a negative integer', function() {
-		var writer = new ber.Writer();
+		const writer = new ber.Writer();
 		writer.writeInt(-3);
-		var reader = new ber.Reader(writer.buffer);
+		const reader = new ber.Reader(writer.buffer);
+		it('returns a positive integer', function() {
+			assert.equal(snmp.ObjectParser.readUint32(reader), 4294967293);
+		});
+	});
+	describe('given a large integer', function() {
+		const writer = new ber.Writer();
+		writer.writeInt(4294967294);
+		const reader = new ber.Reader(writer.buffer);
 		it('returns a positive integer', function() {
-			assert.equal(253, snmp.ObjectParser.readUint(reader));
+			assert.equal(snmp.ObjectParser.readUint32(reader), 4294967294);
 		});
 	});
 });