net-snmp 3.19.1 → 3.20.0

package/README.md

@@ -3469,6 +3469,14 @@ Example programs are included under the module's `example` directory.
 
  * Fix integer constraints check
 
+# Version 3.19.2 - 06/03/2025
+
+ * Fix integer and string constraints check on cast
+
+# Version 3.20.0 - 06/03/2025
+
+ * Fix set value for counter, gauge and unsigned integer types
+
 # License
 
 Copyright (c) 2020 Mark Abrahams <mark@abrahams.co.nz>

package/index.js

@@ -15,6 +15,7 @@ var MIN_SIGNED_INT32 = -2147483648;
 var MAX_SIGNED_INT32 = 2147483647;
 var MIN_UNSIGNED_INT32 = 0;
 var MAX_UNSIGNED_INT32 = 4294967295;
+var MAX_UNSIGNED_INT64 = 18446744073709551615;
 
 function debug (line) {
 	if ( DEBUG ) {
@@ -604,17 +605,17 @@ ObjectTypeUtil.castSetValue = function (type, value, constraints) {
 			if ( isNaN(parsedValue) ) {
 				throw new Error("Invalid Integer", value);
 			}
-			if ( constraints && ObjectTypeUtil.doesIntegerMeetConstraints (parsedValue, constraints) ) {
+			if ( constraints && ! ObjectTypeUtil.doesIntegerMeetConstraints (parsedValue, constraints) ) {
 				throw new Error("Integer does not meet constraints", value);
 			}
 			return parsedValue;
 		}
 
 		case ObjectType.OctetString: {
-			if ( ! value instanceof Buffer && typeof value != "string" ) {
+			if ( ! ( value instanceof Buffer || typeof value == "string" ) ) {
 				throw new Error("Invalid OctetString", value);
 			}
-			if ( constraints && ObjectTypeUtil.doesStringMeetConstraints (value, constraints) ) {
+			if ( constraints && ! ObjectTypeUtil.doesStringMeetConstraints (value, constraints) ) {
 				throw new Error("OctetString does not meet constraints", value);
 			}
 			if ( value instanceof Buffer ) {
@@ -635,19 +636,59 @@ ObjectTypeUtil.castSetValue = function (type, value, constraints) {
 		case ObjectType.Counter32:
 		case ObjectType.Gauge:
 		case ObjectType.Gauge32:
-		case ObjectType.Unsigned32:
-		case ObjectType.Counter64: {
+		case ObjectType.Unsigned32: {
 			// Counters should be initialized to 0 (RFC2578, end of section 7.9)
 			// We'll do so.
-			return 0;
+			// return 0;
+			// That ^^^ was fine when castSetValue was used only for DEFVAL
+			// But now it's used in other set value scenarios
+			// So we need to cast the given value to a whole number
+			const parsedValue = parseInt(value, 10);
+			if ( isNaN(parsedValue) ) {
+				throw new Error(`Invalid Integer for ${type}`, value);
+			}
+			if ( parsedValue < 0 ) {
+				throw new Error(`Integer is negative for ${type}`, value);
+			}
+			if ( parsedValue > MAX_UNSIGNED_INT32 ) {
+				throw new Error(`Integer is greater than max unsigned int32 for ${type}`, value);
+			}
+			return parsedValue;
+		}
+
+		case ObjectType.Counter64: {
+			if ( value instanceof Buffer ) {
+				if ( value.length !== 8 ) {
+					throw new Error(`Counter64 buffer is not 8 bytes`, value);
+				}
+				return value;
+			}
+			const parsedValue = parseInt(value, 10);
+			if ( isNaN(parsedValue) ) {
+				throw new Error(`Invalid Integer for Counter64`, value);
+			}
+			if ( parsedValue < 0 ) {
+				throw new Error(`Integer is negative for Counter64`, value);
+			}
+			if ( parsedValue > MAX_UNSIGNED_INT64 ) {
+				throw new Error(`Integer is greater than max unsigned int64 for Counter64`, value);
+			}
+			return parsedValue;
 		}
 
 		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 ) {
+			const octets = value.split (".");
+			if ( typeof value != "string" || octets.length != 4 ) {
 				throw new Error("Invalid IpAddress", value);
 			}
+			for ( const octet of octets ) {
+				if ( isNaN (octet) ) {
+					throw new Error("Invalid IpAddress", value);
+				}
+				if ( parseInt (octet) < 0 || parseInt (octet) > 255) {
+					throw new Error("Invalid IpAddress", value);
+				}
+			}
 			return value;
 		}
 

package/package.json

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

package/test/cast-set-value.test.js

@@ -0,0 +1,200 @@
+const assert = require('assert');
+const snmp = require('..');
+
+describe('Cast Set Value', function() {
+
+    describe('Boolean', function() {
+        it('casts truthy values to true', function() {
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Boolean, 1), true);
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Boolean, "true"), true);
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Boolean, {}), true);
+        });
+
+        it('casts falsy values to false', function() {
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Boolean, 0), false);
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Boolean, ""), false);
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Boolean, null), false);
+        });
+    });
+
+    describe('Integer', function() {
+        it('accepts valid integers', function() {
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Integer, 42), 42);
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Integer, -42), -42);
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Integer, "42"), 42);
+        });
+
+        it('throws on invalid integers', function() {
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Integer, "not a number");
+            }, /Invalid Integer/);
+
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Integer, {});
+            }, /Invalid Integer/);
+        });
+
+        it('respects enumeration constraints', function() {
+            const constraints = {
+                enumeration: {
+                    1: 'one',
+                    2: 'two'
+                }
+            };
+
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Integer, 1, constraints), 1);
+
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Integer, 3, constraints);
+            }, /Integer does not meet constraints/);
+        });
+
+        it('respects range constraints', function() {
+            const constraints = {
+                ranges: [
+                    { min: 0, max: 10 }
+                ]
+            };
+
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Integer, 5, constraints), 5);
+
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Integer, 11, constraints);
+            }, /Integer does not meet constraints/);
+        });
+    });
+
+    describe('OctetString', function() {
+        it('accepts strings', function() {
+            assert.strictEqual(
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.OctetString, "test string"),
+                "test string"
+            );
+        });
+
+        it('converts buffers to strings', function() {
+            const buf = Buffer.from("test buffer");
+            assert.strictEqual(
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.OctetString, buf),
+                buf.toString()
+            );
+        });
+
+        it('throws on invalid types', function() {
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.OctetString, 123);
+            }, /Invalid OctetString/);
+        });
+
+        it('respects size constraints', function() {
+            const constraints = {
+                sizes: [
+                    { min: 2, max: 5 }
+                ]
+            };
+
+            assert.strictEqual(
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.OctetString, "123", constraints),
+                "123"
+            );
+
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.OctetString, "too long", constraints);
+            }, /OctetString does not meet constraints/);
+        });
+    });
+
+    describe('OID', function() {
+        it('accepts valid OIDs', function() {
+            assert.strictEqual(
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.OID, "1.3.6.1.2.1"),
+                "1.3.6.1.2.1"
+            );
+        });
+
+        it('throws on invalid OIDs', function() {
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.OID, "not.an.oid");
+            }, /Invalid OID/);
+
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.OID, "1.2.3.");
+            }, /Invalid OID/);
+        });
+    });
+
+    describe('Counter/Gauge/Unsigned32', function() {
+        const types = [
+            snmp.ObjectType.Counter,
+            snmp.ObjectType.Counter32,
+            snmp.ObjectType.Gauge,
+            snmp.ObjectType.Gauge32,
+            snmp.ObjectType.Unsigned32
+        ];
+
+        types.forEach(type => {
+            it(`accepts valid unsigned integers for ${type}`, function() {
+                assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(type, 42), 42);
+                assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(type, "42"), 42);
+            });
+
+            it(`throws on negative numbers for ${type}`, function() {
+                assert.throws(() => {
+                    snmp.ObjectTypeUtil.castSetValue(type, -1);
+                }, /Integer is negative/);
+            });
+
+            it(`throws on values exceeding unsigned 32-bit max for ${type}`, function() {
+                assert.throws(() => {
+                    snmp.ObjectTypeUtil.castSetValue(type, 4294967296); // MAX_UNSIGNED_INT32 + 1
+                }, /Integer is greater than max unsigned int32/);
+            });
+        });
+    });
+
+    describe('Counter64', function() {
+        it('accepts valid unsigned integers', function() {
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Counter64, 42), 42);
+            assert.strictEqual(snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Counter64, "42"), 42);
+        });
+
+        it('accepts valid 8-byte buffers', function() {
+            const buf = Buffer.alloc(8);
+            assert.strictEqual(
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Counter64, buf),
+                buf
+            );
+        });
+
+        it('throws on invalid buffer length', function() {
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Counter64, Buffer.alloc(7));
+            }, /Counter64 buffer is not 8 bytes/);
+        });
+
+        it('throws on negative numbers', function() {
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.Counter64, -1);
+            }, /Integer is negative for Counter64/);
+        });
+    });
+
+    describe('IpAddress', function() {
+        it('accepts valid IP addresses', function() {
+            assert.strictEqual(
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.IpAddress, "192.168.1.1"),
+                "192.168.1.1"
+            );
+        });
+
+        it('throws on invalid IP addresses', function() {
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.IpAddress, "not.an.ip.address");
+            }, /Invalid IpAddress/);
+
+            assert.throws(() => {
+                snmp.ObjectTypeUtil.castSetValue(snmp.ObjectType.IpAddress, "192.168.1");
+            }, /Invalid IpAddress/);
+        });
+    });
+});