Apply consistent-return lint rule

.eslintrc.json

@@ -12,6 +12,7 @@
     "no-shadow": ["error", { "allow": ["err"] }],
     "handle-callback-err": "error",
     "prefer-arrow-callback": "error",
-    "curly": ["error", "multi-or-nest", "consistent"]
+    "curly": ["error", "multi-or-nest", "consistent"],
+    "consistent-return": ["error", {"treatUndefinedAsUnspecified": true}]
   }
 }

lib/api-functions.js

@@ -68,7 +68,7 @@ function udpConReq(address, un, key, callback) {
   const func = err => {
     if (err || --count <= 0) {
       client.close();
-      return callback(err);
+      return void callback(err);
     }
     client.send(message, 0, message.length, port, host, func);
   };
@@ -85,8 +85,11 @@ function httpConReq(
   callback
 ) {
   const options = URL.parse(url);
-  if (options.protocol !== "http:")
+  if (options.protocol !== "http:") {
-    return callback(new Error("Invalid connection request URL or protocol"));
+    return void callback(
+      new Error("Invalid connection request URL or protocol")
+    );
+  }
   options.agent = new http.Agent({ maxSockets: 1 });
 
   function statusToError(statusCode) {
@@ -112,7 +115,9 @@ function httpConReq(
         if (authHeader.method === "Basic") {
           if (!allowBasicAuth) {
             request.abort();
-            return callback(new Error("Basic HTTP authentication not allowed"));
+            return void callback(
+              new Error("Basic HTTP authentication not allowed")
+            );
           }
           options.headers = {
             Authorization: auth.basic(username || "", password || "")
@@ -205,7 +210,7 @@ function connectionRequest(deviceId, callback) {
   };
 
   db.devicesCollection.findOne({ _id: deviceId }, proj, (err, device) => {
-    if (err) return callback(err);
+    if (err) return void callback(err);
 
     let managementServer,
       connectionRequestUrl,
@@ -245,7 +250,7 @@ function connectionRequest(deviceId, callback) {
         CONNECTION_REQUEST_ALLOW_BASIC_AUTH,
         CONNECTION_REQUEST_TIMEOUT,
         err => {
-          if (udpSent) return callback();
+          if (udpSent) return void callback();
           callback(err);
         }
       );
@@ -254,7 +259,7 @@ function connectionRequest(deviceId, callback) {
     if (config.auth && config.auth.connectionRequest) {
       // Callback is optional for backward compatibility
       if (config.auth.connectionRequest.length > 4) {
-        return config.auth.connectionRequest(
+        return void config.auth.connectionRequest(
           deviceId,
           connectionRequestUrl,
           username,
@@ -280,17 +285,17 @@ function connectionRequest(deviceId, callback) {
 function watchTask(deviceId, taskId, timeout, callback) {
   setTimeout(() => {
     db.tasksCollection.findOne({ _id: taskId }, { _id: 1 }, (err, task) => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
-      if (!task) return callback(null, "completed");
+      if (!task) return void callback(null, "completed");
 
       const q = { _id: `${deviceId}:task_${taskId}` };
       db.faultsCollection.findOne(q, { _id: 1 }, (err, fault) => {
-        if (err) return callback(err);
+        if (err) return void callback(err);
 
-        if (fault) return callback(null, "fault");
+        if (fault) return void callback(null, "fault");
 
-        if ((timeout -= 500) <= 0) return callback(null, "timeout");
+        if ((timeout -= 500) <= 0) return void callback(null, "timeout");
 
         watchTask(deviceId, taskId, timeout, callback);
       });
@@ -311,7 +316,8 @@ function sanitizeTask(task, callback) {
 
 function insertTasks(tasks, callback) {
   if (tasks && common.typeOf(tasks) !== common.ARRAY_TYPE) tasks = [tasks];
-  else if (!tasks || tasks.length === 0) return callback(null, tasks || []);
+  else if (!tasks || tasks.length === 0)
+    return void callback(null, tasks || []);
 
   let counter = tasks.length;
   for (let task of tasks) {
@@ -330,9 +336,9 @@ function insertTasks(tasks, callback) {
 
 function deleteDevice(deviceId, callback) {
   db.tasksCollection.remove({ device: deviceId }, err => {
-    if (err) return callback(err);
+    if (err) return void callback(err);
     db.devicesCollection.remove({ _id: deviceId }, err => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
       db.faultsCollection.remove(
         {
           _id: {
@@ -340,7 +346,7 @@ function deleteDevice(deviceId, callback) {
           }
         },
         err => {
-          if (err) return callback(err);
+          if (err) return void callback(err);
           db.operationsCollection.remove(
             {
               _id: {
@@ -348,7 +354,7 @@ function deleteDevice(deviceId, callback) {
               }
             },
             err => {
-              if (err) return callback(err);
+              if (err) return void callback(err);
               cache.del(`${deviceId}_tasks_faults_operations`, callback);
             }
           );

lib/cache.js

@@ -50,7 +50,7 @@ function connect(callback) {
     mongodb.MongoClient.connect(
       MONGODB_CONNECTION_URL,
       (err, db) => {
-        if (err) return callback(err);
+        if (err) return void callback(err);
 
         mongoDb = db;
         mongoCollection = db.collection("cache");
@@ -58,7 +58,7 @@ function connect(callback) {
 
         const now = Date.now();
         mongoDb.command({ hostInfo: 1 }, (err, res) => {
-          if (err) return callback(err);
+          if (err) return void callback(err);
           mongoTimeOffset = res.system.currentTime.getTime() - now;
           exports.get = mongoGet;
           exports.set = mongoSet;
@@ -133,7 +133,7 @@ function redisLock(lockName, ttl, callback) {
   }
 
   redisClient.set(lockName, token, "NX", "EX", ttl, (err, res) => {
-    if (err || res) return callback(err, unlockOrExtend);
+    if (err || res) return void callback(err, unlockOrExtend);
 
     setTimeout(() => {
       redisLock(lockName, ttl, callback);
@@ -145,7 +145,7 @@ function mongoGet(key, callback) {
   let expire = new Date(Date.now() - mongoTimeOffset);
   if (Array.isArray(key)) {
     mongoCollection.find({ _id: { $in: key } }).toArray((err, res) => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
       let indices = {};
       key.forEach((v, i) => {
@@ -160,9 +160,9 @@ function mongoGet(key, callback) {
     });
   } else {
     mongoCollection.findOne({ _id: { $in: [key] } }, (err, res) => {
-      if (err || !res) return callback(err);
+      if (err || !res) return void callback(err);
 
-      if (res["expire"] > expire) return callback(null, res["value"]);
+      if (res["expire"] > expire) return void callback(null, res["value"]);
 
       callback();
     });
@@ -194,10 +194,10 @@ function mongoPop(key, callback) {
     null,
     { remove: true },
     (err, res) => {
-      if (err || !res["value"]) return callback(err);
+      if (err || !res["value"]) return void callback(err);
 
       if (res["value"]["expire"] > new Date(Date.now() - mongoTimeOffset))
-        return callback(null, res["value"]["value"]);
+        return void callback(null, res["value"]["value"]);
 
       callback();
     }

lib/cwmp.js

@@ -65,7 +65,7 @@ function writeResponse(sessionContext, res, close) {
       res.data +
       "\n\n";
     fs.appendFile(`./debug/${sessionContext.deviceId}.dump`, dump, err => {
-      if (err) return throwError(err);
+      if (err) throwError(err);
     });
   }
 
@@ -78,7 +78,7 @@ function writeResponse(sessionContext, res, close) {
       });
     } else if (close) {
       endSession(sessionContext, (err, isNew) => {
-        if (err) return throwError(err);
+        if (err) return void throwError(err);
 
         if (isNew) {
           logger.accessInfo({
@@ -115,7 +115,7 @@ function writeResponse(sessionContext, res, close) {
 
   if (compress) {
     compress(res.data, (err, data) => {
-      if (err) return throwError(err, sessionContext.httpResponse);
+      if (err) return void throwError(err, sessionContext.httpResponse);
 
       res.headers["Content-Length"] = data.length;
       sessionContext.httpResponse.writeHead(res.code, res.headers);
@@ -187,7 +187,7 @@ function recordFault(sessionContext, fault, provisions, channels) {
 
 function inform(sessionContext, rpc) {
   session.inform(sessionContext, rpc.cpeRequest, (err, acsResponse) => {
-    if (err) return throwError(err, sessionContext.httpResponse);
+    if (err) return void throwError(err, sessionContext.httpResponse);
 
     const res = soap.response({
       id: rpc.id,
@@ -213,7 +213,7 @@ function transferComplete(sessionContext, rpc) {
     sessionContext,
     rpc.cpeRequest,
     (err, acsResponse, operation, fault) => {
-      if (err) return throwError(err, sessionContext.httpResponse);
+      if (err) return void throwError(err, sessionContext.httpResponse);
 
       if (!operation) {
         logger.accessWarn({
@@ -279,7 +279,7 @@ function appendProvisions(original, toAppend) {
 function applyPresets(sessionContext) {
   const deviceData = sessionContext.deviceData;
   localCache.getPresets((err, presetsHash, presets) => {
-    if (err) return throwError(err, sessionContext.httpResponse);
+    if (err) return void throwError(err, sessionContext.httpResponse);
 
     // Filter presets based on existing faults
     const blackList = {};
@@ -361,15 +361,15 @@ function applyPresets(sessionContext) {
       sessionContext,
       declarations,
       (err, flt, reqId, acsReq) => {
-        if (err) return throwError(err, sessionContext.httpResponse);
+        if (err) return void throwError(err, sessionContext.httpResponse);
 
         if (flt) {
           recordFault(sessionContext, flt);
           session.clearProvisions(sessionContext);
-          return applyPresets(sessionContext);
+          return void applyPresets(sessionContext);
         }
 
-        if (acsReq) return sendAcsRequest(sessionContext, reqId, acsReq);
+        if (acsReq) return void sendAcsRequest(sessionContext, reqId, acsReq);
 
         session.clearProvisions(sessionContext);
 
@@ -428,7 +428,7 @@ function applyPresets(sessionContext) {
           for (const f of Object.values(sessionContext.faults))
             delete f.retryNow;
           session.clearProvisions(sessionContext);
-          return sendAcsRequest(sessionContext);
+          return void sendAcsRequest(sessionContext);
         }
 
         deviceData.timestamps.dirty = 0;
@@ -437,12 +437,12 @@ function applyPresets(sessionContext) {
           sessionContext,
           null,
           (err, fault, id, acsRequest) => {
-            if (err) return throwError(err, sessionContext.httpResponse);
+            if (err) return void throwError(err, sessionContext.httpResponse);
 
             if (fault) {
               recordFault(sessionContext, fault);
               session.clearProvisions(sessionContext);
-              return applyPresets(sessionContext);
+              return void applyPresets(sessionContext);
             }
 
             if (!acsRequest) {
@@ -455,13 +455,13 @@ function applyPresets(sessionContext) {
                 }
               }
 
-              if (whiteList != null) return applyPresets(sessionContext);
+              if (whiteList != null) return void applyPresets(sessionContext);
 
               if (
                 sessionContext.deviceData.timestamps.dirty > 1 ||
                 sessionContext.deviceData.attributes.dirty > 1
               )
-                return applyPresets(sessionContext);
+                return void applyPresets(sessionContext);
             }
 
             sendAcsRequest(sessionContext, id, acsRequest);
@@ -474,15 +474,15 @@ function applyPresets(sessionContext) {
 
 function nextRpc(sessionContext) {
   session.rpcRequest(sessionContext, null, (err, fault, id, acsRequest) => {
-    if (err) return throwError(err, sessionContext.httpResponse);
+    if (err) return void throwError(err, sessionContext.httpResponse);
 
     if (fault) {
       recordFault(sessionContext, fault);
       session.clearProvisions(sessionContext);
-      return nextRpc(sessionContext);
+      return void nextRpc(sessionContext);
     }
 
-    if (acsRequest) return sendAcsRequest(sessionContext, id, acsRequest);
+    if (acsRequest) return void sendAcsRequest(sessionContext, id, acsRequest);
 
     for (let [channel, flags] of Object.entries(sessionContext.channels)) {
       if (flags && sessionContext.faults[channel]) {
@@ -534,7 +534,7 @@ function nextRpc(sessionContext) {
       t => !sessionContext.faults[`task_${t._id}`]
     );
 
-    if (!task) return applyPresets(sessionContext);
+    if (!task) return void applyPresets(sessionContext);
 
     let alias;
 
@@ -589,7 +589,7 @@ function nextRpc(sessionContext) {
         ]);
         break;
       default:
-        return throwError(
+        return void throwError(
           new Error("Task name not recognized"),
           sessionContext.httpResponse
         );
@@ -611,9 +611,9 @@ function endSession(sessionContext, callback) {
     err => {
       if (err) {
         if (counter & 1) callback(err);
-        return (counter = 0);
+        return void (counter = 0);
       }
-      if ((counter -= 2) === 1) return callback(null, sessionContext.new);
+      if ((counter -= 2) === 1) callback(null, sessionContext.new);
     }
   );
 
@@ -629,7 +629,7 @@ function endSession(sessionContext, callback) {
           err => {
             if (err) {
               if (counter & 1) callback(err);
-              return (counter = 0);
+              return void (counter = 0);
             }
             if ((counter -= 2) === 1) callback(null, sessionContext.new);
           }
@@ -638,7 +638,7 @@ function endSession(sessionContext, callback) {
         db.deleteOperation(sessionContext.deviceId, k, err => {
           if (err) {
             if (counter & 1) callback(err);
-            return (counter = 0);
+            return void (counter = 0);
           }
           if ((counter -= 2) === 1) callback(null, sessionContext.new);
         });
@@ -652,7 +652,7 @@ function endSession(sessionContext, callback) {
     db.clearTasks(sessionContext.deviceId, sessionContext.doneTasks, err => {
       if (err) {
         if (counter & 1) callback(err);
-        return (counter = 0);
+        return void (counter = 0);
       }
       if ((counter -= 2) === 1) callback(null, sessionContext.new);
     });
@@ -671,7 +671,7 @@ function endSession(sessionContext, callback) {
           err => {
             if (err) {
               if (counter & 1) callback(err);
-              return (counter = 0);
+              return void (counter = 0);
             }
             if ((counter -= 2) === 1) callback(null, sessionContext.new);
           }
@@ -680,7 +680,7 @@ function endSession(sessionContext, callback) {
         db.deleteFault(sessionContext.deviceId, k, err => {
           if (err) {
             if (counter & 1) callback(err);
-            return (counter = 0);
+            return void (counter = 0);
           }
           if ((counter -= 2) === 1) callback(null, sessionContext.new);
         });
@@ -699,9 +699,9 @@ function endSession(sessionContext, callback) {
       err => {
         if (err) {
           if (counter & 1) callback(err);
-          return (counter = 0);
+          return void (counter = 0);
         }
-        if ((counter -= 2) === 1) return callback(null, sessionContext.new);
+        if ((counter -= 2) === 1) callback(null, sessionContext.new);
       }
     );
   }
@@ -710,7 +710,7 @@ function endSession(sessionContext, callback) {
 
 function sendAcsRequest(sessionContext, id, acsRequest) {
   if (!acsRequest)
-    return writeResponse(sessionContext, soap.response(null), true);
+    return void writeResponse(sessionContext, soap.response(null), true);
 
   if (acsRequest.name === "Download") {
     if (!acsRequest.url) {
@@ -724,14 +724,14 @@ function sendAcsRequest(sessionContext, id, acsRequest) {
     }
 
     if (acsRequest.fileSize == null) {
-      return localCache.getFiles((err, hash, files) => {
+      return void localCache.getFiles((err, hash, files) => {
-        if (err) return throwError(err, sessionContext.httpResponse);
+        if (err) return void throwError(err, sessionContext.httpResponse);
 
         if (files[acsRequest.fileName])
           acsRequest.fileSize = files[acsRequest.fileName].length;
         else acsRequest.fileSize = 0;
 
-        return sendAcsRequest(sessionContext, id, acsRequest);
+        sendAcsRequest(sessionContext, id, acsRequest);
       });
     }
   }
@@ -756,14 +756,14 @@ function getSession(connection, sessionId, callback) {
   const sessionContext = currentSessions.get(connection);
   if (sessionContext) {
     currentSessions.delete(connection);
-    return callback(null, sessionContext);
+    return void callback(null, sessionContext);
   }
 
-  if (!sessionId) return callback();
+  if (!sessionId) return void callback();
 
   setTimeout(() => {
     cache.pop(`session_${sessionId}`, (err, sessionContextString) => {
-      if (err || !sessionContextString) return callback(err);
+      if (err || !sessionContextString) return void callback(err);
       session.deserialize(sessionContextString, callback);
     });
   }, 100);
@@ -792,18 +792,18 @@ function onConnection(socket) {
 
     const timeout =
       sessionContext.lastActivity + sessionContext.timeout * 1000 - now;
-    if (timeout <= 0) return logger.accessError(timeoutMsg);
+    if (timeout <= 0) return void logger.accessError(timeoutMsg);
 
     setTimeout(() => {
-      return cache.get(
+      cache.get(
         `session_${sessionContext.sessionId}`,
         (err, sessionContextString) => {
-          if (err) return throwError(err);
+          if (err) return void throwError(err);
 
           if (!sessionContextString) return;
 
           session.deserialize(sessionContextString, (err, _sessionContext) => {
-            if (err) return throwError(err);
+            if (err) return void throwError(err);
             if (_sessionContext.lastActivity === lastActivity)
               logger.accessError(timeoutMsg);
           });
@@ -812,13 +812,13 @@ function onConnection(socket) {
     }, timeout + 1000).unref();
 
     session.serialize(sessionContext, (err, sessionContextString) => {
-      if (err) return throwError(err);
+      if (err) return void throwError(err);
       cache.set(
         `session_${sessionContext.sessionId}`,
         sessionContextString,
         Math.ceil(timeout / 1000) + 3,
         err => {
-          if (err) return throwError(err);
+          if (err) return void throwError(err);
         }
       );
     });
@@ -843,11 +843,11 @@ setInterval(() => {
 
 function getDueTasksAndFaultsAndOperations(deviceId, timestamp, callback) {
   cache.get(`${deviceId}_tasks_faults_operations`, (err, res) => {
-    if (err) return callback(err);
+    if (err) return void callback(err);
 
     if (res) {
       res = JSON.parse(res);
-      return callback(
+      return void callback(
         null,
         res.tasks || [],
         res.faults || {},
@@ -860,7 +860,7 @@ function getDueTasksAndFaultsAndOperations(deviceId, timestamp, callback) {
     db.getFaults(deviceId, (err, _faults) => {
       if (err) {
         if (callback) callback(err);
-        return (callback = null);
+        return void (callback = null);
       }
       faults = _faults;
       if (tasks && operations)
@@ -870,7 +870,7 @@ function getDueTasksAndFaultsAndOperations(deviceId, timestamp, callback) {
     db.getDueTasks(deviceId, timestamp, (err, dueTasks, nextTimestamp) => {
       if (err) {
         if (callback) callback(err);
-        return (callback = null);
+        return void (callback = null);
       }
       tasks = dueTasks;
       cacheUntil = nextTimestamp || 0;
@@ -881,7 +881,7 @@ function getDueTasksAndFaultsAndOperations(deviceId, timestamp, callback) {
     db.getOperations(deviceId, (err, _operations) => {
       if (err) {
         if (callback) callback(err);
-        return (callback = null);
+        return void (callback = null);
       }
       operations = _operations;
       if (faults && tasks)
@@ -950,14 +950,14 @@ function processRequest(sessionContext, rpc) {
       });
       writeResponse(sessionContext, res);
     } else {
-      return throwError(
+      return void throwError(
         new Error("ACS method not supported"),
         sessionContext.httpResponse
       );
     }
   } else if (rpc.cpeResponse) {
     session.rpcResponse(sessionContext, rpc.id, rpc.cpeResponse, err => {
-      if (err) return throwError(err, sessionContext.httpResponse);
+      if (err) return void throwError(err, sessionContext.httpResponse);
       nextRpc(sessionContext);
     });
   } else if (rpc.cpeFault) {
@@ -968,7 +968,7 @@ function processRequest(sessionContext, rpc) {
     });
 
     session.rpcFault(sessionContext, rpc.id, rpc.cpeFault, (err, fault) => {
-      if (err) return throwError(err, sessionContext.httpResponse);
+      if (err) return void throwError(err, sessionContext.httpResponse);
       if (fault) {
         recordFault(sessionContext, fault);
         session.clearProvisions(sessionContext);
@@ -978,7 +978,7 @@ function processRequest(sessionContext, rpc) {
   } else {
     // CPE sent empty response
     session.timeoutOperations(sessionContext, (err, faults, operations) => {
-      if (err) return throwError(err, sessionContext.httpResponse);
+      if (err) return void throwError(err, sessionContext.httpResponse);
 
       for (let i of faults) {
         for (let [k, v] of Object.entries(operations[i].retries))
@@ -1080,7 +1080,7 @@ function listener(httpRequest, httpResponse) {
           body +
           "\n\n";
         fs.appendFile(`./debug/${sessionContext.deviceId}.dump`, dump, err => {
-          if (err) return throwError(err);
+          if (err) return void throwError(err);
         });
       }
 
@@ -1088,7 +1088,7 @@ function listener(httpRequest, httpResponse) {
     }
 
     getSession(httpRequest.connection, sessionId, (err, sessionContext) => {
-      if (err) return throwError(err, httpResponse);
+      if (err) return void throwError(err, httpResponse);
 
       if (sessionContext) {
         sessionContext.httpRequest = httpRequest;
@@ -1155,7 +1155,7 @@ function listener(httpRequest, httpResponse) {
           stats.concurrentRequests -= 1;
           return;
         }
-        return parsedRpc(sessionContext, rpc, parseWarnings);
+        return void parsedRpc(sessionContext, rpc, parseWarnings);
       }
 
       if (!(rpc.cpeRequest && rpc.cpeRequest.name === "Inform")) {
@@ -1180,7 +1180,7 @@ function listener(httpRequest, httpResponse) {
         rpc.cwmpVersion,
         rpc.sessionTimeout || config.get("SESSION_TIMEOUT", deviceId),
         (err, _sessionContext) => {
-          if (err) return throwError(err, httpResponse);
+          if (err) return void throwError(err, httpResponse);
 
           _sessionContext.httpRequest = httpRequest;
           _sessionContext.httpResponse = httpResponse;
@@ -1191,7 +1191,7 @@ function listener(httpRequest, httpResponse) {
             deviceId,
             _sessionContext.timestamp,
             (err, dueTasks, faults, operations, cacheUntil) => {
-              if (err) return throwError(err, httpResponse);
+              if (err) return void throwError(err, httpResponse);
 
               _sessionContext.tasks = dueTasks;
               _sessionContext.operations = operations;

lib/db.js

@@ -37,7 +37,7 @@ function connect(callback) {
   mongodb.MongoClient.connect(
     config.get("MONGODB_CONNECTION_URL"),
     (err, db) => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
       exports.mongoDb = db;
       db.collection("tasks", (err, collection) => {
@@ -47,63 +47,63 @@ function connect(callback) {
 
         if (--callbackCounter === 0 || err) {
           callbackCounter = 0;
-          return callback(err);
+          callback(err);
         }
       });
       db.collection("devices", (err, collection) => {
         exports.devicesCollection = devicesCollection = collection;
         if (--callbackCounter === 0 || err) {
           callbackCounter = 0;
-          return callback(err);
+          callback(err);
         }
       });
       db.collection("presets", (err, collection) => {
         exports.presetsCollection = presetsCollection = collection;
         if (--callbackCounter === 0 || err) {
           callbackCounter = 0;
-          return callback(err);
+          callback(err);
         }
       });
       db.collection("objects", (err, collection) => {
         exports.objectsCollection = objectsCollection = collection;
         if (--callbackCounter === 0 || err) {
           callbackCounter = 0;
-          return callback(err);
+          callback(err);
         }
       });
       db.collection("fs.files", (err, collection) => {
         exports.filesCollection = filesCollection = collection;
         if (--callbackCounter === 0 || err) {
           callbackCounter = 0;
-          return callback(err);
+          callback(err);
         }
       });
       db.collection("provisions", (err, collection) => {
         exports.provisionsCollection = provisionsCollection = collection;
         if (--callbackCounter === 0 || err) {
           callbackCounter = 0;
-          return callback(err);
+          callback(err);
         }
       });
       db.collection("virtualParameters", (err, collection) => {
         exports.virtualParametersCollection = virtualParametersCollection = collection;
         if (--callbackCounter === 0 || err) {
           callbackCounter = 0;
-          return callback(err);
+          callback(err);
         }
       });
       db.collection("faults", (err, collection) => {
         exports.faultsCollection = faultsCollection = collection;
         if (--callbackCounter === 0 || err) {
           callbackCounter = 0;
-          return callback(err);
+          callback(err);
         }
       });
-      return db.collection("operations", (err, collection) => {
+      db.collection("operations", (err, collection) => {
         exports.operationsCollection = operationsCollection = collection;
         if (--callbackCounter === 0 || err) {
           callbackCounter = 0;
-          return callback(err);
+          callback(err);
         }
       });
     }
@@ -285,7 +285,7 @@ function fetchDevice(id, timestamp, patterns, callback) {
   else proj = projection;
 
   devicesCollection.findOne({ _id: id }, proj, (err, device) => {
-    if (err || !device) return callback(err);
+    if (err || !device) return void callback(err);
 
     function storeParams(obj, path, ts, descendantsFetched, projTree) {
       let thisFetched = false;
@@ -731,7 +731,7 @@ function saveDevice(deviceId, deviceData, isNew, sessionTimestamp, callback) {
     if (!Object.keys(v).length) delete update[k];
   }
 
-  if (!Object.keys(update).length) return callback();
+  if (!Object.keys(update).length) return void callback();
 
   // Mongo doesn't allow $addToSet and $pull at the same time
   let update2;
@@ -745,13 +745,21 @@ function saveDevice(deviceId, deviceData, isNew, sessionTimestamp, callback) {
     update,
     { upsert: isNew },
     (err, result) => {
-      if (!err && result.result.n !== 1)
+      if (!err && result.result.n !== 1) {
-        return callback(new Error(`Device ${deviceId} not found in database`));
+        return void callback(
+          new Error(`Device ${deviceId} not found in database`)
+        );
+      }
 
-      if (update2)
+      if (update2) {
-        return devicesCollection.update({ _id: deviceId }, update2, callback);
+        return void devicesCollection.update(
+          { _id: deviceId },
+          update2,
+          callback
+        );
+      }
 
-      return callback(err);
+      callback(err);
     }
   );
 }
@@ -798,14 +806,14 @@ function getDueTasks(deviceId, timestamp, callback) {
   let f;
   cur.nextObject(
     (f = (err, task) => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
-      if (!task) return callback(null, tasks, null);
+      if (!task) return void callback(null, tasks, null);
 
       if (task.timestamp) task.timestamp = +task.timestamp;
       if (task.expiry) task.expiry = +task.expiry;
       if (task.timestamp >= timestamp)
-        return callback(null, tasks, +task.timestamp);
+        return void callback(null, tasks, +task.timestamp);
       task._id = String(task._id);
 
       tasks.push(task);
@@ -818,7 +826,7 @@ function getDueTasks(deviceId, timestamp, callback) {
         else q = { _id: task.file };
 
         filesCollection.find(q).toArray((err, res) => {
-          if (err) return callback(err);
+          if (err) return void callback(err);
 
           if (res[0]) {
             if (!task.fileType) task.fileType = res[0].metadata.fileType;
@@ -847,7 +855,7 @@ function getOperations(deviceId, callback) {
   operationsCollection
     .find({ _id: { $regex: `^${common.escapeRegExp(deviceId)}\\:` } })
     .toArray((err, res) => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
       const operations = {};
       for (const r of res) {

lib/extensions.js

@@ -65,10 +65,7 @@ function run(args, callback) {
   setTimeout(() => {
     if (id in jobs) {
       delete jobs[id];
-      return callback(null, {
+      callback(null, { code: "timeout", message: "Extension timed out" });
-        code: "timeout",
-        message: "Extension timed out"
-      });
     }
   }, TIMEOUT);
 

lib/local-cache.js

@@ -70,7 +70,7 @@ function flattenObject(src, prefix = "", dst = {}) {
 
 function refresh(callback) {
   if (!nextRefresh) {
-    return setTimeout(() => {
+    return void setTimeout(() => {
       refresh(callback);
     }, 20);
   }
@@ -79,15 +79,15 @@ function refresh(callback) {
   const now = Date.now();
 
   cache.get("presets_hash", (err, dbHash) => {
-    if (err) return callback(err);
+    if (err) return void callback(err);
 
     if (hash && dbHash === hash) {
       nextRefresh = now + (REFRESH - (now % REFRESH));
-      return callback();
+      return void callback();
     }
 
     cache.lock("presets_hash_lock", 3, (err, unlockOrExtend) => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
       let counter = 3;
 
@@ -95,13 +95,13 @@ function refresh(callback) {
       db.getPresets((err, res) => {
         if (err) {
           if (counter & 1) callback(err);
-          return (counter = 0);
+          return void (counter = 0);
         }
 
         db.getObjects((err, objects) => {
           if (err) {
             if (counter & 1) callback(err);
-            return (counter = 0);
+            return void (counter = 0);
           }
 
           objects = objects.map(obj => {
@@ -212,7 +212,7 @@ function refresh(callback) {
                 default:
                   if (counter & 1)
                     callback(new Error(`Unknown configuration type ${c.type}`));
-                  return (counter = 0);
+                  return void (counter = 0);
               }
             }
 
@@ -241,7 +241,7 @@ function refresh(callback) {
       db.getProvisions((err, res) => {
         if (err) {
           if (counter & 1) callback(err);
-          return (counter = 0);
+          return void (counter = 0);
         }
 
         provisions = {};
@@ -271,7 +271,7 @@ function refresh(callback) {
       db.getVirtualParameters((err, res) => {
         if (err) {
           if (counter & 1) callback(err);
-          return (counter = 0);
+          return void (counter = 0);
         }
 
         virtualParameters = {};
@@ -301,7 +301,7 @@ function refresh(callback) {
       db.getFiles((err, res) => {
         if (err) {
           if (counter & 1) callback(err);
-          return (counter = 0);
+          return void (counter = 0);
         }
 
         files = {};
@@ -336,7 +336,7 @@ function refresh(callback) {
 }
 
 function getPresets(callback) {
-  if (Date.now() < nextRefresh) return callback(null, hash, presets);
+  if (Date.now() < nextRefresh) return void callback(null, hash, presets);
 
   refresh(err => {
     callback(err, hash, presets);
@@ -344,7 +344,7 @@ function getPresets(callback) {
 }
 
 function getFiles(callback) {
-  if (Date.now() < nextRefresh) return callback(null, hash, files);
+  if (Date.now() < nextRefresh) return void callback(null, hash, files);
 
   refresh(err => {
     callback(err, hash, files);
@@ -353,7 +353,7 @@ function getFiles(callback) {
 
 function getProvisionsAndVirtualParameters(callback) {
   if (Date.now() < nextRefresh)
-    return callback(null, hash, provisions, virtualParameters);
+    return void callback(null, hash, provisions, virtualParameters);
 
   refresh(err => {
     callback(err, hash, provisions, virtualParameters);

lib/nbi.js

@@ -84,10 +84,10 @@ function listener(request, response) {
         const preset = JSON.parse(body);
         preset._id = presetName;
         db.presetsCollection.save(preset, err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           cache.del("presets_hash", err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             response.writeHead(200);
             response.end();
@@ -95,10 +95,10 @@ function listener(request, response) {
         });
       } else if (request.method === "DELETE") {
         db.presetsCollection.remove({ _id: presetName }, err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           cache.del("presets_hash", err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             response.writeHead(200);
             response.end();
@@ -116,10 +116,10 @@ function listener(request, response) {
         const object = JSON.parse(body);
         object._id = objectName;
         db.objectsCollection.save(object, err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           cache.del("presets_hash", err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             response.writeHead(200);
             response.end();
@@ -127,10 +127,10 @@ function listener(request, response) {
         });
       } else if (request.method === "DELETE") {
         db.objectsCollection.remove({ _id: objectName }, err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           cache.del("presets_hash", err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             response.writeHead(200);
             response.end();
@@ -159,10 +159,10 @@ function listener(request, response) {
         }
 
         db.provisionsCollection.save(object, err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           cache.del("presets_hash", err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             response.writeHead(200);
             response.end();
@@ -170,10 +170,10 @@ function listener(request, response) {
         });
       } else if (request.method === "DELETE") {
         db.provisionsCollection.remove({ _id: provisionName }, err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           cache.del("presets_hash", err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             response.writeHead(200);
             response.end();
@@ -202,10 +202,10 @@ function listener(request, response) {
         }
 
         db.virtualParametersCollection.save(object, err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           cache.del("presets_hash", err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             response.writeHead(200);
             response.end();
@@ -215,10 +215,10 @@ function listener(request, response) {
         db.virtualParametersCollection.remove(
           { _id: virtualParameterName },
           err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             cache.del("presets_hash", err => {
-              if (err) return throwError(err, response);
+              if (err) return void throwError(err, response);
 
               response.writeHead(200);
               response.end();
@@ -239,7 +239,7 @@ function listener(request, response) {
           { $addToSet: { _tags: tag } },
           { safe: true },
           err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
             response.writeHead(200);
             response.end();
           }
@@ -250,7 +250,7 @@ function listener(request, response) {
           { $pull: { _tags: tag } },
           { safe: true },
           err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             response.writeHead(200);
             response.end();
@@ -268,15 +268,15 @@ function listener(request, response) {
         const deviceId = faultId.split(":", 1)[0];
         const channel = faultId.slice(deviceId.length + 1);
         db.faultsCollection.remove({ _id: faultId }, err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           if (channel.startsWith("task_")) {
             const objId = new mongodb.ObjectID(channel.slice(5));
-            return db.tasksCollection.remove({ _id: objId }, err => {
+            return void db.tasksCollection.remove({ _id: objId }, err => {
-              if (err) return throwError(err, response);
+              if (err) return void throwError(err, response);
 
               cache.del(`${deviceId}_tasks_faults_operations`, err => {
-                if (err) return throwError(err, response);
+                if (err) return void throwError(err, response);
 
                 response.writeHead(200);
                 response.end();
@@ -285,7 +285,7 @@ function listener(request, response) {
           }
 
           cache.del(`${deviceId}_tasks_faults_operations`, err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             response.writeHead(200);
             response.end();
@@ -304,10 +304,10 @@ function listener(request, response) {
           const task = JSON.parse(body);
           task.device = deviceId;
           apiFunctions.insertTasks(task, err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             cache.del(`${deviceId}_tasks_faults_operations`, err => {
-              if (err) return throwError(err, response);
+              if (err) return void throwError(err, response);
 
               if (urlParts.query.connection_request != null) {
                 apiFunctions.connectionRequest(deviceId, err => {
@@ -328,7 +328,7 @@ function listener(request, response) {
                     task._id,
                     DEVICE_ONLINE_THRESHOLD,
                     (err, status) => {
-                      if (err) return throwError(err, response);
+                      if (err) return void throwError(err, response);
 
                       if (status === "timeout") {
                         response.writeHead(
@@ -343,7 +343,7 @@ function listener(request, response) {
                         db.tasksCollection.findOne(
                           { _id: task._id },
                           (err, task2) => {
-                            if (err) return throwError(err, response);
+                            if (err) return void throwError(err, response);
 
                             response.writeHead(202, "Task faulted", {
                               "Content-Type": "application/json"
@@ -397,7 +397,7 @@ function listener(request, response) {
             { _id: new mongodb.ObjectID(taskId) },
             { device: 1 },
             (err, task) => {
-              if (err) return throwError(err, response);
+              if (err) return void throwError(err, response);
 
               if (!task) {
                 response.writeHead(404);
@@ -409,15 +409,15 @@ function listener(request, response) {
               db.tasksCollection.remove(
                 { _id: new mongodb.ObjectID(taskId) },
                 err => {
-                  if (err) return throwError(err, response);
+                  if (err) return void throwError(err, response);
 
                   db.faultsCollection.remove(
                     { _id: `${deviceId}:task_${taskId}` },
                     err => {
-                      if (err) return throwError(err, response);
+                      if (err) return void throwError(err, response);
 
                       cache.del(`${deviceId}_tasks_faults_operations`, err => {
-                        if (err) return throwError(err, response);
+                        if (err) return void throwError(err, response);
 
                         response.writeHead(200);
                         response.end();
@@ -438,16 +438,16 @@ function listener(request, response) {
             { _id: new mongodb.ObjectID(taskId) },
             { device: 1 },
             (err, task) => {
-              if (err) return throwError(err, response);
+              if (err) return void throwError(err, response);
 
               const deviceId = task.device;
               db.faultsCollection.remove(
                 { _id: `${deviceId}:task_${taskId}` },
                 err => {
-                  if (err) return throwError(err, response);
+                  if (err) return void throwError(err, response);
 
                   cache.del(`${deviceId}_tasks_faults_operations`, err => {
-                    if (err) return throwError(err, response);
+                    if (err) return void throwError(err, response);
 
                     response.writeHead(200);
                     response.end();
@@ -479,13 +479,13 @@ function listener(request, response) {
           metadata: metadata
         });
         gs.open(err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           gs.write(body, err => {
-            if (err) return throwError(err, response);
+            if (err) return void throwError(err, response);
 
             gs.close(err => {
-              if (err) return throwError(err, response);
+              if (err) return void throwError(err, response);
 
               response.writeHead(201);
               response.end();
@@ -494,7 +494,7 @@ function listener(request, response) {
         });
       } else if (request.method === "DELETE") {
         mongodb.GridStore.unlink(db.mongoDb, filename, err => {
-          if (err) return throwError(err, response);
+          if (err) return void throwError(err, response);
 
           response.writeHead(200);
           response.end();
@@ -529,7 +529,7 @@ function listener(request, response) {
         DELETE_DEVICE_REGEX.exec(urlParts.pathname)[1]
       );
       apiFunctions.deleteDevice(deviceId, err => {
-        if (err) return throwError(err, response);
+        if (err) return void throwError(err, response);
 
         response.writeHead(200);
         response.end();
@@ -617,7 +617,7 @@ function listener(request, response) {
         cur.limit((limit = parseInt(urlParts.query.limit)));
 
       cur.count(false, (err, total) => {
-        if (err) return throwError(err);
+        if (err) return void throwError(err);
 
         response.writeHead(200, {
           "Content-Type": "application/json",
@@ -646,6 +646,8 @@ function listener(request, response) {
             response.end("\n]");
             return false;
           }
+
+          return null;
         });
       });
     } else {

lib/sandbox.js

@@ -34,6 +34,8 @@ const COMMIT = Symbol();
 // Used to execute extensions and restart
 const EXT = Symbol();
 
+const UNDEFINED = undefined;
+
 const context = vm.createContext();
 
 let state;
@@ -117,14 +119,14 @@ class ParameterWrapper {
             );
           }
 
-          if (!unpacked.length) return undefined;
+          if (!unpacked.length) return UNDEFINED;
 
           let attr = state.sessionContext.deviceData.attributes.get(
             unpacked[0],
             state.revision
           )[attrName];
 
-          if (!attr) return undefined;
+          if (!attr) return UNDEFINED;
 
           return attr[1];
         }
@@ -144,7 +146,7 @@ class ParameterWrapper {
           );
         }
 
-        if (!unpacked.length) return undefined;
+        if (!unpacked.length) return UNDEFINED;
 
         return unpacked[0].join(".");
       }
@@ -163,7 +165,7 @@ class ParameterWrapper {
           );
         }
 
-        if (!unpacked.length) return undefined;
+        if (!unpacked.length) return UNDEFINED;
 
         return unpacked.length;
       }
@@ -349,7 +351,7 @@ function run(
   } catch (err) {
     if (err === COMMIT) status = 1;
     else if (err === EXT) status = 2;
-    else return callback(null, errorToFault(err));
+    else return void callback(null, errorToFault(err));
   }
 
   let _state = state;
@@ -370,13 +372,13 @@ function run(
       (err, fault) => {
         if (err || fault) {
           if (counter & 1) callback(err, fault);
-          return (counter = 0);
+          return void (counter = 0);
         }
         if ((counter -= 2) === 1) {
           if (status === 2) {
-            return run.apply(null, args);
+            return void run.apply(null, args);
           } else {
-            return callback(
+            return void callback(
               null,
               null,
               _state.clear,
@@ -392,9 +394,9 @@ function run(
 
   if ((counter -= 2) === 1) {
     if (status === 2) {
-      return run.apply(null, args);
+      run.apply(null, args);
     } else {
-      return callback(
+      callback(
         null,
         null,
         _state.clear,

lib/server.js

@@ -43,7 +43,7 @@ const { listener, onConnection } = require(`./${service}`);
 let server;
 
 function closeServer(timeout, callback) {
-  if (!server) return callback();
+  if (!server) return void callback();
 
   setTimeout(() => {
     if (!callback) return;

lib/session.js

@@ -69,7 +69,7 @@ function init(deviceId, cwmpVersion, timeout, callback) {
 
   localCache.getProvisionsAndVirtualParameters(
     (err, hash, provisions, virtualParameters) => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
       sessionContext.presetsHash = hash;
       provisionsCache.set(sessionContext, provisions);
@@ -80,7 +80,8 @@ function init(deviceId, cwmpVersion, timeout, callback) {
 }
 
 function loadParameters(sessionContext, callback) {
-  if (!sessionContext.toLoad || !sessionContext.toLoad.size) return callback();
+  if (!sessionContext.toLoad || !sessionContext.toLoad.size)
+    return void callback();
 
   const toLoad = Array.from(sessionContext.toLoad.entries());
   db.fetchDevice(
@@ -88,7 +89,7 @@ function loadParameters(sessionContext, callback) {
     sessionContext.timestamp,
     toLoad,
     (err, parameters, loaded) => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
       if (!parameters) {
         // Device not available in database, mark as new
@@ -211,7 +212,7 @@ function inform(sessionContext, rpcReq, callback) {
   for (const p of params) loadPath(sessionContext, p[0]);
 
   loadParameters(sessionContext, err => {
-    if (err) return callback(err);
+    if (err) return void callback(err);
 
     if (sessionContext.new) {
       params.push([
@@ -267,7 +268,8 @@ function transferComplete(sessionContext, rpcReq, callback) {
   const commandKey = rpcReq.commandKey;
   const operation = sessionContext.operations[commandKey];
 
-  if (!operation) return callback(null, { name: "TransferCompleteResponse" });
+  if (!operation)
+    return void callback(null, { name: "TransferCompleteResponse" });
 
   const instance = operation.args.instance;
 
@@ -276,7 +278,7 @@ function transferComplete(sessionContext, rpcReq, callback) {
   sessionContext.operationsTouched[commandKey] = 1;
 
   if (rpcReq.faultStruct && rpcReq.faultStruct.faultCode !== "0") {
-    return revertDownloadParameters(
+    return void revertDownloadParameters(
       sessionContext,
       operation.args.instance,
       err => {
@@ -295,7 +297,7 @@ function transferComplete(sessionContext, rpcReq, callback) {
   loadPath(sessionContext, ["Downloads", instance, "*"]);
 
   loadParameters(sessionContext, err => {
-    if (err) return callback(err);
+    if (err) return void callback(err);
 
     let toClear = null;
     const timestamp = sessionContext.timestamp + sessionContext.iteration + 1;
@@ -390,7 +392,7 @@ function revertDownloadParameters(sessionContext, instance, callback) {
   loadPath(sessionContext, ["Downloads", instance, "*"]);
 
   loadParameters(sessionContext, err => {
-    if (err) return callback(err);
+    if (err) return void callback(err);
 
     const timestamp = sessionContext.timestamp + sessionContext.iteration + 1;
 
@@ -434,8 +436,11 @@ function timeoutOperations(sessionContext, callback) {
   let counter = 3;
 
   for (const [commandKey, operation] of Object.entries(operations)) {
-    if (operation.name !== "Download")
+    if (operation.name !== "Download") {
-      return callback(new Error(`Unknown operation name ${operation.name}`));
+      return void callback(
+        new Error(`Unknown operation name ${operation.name}`)
+      );
+    }
 
     const DOWNLOAD_TIMEOUT =
       config.get("DOWNLOAD_TIMEOUT", sessionContext.deviceId) * 1000;
@@ -458,7 +463,7 @@ function timeoutOperations(sessionContext, callback) {
       revertDownloadParameters(sessionContext, operation.args.instance, err => {
         if (err) {
           if (counter & 1) callback(err);
-          return (counter = 0);
+          return void (counter = 0);
         }
         if ((counter -= 2) === 1) callback(null, faults, operations);
       });
@@ -575,7 +580,7 @@ function runProvisions(
       (err, _fault, _clear, _declarations, _done) => {
         if (err || _fault) {
           if (counter & 1) callback(err, _fault);
-          return (counter = 0);
+          return void (counter = 0);
         }
         done = done && _done;
         allDeclarations[j] = _declarations || [];
@@ -626,7 +631,7 @@ function runVirtualParameters(
       (err, _fault, _clear, _declarations, _done, _returnValue) => {
         if (err || _fault) {
           if (counter & 1) callback(err, _fault);
-          return (counter = 0);
+          return void (counter = 0);
         }
 
         done = done && _done;
@@ -642,7 +647,7 @@ function runVirtualParameters(
               });
             }
 
-            return (counter = 0);
+            return void (counter = 0);
           }
 
           const ret = {};
@@ -659,7 +664,7 @@ function runVirtualParameters(
               });
             }
 
-            return (counter = 0);
+            return void (counter = 0);
           }
 
           if (_returnValue.value != null) {
@@ -697,7 +702,7 @@ function runVirtualParameters(
                 });
               }
 
-              return (counter = 0);
+              return void (counter = 0);
             }
             ret.value = device.sanitizeParameterValue(_returnValue.value);
           } else if (provision[1].value != null || provision[2].value != null) {
@@ -708,7 +713,7 @@ function runVirtualParameters(
               });
             }
 
-            return (counter = 0);
+            return void (counter = 0);
           }
           virtualParameterUpdates[j] = ret;
         }
@@ -716,7 +721,7 @@ function runVirtualParameters(
         if ((counter -= 2) === 1) {
           allDeclarations = Array.prototype.concat.apply([], allDeclarations);
           allClear = Array.prototype.concat.apply([], allClear);
-          return callback(
+          callback(
             null,
             null,
             done ? virtualParameterUpdates : null,
@@ -731,7 +736,7 @@ function runVirtualParameters(
   if ((counter -= 2) === 1) {
     allDeclarations = Array.prototype.concat.apply([], allDeclarations);
     allClear = Array.prototype.concat.apply([], allClear);
-    return callback(
+    callback(
       null,
       null,
       done ? virtualParameterUpdates : null,
@@ -933,7 +938,7 @@ function runDeclarations(sessionContext, declarations) {
 
 function rpcRequest(sessionContext, _declarations, callback) {
   if (sessionContext.rpcRequest != null) {
-    return callback(
+    return void callback(
       null,
       null,
       generateRpcId(sessionContext),
@@ -947,7 +952,7 @@ function rpcRequest(sessionContext, _declarations, callback) {
     !(_declarations && _declarations.length) &&
     !sessionContext.provisions.length
   )
-    return callback();
+    return void callback();
 
   if (
     sessionContext.declarations.length <=
@@ -967,17 +972,17 @@ function rpcRequest(sessionContext, _declarations, callback) {
       provisions = sessionContext.virtualParameters[inception - 1];
     }
 
-    return run(
+    return void run(
       sessionContext,
       provisions,
       sessionContext.revisions[inception - 1] || 0,
       sessionContext.revisions[inception],
       (err, fault, ret, decs, toClear) => {
-        if (err) return callback(err);
+        if (err) return void callback(err);
 
         if (fault) {
           fault.timestamp = sessionContext.timestamp;
-          return callback(null, fault);
+          return void callback(null, fault);
         }
 
         // Enforce max clear timestamp
@@ -1006,10 +1011,10 @@ function rpcRequest(sessionContext, _declarations, callback) {
         }
 
         clear(sessionContext, toClear, err => {
-          if (err) return callback(err);
+          if (err) return void callback(err);
 
           loadParameters(sessionContext, err => {
-            if (err) return callback(err);
+            if (err) return void callback(err);
             rpcRequest(sessionContext, _declarations, callback);
           });
         });
@@ -1029,15 +1034,15 @@ function rpcRequest(sessionContext, _declarations, callback) {
         loadPath(sessionContext, ad[0]);
     }
 
-    return loadParameters(sessionContext, err => {
+    return void loadParameters(sessionContext, err => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
       rpcRequest(sessionContext, null, callback);
     });
   }
 
   if (sessionContext.rpcCount >= 255) {
-    return callback(null, {
+    return void callback(null, {
       code: "too_many_rpcs",
       message: "Too many RPC requests",
       timestamp: sessionContext.timestamp
@@ -1045,7 +1050,7 @@ function rpcRequest(sessionContext, _declarations, callback) {
   }
 
   if (sessionContext.revisions.length >= 8) {
-    return callback(null, {
+    return void callback(null, {
       code: "deeply_nested_vparams",
       message:
         "Virtual parameters are referencing other virtual parameters in a deeply nested manner",
@@ -1054,7 +1059,7 @@ function rpcRequest(sessionContext, _declarations, callback) {
   }
 
   if (sessionContext.cycle >= 255) {
-    return callback(null, {
+    return void callback(null, {
       code: "too_many_cycles",
       message: "Too many provision cycles",
       timestamp: sessionContext.timestamp
@@ -1062,7 +1067,7 @@ function rpcRequest(sessionContext, _declarations, callback) {
   }
 
   if (sessionContext.iteration >= MAX_ITERATIONS * (sessionContext.cycle + 1)) {
-    return callback(null, {
+    return void callback(null, {
       code: "too_many_commits",
       message: "Too many commit iterations",
       timestamp: sessionContext.timestamp
@@ -1166,14 +1171,14 @@ function rpcRequest(sessionContext, _declarations, callback) {
       return false;
     });
 
-    return clear(sessionContext, toClear, err => {
+    return void clear(sessionContext, toClear, err => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
       sessionContext.syncState.virtualParameterDeclarations[inception] = vpd;
       rpcRequest(sessionContext, null, callback);
     });
   }
 
-  if (!sessionContext.syncState) return callback();
+  if (!sessionContext.syncState) return void callback();
 
   const inception = sessionContext.declarations.length - 1;
 
@@ -1190,7 +1195,7 @@ function rpcRequest(sessionContext, _declarations, callback) {
       if (sessionContext.deviceData.changes.has("prerequisite")) {
         delete sessionContext.syncState;
         device.clearTrackers(sessionContext.deviceData, "prerequisite");
-        return rpcRequest(sessionContext, null, callback);
+        return void rpcRequest(sessionContext, null, callback);
       }
 
       let toClear;
@@ -1340,8 +1345,8 @@ function rpcRequest(sessionContext, _declarations, callback) {
       }
 
       if (toClear || sessionContext.deviceData.changes.has("prerequisite")) {
-        return clear(sessionContext, toClear, err => {
+        return void clear(sessionContext, toClear, err => {
-          if (err) return callback(err);
+          if (err) return void callback(err);
           rpcRequest(sessionContext, null, callback);
         });
       }
@@ -1358,11 +1363,11 @@ function rpcRequest(sessionContext, _declarations, callback) {
   if (provisions) {
     sessionContext.virtualParameters.push(provisions);
     sessionContext.revisions.push(sessionContext.revisions[inception]);
-    return rpcRequest(sessionContext, null, callback);
+    return void rpcRequest(sessionContext, null, callback);
   }
 
   if (sessionContext.rpcRequest) {
-    return callback(
+    return void callback(
       null,
       null,
       generateRpcId(sessionContext),
@@ -1375,7 +1380,7 @@ function rpcRequest(sessionContext, _declarations, callback) {
   sessionContext.syncState.virtualParameterDeclarations.pop();
 
   const ret = sessionContext.provisionsRet.splice(inception)[0];
-  if (!ret) return rpcRequest(sessionContext, null, callback);
+  if (!ret) return void rpcRequest(sessionContext, null, callback);
 
   sessionContext.revisions.pop();
   const rev =
@@ -1391,7 +1396,7 @@ function rpcRequest(sessionContext, _declarations, callback) {
   }
 
   const vparams = sessionContext.virtualParameters.pop();
-  if (!vparams) return callback();
+  if (!vparams) return void callback();
 
   const timestamp = sessionContext.timestamp + sessionContext.iteration;
   let toClear;
@@ -1409,7 +1414,7 @@ function rpcRequest(sessionContext, _declarations, callback) {
   }
 
   clear(sessionContext, toClear, err => {
-    if (err) return callback(err);
+    if (err) return void callback(err);
     rpcRequest(sessionContext, null, callback);
   });
 }
@@ -2154,7 +2159,7 @@ function processInstances(
 }
 
 function clear(sessionContext, toClear, callback) {
-  if (!toClear || !toClear.length) return callback();
+  if (!toClear || !toClear.length) return void callback();
 
   const MAX_DEPTH = config.get("MAX_DEPTH", sessionContext.deviceId);
 
@@ -2178,7 +2183,7 @@ function clear(sessionContext, toClear, callback) {
   }
 
   loadParameters(sessionContext, err => {
-    if (err) return callback(err);
+    if (err) return void callback(err);
     for (const c of toClear)
       device.clear(sessionContext.deviceData, c[0], c[1], c[2], c[3]);
 
@@ -2188,7 +2193,7 @@ function clear(sessionContext, toClear, callback) {
 
 function rpcResponse(sessionContext, id, rpcRes, callback) {
   if (id !== generateRpcId(sessionContext))
-    return callback(new Error("Request ID not recognized"));
+    return void callback(new Error("Request ID not recognized"));
 
   ++sessionContext.rpcCount;
 
@@ -2248,8 +2253,11 @@ function rpcResponse(sessionContext, id, rpcRes, callback) {
 
   switch (rpcRes.name) {
     case "GetParameterValuesResponse":
-      if (rpcReq.name !== "GetParameterValues")
+      if (rpcReq.name !== "GetParameterValues") {
-        return callback(new Error("Response name does not match request name"));
+        return void callback(
+          new Error("Response name does not match request name")
+        );
+      }
 
       for (const p of rpcRes.parameterList) {
         toClear = device.set(
@@ -2263,8 +2271,11 @@ function rpcResponse(sessionContext, id, rpcRes, callback) {
 
       break;
     case "GetParameterNamesResponse":
-      if (rpcReq.name !== "GetParameterNames")
+      if (rpcReq.name !== "GetParameterNames") {
-        return callback(new Error("Response name does not match request name"));
+        return void callback(
+          new Error("Response name does not match request name")
+        );
+      }
 
       if (rpcReq.parameterPath.endsWith("."))
         root = common.parsePath(rpcReq.parameterPath.slice(0, -1));
@@ -2333,7 +2344,7 @@ function rpcResponse(sessionContext, id, rpcRes, callback) {
       }
 
       loadParameters(sessionContext, err => {
-        if (err) return callback(err);
+        if (err) return void callback(err);
 
         if (!root.length) {
           for (const n of [
@@ -2365,8 +2376,11 @@ function rpcResponse(sessionContext, id, rpcRes, callback) {
       });
       return;
     case "SetParameterValuesResponse":
-      if (rpcReq.name !== "SetParameterValues")
+      if (rpcReq.name !== "SetParameterValues") {
-        return callback(new Error("Response name does not match request name"));
+        return void callback(
+          new Error("Response name does not match request name")
+        );
+      }
 
       for (const p of rpcReq.parameterList) {
         toClear = device.set(
@@ -2505,7 +2519,7 @@ function rpcResponse(sessionContext, id, rpcRes, callback) {
       }
       break;
     default:
-      return callback(new Error("Response name not recognized"));
+      return void callback(new Error("Response name not recognized"));
   }
   clear(sessionContext, toClear, callback);
 }
@@ -2527,12 +2541,12 @@ function rpcFault(sessionContext, id, faultResponse, callback) {
 function deserialize(sessionContextString, callback) {
   localCache.getProvisionsAndVirtualParameters(
     (err, hash, provisions, virtualParameters) => {
-      if (err) return callback(err);
+      if (err) return void callback(err);
 
       const sessionContext = JSON.parse(sessionContextString);
 
       if (sessionContext.presetsHash && sessionContext.presetsHash !== hash)
-        return callback(new Error("Preset hash mismatch"));
+        return void callback(new Error("Preset hash mismatch"));
 
       provisionsCache.set(sessionContext, provisions);
       virtualParametersCache.set(sessionContext, virtualParameters);

lib/versioned-map.js

@@ -19,6 +19,7 @@
 "use strict";
 
 const NONEXISTENT = new Object();
+const UNDEFINED = undefined;
 
 function compareEquality(a, b) {
   var t = typeof a;
@@ -61,14 +62,16 @@ class VersionedMap {
     if (rev == null) rev = this._revision;
 
     var v = this.map.get(key);
-    if (!v) return;
+    if (!v) return UNDEFINED;
 
     for (let i = Math.min(v.length - 1, rev); i >= 0; --i) {
       if (i in v) {
-        if (v[i] === NONEXISTENT) return undefined;
+        if (v[i] === NONEXISTENT) return UNDEFINED;
         else return v[i];
       }
     }
+
+    return UNDEFINED;
   }
 
   has(key, rev) {
@@ -99,7 +102,7 @@ class VersionedMap {
       v = [];
       v[rev] = value;
       this.map.set(key, v);
-      return this;
+      return;
     }
 
     var old = v[Math.min(rev, v.length - 1)];