net-snmp 3.12.1 → 3.13.0

package/.travis.yml

@@ -1,6 +1,9 @@
 language: node_js
 node_js:
   - lts/*
+  - 20
+  - 18
+  - 16
   - 14
   - 12
   - 10

package/README.md

@@ -3385,6 +3385,10 @@ Example programs are included under the module's `example` directory.
 
  * Fix SNMPv1 session walk infinite loop condition
 
+## Version 3.13.0 - 03/09/2024
+
+ * Add support for out-of-order MIB dependencies
+
 # License
 
 Copyright (c) 2020 Mark Abrahams <mark@abrahams.co.nz>

package/eslint.config.js

@@ -0,0 +1,95 @@
+module.exports = [
+    {
+        files: ['**/*.js'],
+        languageOptions: {
+            ecmaVersion: 2020,
+            sourceType: 'module',
+            globals: {
+                // Browser globals
+                window: 'readonly',
+                document: 'readonly',
+                navigator: 'readonly',
+
+                // Node.js globals
+                require: 'readonly',
+                module: 'readonly',
+                process: 'readonly',
+                __dirname: 'readonly',
+                __filename: 'readonly',
+                console: 'readonly',
+                exports: 'readonly',
+                Buffer: 'readonly',
+                setInterval: 'readonly',
+                setTimeout: 'readonly',
+                clearInterval: 'readonly',
+                clearTimeout: 'readonly',
+
+                // Mocha globals
+                describe: 'readonly',
+                it: 'readonly',
+                before: 'readonly',
+                after: 'readonly',
+                beforeEach: 'readonly',
+                afterEach: 'readonly',
+
+                // ES6 globals
+                Promise: 'readonly',
+                Set: 'readonly',
+                Map: 'readonly',
+
+                // User-defined globals
+                $: 'readonly',
+                System: 'readonly',
+                expect: 'readonly',
+            },
+        },
+        linterOptions: {
+            reportUnusedDisableDirectives: true,
+        },
+        rules: {
+            'accessor-pairs': 'error',
+            'arrow-spacing': 'error',
+            'brace-style': ['error', '1tbs', { allowSingleLine: true }],
+            camelcase: ['error', { properties: 'never' }],
+            'comma-spacing': ['error', { before: false, after: true }],
+            'eol-last': ['error', 'always'],
+            'key-spacing': ['error', { beforeColon: false, afterColon: true, mode: 'minimum' }],
+            'keyword-spacing': ['error', {}],
+            'no-cond-assign': 'error',
+            'no-console': ['off', { allow: ['warn', 'error'] }],
+            'no-constant-condition': ['error', { checkLoops: false }],
+            'no-eval': 'error',
+            'no-fallthrough': 'off',
+            'no-mixed-spaces-and-tabs': 'error',
+            'no-restricted-globals': ['error', 'event'],
+            'no-restricted-syntax': [
+                'error',
+                {
+                    selector:
+                        "*:not(ExpressionStatement) > CallExpression[callee.property.name='sort']:not([callee.object.type='CallExpression']):not([callee.object.type='ArrayExpression']):not([callee.object.name='mongoUtil'])",
+                    message:
+                        'Restricted Array Mutation: Use `array.slice().sort(...)` if mutation was not intended, otherwise place on own line.',
+                },
+                {
+                    selector:
+                        "*:not(ExpressionStatement) > CallExpression[callee.property.name='reverse']:not([callee.object.type='CallExpression']):not([callee.object.type='ArrayExpression'])",
+                    message:
+                        'Restricted Array Mutation: Use `array.slice().reverse(...)` if mutation was not intended, otherwise place on own line.',
+                },
+                {
+                    selector: "*:not(ExpressionStatement) > CallExpression[callee.property.name='push']",
+                    message:
+                        'Restricted Array Mutation: `array.push(...)` returns push count, not array reference, place statement on own line.',
+                },
+            ],
+            'no-undef': 'error',
+            'no-unused-expressions': 'error',
+            'no-unused-vars': ['error', { vars: 'all', args: 'none' }],
+            'no-useless-escape': 'off',
+            'no-with': 'error',
+            'padding-line-between-statements': ['error', { blankLine: 'always', prev: '*', next: 'function' }],
+            semi: ['error', 'always'],
+            'space-before-blocks': ['error', 'always'],
+        },
+    },
+];

package/example/snmp-agent.js

@@ -31,8 +31,8 @@ if (options.s) {
 				mib.setScalarValue(providerName, change);
 			}
 		}
-	} catch (e) {
-		console.log("Could not parse persistent storage");
+	} catch (error) {
+		console.log("Could not parse persistent storage", error);
 		changes = {};
 	}
 }

package/index.js

@@ -5257,6 +5257,7 @@ Agent.prototype.addGetNextVarbind = function (targetVarbinds, startOid) {
 
 	try {
 		startNode = this.mib.lookup (startOid);
+	// eslint-disable-next-line no-unused-vars
 	} catch ( error ) {
 		startOid = '1.3.6.1';
 		startNode = this.mib.lookup (startOid);
@@ -6199,6 +6200,7 @@ Subagent.prototype.addGetNextVarbind = function (targetVarbinds, startOid) {
 
 	try {
 		startNode = this.mib.lookup (startOid);
+	// eslint-disable-next-line no-unused-vars
 	} catch ( error ) {
 		startOid = '1.3.6.1';
 		startNode = this.mib.lookup (startOid);

package/lib/mib.js

@@ -346,6 +346,7 @@ var MIB = function (dir) {
                     var Symbols = this.SymbolBuffer[ModuleName];
                     var Object = Module;
                     var MACROName = '';
+                    let unresolvedObjects = [];
                     for (var i = 0; i < Symbols.length; i++) {
                         switch (Symbols[i]) {
                             case '::=': //new OBJECT to define
@@ -372,9 +373,14 @@ var MIB = function (dir) {
                                             Object[Symbols[i - 2]]['OID'] = '0.0';
                                             Object[Symbols[i - 2]]['NameSpace'] = 'null';
                                         } else {
-                                            const { oidString, nameString } = this.getOidAndNamePaths(Object[Symbols[i - 2]]['OBJECT IDENTIFIER'], Symbols[i - 2], ModuleName);
+                                            const { oidString, nameString, unresolvedObject } = this.getOidAndNamePaths(Object[Symbols[i - 2]]['OBJECT IDENTIFIER'], Symbols[i - 2], ModuleName);
                                             Object[Symbols[i - 2]]['OID'] = oidString;
                                             Object[Symbols[i - 2]]['NameSpace'] = nameString;
+                                            if (unresolvedObject) {
+                                                if ( ! unresolvedObjects.includes(unresolvedObject) ) {
+                                                    unresolvedObjects.push(unresolvedObject);
+                                                }
+                                            }
                                             // Object[Symbols[i - 2]]['ModuleName'] = ModuleName;
                                             // Object[Symbols[i - 2]]['ObjectName'] = Symbols[i - 2];
                                         }
@@ -531,11 +537,14 @@ var MIB = function (dir) {
                                             Object[Symbols[r - 1]]['OID'] = '0.0';
                                             Object[Symbols[r - 1]]['NameSpace'] = 'null';
                                         } else {
-                                            const { oidString, nameString } = this.getOidAndNamePaths(Object[Symbols[r - 1]]['OBJECT IDENTIFIER'], Symbols[r - 1], ModuleName);
+                                            const { oidString, nameString, unresolvedObject } = this.getOidAndNamePaths(Object[Symbols[r - 1]]['OBJECT IDENTIFIER'], Symbols[r - 1], ModuleName);
                                             Object[Symbols[r - 1]]['OID'] = oidString;
                                             Object[Symbols[r - 1]]['NameSpace'] = nameString;
-                                            // Object[Symbols[r - 1]]['ModuleName'] = ModuleName;
-                                            // Object[Symbols[r - 1]]['ObjectName'] = Symbols[r - 1];
+                                            if (unresolvedObject) {
+                                                if ( ! unresolvedObjects.includes(unresolvedObject) ) {
+                                                    unresolvedObjects.push(unresolvedObject);
+                                                }
+                                            }
                                         }
                                         if ( Object[Symbols[r - 1]]['REVISIONS-DESCRIPTIONS'] &&
                                                 Object[Symbols[r - 1]]['REVISIONS-DESCRIPTIONS'].length == 1 &&
@@ -643,6 +652,29 @@ var MIB = function (dir) {
 
 
                     }
+                    // attempt OID/namespace reconstruction for unresolved objects, as parsing has finished
+                    if (unresolvedObjects.length > 0) {
+                        for (const unresolved of unresolvedObjects) {
+                            const obj = this.Modules[ModuleName][unresolved];
+                            
+                            const { oidString, nameString, unresolvedObject } = this.getOidAndNamePaths(obj['OBJECT IDENTIFIER'], unresolved, ModuleName);
+                            this.Modules[ModuleName][unresolved].NameSpace = nameString;
+                            this.Modules[ModuleName][unresolved].OID = oidString;
+
+                            // unresolvedObject is only returned if still unable to resolve (likely due to error in MIB)
+                            // unresolved OID will propagate to all children as well
+                            if (unresolvedObject) {
+                                if (obj.NameSpace) {
+                                    const unresolvedParent = obj.NameSpace.split('.')[1];
+                                    if (unresolvedParent !== obj.ObjectName) {
+                                        console.warn(`Unable to mount node '${obj.ObjectName}', cannot resolve parent object '${unresolvedParent}'.`);
+                                        continue;
+                                    }
+                                }
+                                console.warn(`Unable to mount node '${obj.ObjectName}', cannot resolve object identifier '${obj['OBJECT IDENTIFIER']}'.`);
+                            }
+                        }
+                    }
                 }
             }
         },
@@ -761,6 +793,7 @@ var MIB = function (dir) {
             nameEntries.push(ObjectName);
             let parentOidPrefix;
             let parentNamePrefix;
+            let unresolvedObject;
             if ( parent == 'iso' ) {
                 parentOidPrefix = '1';
                 parentNamePrefix = 'iso';
@@ -780,18 +813,25 @@ var MIB = function (dir) {
                 }
                 if ( ! parentObject ) {
                     // occurs for out-of-order dependencies in a module
-                    // console.warn('Parent object not found for ' + parent);
+                    // return partial OID/namespace and name of unresolved object
+                    unresolvedObject = ObjectName;
                     return {
-                        oidString: '',
-                        nameString: ''
+                        oidString: '.' + oidEntries.join('.'),
+                        nameString: '.' + nameEntries.join('.'),
+                        unresolvedObject
                     };
                 }
+                // occurs for all children of an unresolved node
+                if ( parentObject.OID.startsWith('.') ) {
+                    unresolvedObject = ObjectName;
+                }
                 parentOidPrefix = parentObject['OID'];
                 parentNamePrefix = parentObject['NameSpace'];
             }
             return {
                 oidString: parentOidPrefix + '.' + oidEntries.join('.'),
-                nameString: parentNamePrefix + '.' + nameEntries.join('.')
+                nameString: parentNamePrefix + '.' + nameEntries.join('.'),
+                unresolvedObject: unresolvedObject || undefined
             };
         }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "net-snmp",
-  "version": "3.12.1",
+  "version": "3.13.0",
   "description": "JavaScript implementation of the Simple Network Management Protocol (SNMP)",
   "main": "index.js",
   "directories": {
@@ -11,7 +11,7 @@
     "smart-buffer": "^4.1.0"
   },
   "devDependencies": {
-    "eslint": "^5.16.0",
+    "eslint": "^9.9.1",
     "getopts": "*"
   },
   "contributors": [

package/.eslintrc

@@ -1,76 +0,0 @@
-{
-  "extends": "eslint:recommended",
-  "env": {
-    "es6": true,
-    "node": true,
-    "browser": true,
-    "mocha": true
-  },
-  "parserOptions": {
-      "ecmaVersion": 2016
-  },
-  "globals": {
-    "window": false,
-    "document": false,
-    "$": false,
-    "System": false,
-    "expect": false
-  },
-  "rules": {
-    "accessor-pairs": "error",
-    "arrow-spacing": "error",
-    "brace-style": [ "error", "1tbs", { "allowSingleLine": true } ],
-    "camelcase": [ "error", { "properties": "never" } ],
-    "comma-spacing": ["error", { "before": false, "after": true }],
-    // "curly": [ "error", "all" ],
-    // "dot-notation": "error",
-    "eol-last": ["error", "always"],
-    // "eqeqeq": ["error", "always"],
-    // "indent": ["error", "tab", { "MemberExpression": "off", "SwitchCase": 1, "ObjectExpression": "first" } ],
-    "key-spacing": [ "error", { "beforeColon": false, "afterColon": true, "mode": "minimum" } ],
-    "keyword-spacing": [ "error", {} ],
-    "no-cond-assign": "error",
-    "no-console": ["off", { "allow": ["warn", "error"] }],
-    "no-constant-condition": ["error", { "checkLoops": false }],
-    "no-eval": "error",
-    "no-fallthrough": "off",
-    "no-mixed-spaces-and-tabs": "error",
-    // "no-multiple-empty-lines": "error",
-    "no-restricted-globals": ["error", "event"],
-    "no-restricted-syntax": [
-      "error",
-      {
-        "selector": "*:not(ExpressionStatement) > CallExpression[callee.property.name='sort']:not([callee.object.type='CallExpression']):not([callee.object.type='ArrayExpression']):not([callee.object.name='mongoUtil'])",
-        "message": "Restricted Array Mutation: Use `array.slice().sort(...)` if mutation was not intended, otherwise place on own line."
-      },
-      {
-        "selector": "*:not(ExpressionStatement) > CallExpression[callee.property.name='reverse']:not([callee.object.type='CallExpression']):not([callee.object.type='ArrayExpression'])",
-        "message": "Restricted Array Mutation: Use `array.slice().reverse(...)` if mutation was not intended, otherwise place on own line."
-      },
-      {
-        "selector": "*:not(ExpressionStatement) > CallExpression[callee.property.name='push']",
-        "message": "Restricted Array Mutation: `array.push(...)` returns push count, not array reference, place statement on own line."
-      }
-    ],
-    // "no-return-assign": "error",
-    // "no-trailing-spaces": "error",
-    "no-undef": "error",
-    "no-unused-expressions": "error",
-    "no-unused-vars": ["error", { "vars": "all", "args": "none" }],
-    // "no-use-before-define": [ "error", { "functions": false } ],
-    "no-useless-escape": "off",
-    "no-with": "error",
-    "padding-line-between-statements": [
-      "error",
-      { "blankLine": "always", "prev": "*", "next": "function" }
-    ],
-    // "quotes": [ "error", "double", { "allowTemplateLiterals": true, "avoidEscape": true } ],
-    "semi": [ "error", "always" ],
-    "space-before-blocks": [ "error", "always" ],
-    // "space-before-function-paren": [ "error", { "anonymous": "always", "named": "always", "asyncArrow": "always" } ],
-    // "space-in-parens": [ "error", "never" ],
-    // "space-infix-ops": "error",
-    // "space-unary-ops": [ "error", { "nonwords": true, "overrides": {} } ],
-    // "spaced-comment": [ "error", "always", {"block": {"exceptions": ["*", "!"], "balanced": true}} ]
-  }
-}