* The hostname in setSecurityParams is now treated like the one given to tryToConnect (fixes the issue mentioned in #30)

* added tests for `getConnection`

Author: AlCalzone

README.md

@@ -145,6 +145,9 @@ To only reset connections and requests for a specific hostname, pass the hostnam
 
 ## Changelog
 
+#### 0.5.4 (2018-02-13)
+* (AlCalzone) The hostname in `setSecurityParams` is now treated like the one given to `tryToConnect` (fixes the issue mentioned in #30)
+
 #### 0.5.3 (2018-02-07)
 * (AlCalzone) Attempt to fix `TypeError: generator already running` in ioBroker.tradfri
 

build/CoapClient.d.ts

@@ -157,11 +157,6 @@ export declare class CoapClient {
      * @param target The target to connect to. Must be a string, NodeJS.Url or Origin and has to contain the protocol, host and port.
      */
     static tryToConnect(target: string | nodeUrl.Url | Origin): Promise<boolean>;
-    /**
-     * Establishes a new or retrieves an existing connection to the given origin
-     * @param origin - The other party
-     */
-    private static getConnection(origin);
     private static workOffPendingConnections();
     /**
      * Establishes or retrieves a socket that can be used to send to and receive data from the given origin

build/CoapClient.js

@@ -96,6 +96,19 @@ function validateBlockSize(size) {
         return false;
     return true;
 }
+// Since coaps:// urls are parsed by the url package, the contained hostname is normalized.
+// This function applies the same transformation to any given hostname. Fixes the issue mentioned in #30
+/**
+ * Normalizes a hostname so it matches between `setSecurityParameters` and `connect`
+ * @param hostname The hostname to normalize
+ */
+function normalizeHostname(hostname) {
+    // make sure noone gave us a full URI
+    if (!hostname.startsWith("coap://") && !hostname.startsWith("coaps://")) {
+        hostname = `coaps://${hostname}`;
+    }
+    return nodeUrl.parse(hostname).hostname;
+}
 /**
  * provides methods to access CoAP server resources
  */
@@ -104,6 +117,7 @@ class CoapClient {
      * Sets the security params to be used for the given hostname
      */
     static setSecurityParams(hostname, params) {
+        hostname = normalizeHostname(hostname);
         CoapClient.dtlsParams.set(hostname, params);
     }
     /**
@@ -836,6 +850,7 @@ class CoapClient {
     /**
      * Establishes a new or retrieves an existing connection to the given origin
      * @param origin - The other party
+     * @internal
      */
     static getConnection(origin) {
         const originString = origin.toString();
@@ -920,8 +935,6 @@ class CoapClient {
                 // simply return a normal udp socket
                 return Promise.resolve(new SocketWrapper_1.SocketWrapper(dgram.createSocket("udp4")));
             case "coaps:":
-                // return a promise we resolve as soon as the connection is secured
-                const ret = DeferredPromise_1.createDeferredPromise();
                 // try to find security parameters
                 if (!CoapClient.dtlsParams.has(origin.hostname)) {
                     return Promise.reject(new Error(`No security parameters given for the resource at ${origin.toString()}`));
@@ -931,6 +944,8 @@ class CoapClient {
                     address: origin.hostname,
                     port: origin.port,
                 }, CoapClient.dtlsParams.get(origin.hostname));
+                // return a promise we resolve as soon as the connection is secured
+                const ret = DeferredPromise_1.createDeferredPromise();
                 // try connecting
                 const onConnection = () => {
                     debug("successfully created socket for origin " + origin.toString());

package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-coap-client",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Clientside implementation of the CoAP protocol with DTLS support.",
   "keywords": [
     "coap",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "debug": "^3.1.0",
-    "node-dtls-client": "^0.3.0"
+    "node-dtls-client": "^0.3.1"
   },
   "engines": {
     "node": ">= 6.0.0"
@@ -55,6 +55,9 @@
     "include": [
       "src/**/*.ts"
     ],
+    "exclude": [
+      "**/*.test.ts"
+    ],
     "extension": [
       ".ts"
     ],

src/CoapClient.test.ts

@@ -0,0 +1,38 @@
+// tslint:disable:no-console
+// tslint:disable:no-unused-expression
+import { expect, should, use } from "chai";
+import * as chaiAsPromised from "chai-as-promised";
+
+before(() => {
+	use(chaiAsPromised);
+	should();
+});
+
+import { CoapClient as coap } from "./CoapClient";
+import { Origin } from "./lib/Origin";
+
+describe("CoapClient Tests =>", () => {
+
+	coap.setSecurityParams("does-not-exist", {
+		psk: { IDENTITY: "FOO" },
+	});
+	const correctOrigin = new Origin("coaps:", "does-not-exist", 5684);
+	// tslint:disable-next-line:variable-name
+	const correctOrigin_wrongCasing = new Origin("coaps:", "does-NOT-exist", 5684);
+	const wrongOrigin = new Origin("coaps:", "does-not-exist2", 5684);
+
+	it("connecting to a non-existing endpoint should fail with ENOTFOUND or DTLS timeout", function() {
+		this.timeout(10000);
+		return coap.getConnection(correctOrigin).should.be.rejectedWith(/(ENOTFOUND)|(DTLS handshake timed out)/);
+	});
+	it("the hostname should not be case-sensitive", function() {
+		this.timeout(10000);
+		// we test against a non-existing endpoint, so ENOTFOUND should be thrown but not "No security parameters given"
+		return coap.getConnection(correctOrigin_wrongCasing).should.be.rejectedWith(/(ENOTFOUND)|(DTLS handshake timed out)/);
+	});
+	it("missing security params should fail the connection with the correct message", function() {
+		this.timeout(10000);
+		return coap.getConnection(wrongOrigin).should.be.rejectedWith("No security parameters");
+	});
+
+});

src/CoapClient.ts

@@ -164,6 +164,20 @@ function validateBlockSize(size: number): boolean {
 	return true;
 }
 
+// Since coaps:// urls are parsed by the url package, the contained hostname is normalized.
+// This function applies the same transformation to any given hostname. Fixes the issue mentioned in #30
+/**
+ * Normalizes a hostname so it matches between `setSecurityParameters` and `connect`
+ * @param hostname The hostname to normalize
+ */
+function normalizeHostname(hostname: string): string {
+	// make sure noone gave us a full URI
+	if (!hostname.startsWith("coap://") && !hostname.startsWith("coaps://")) {
+		hostname = `coaps://${hostname}`;
+	}
+	return nodeUrl.parse(hostname).hostname;
+}
+
 /**
  * provides methods to access CoAP server resources
  */
@@ -192,6 +206,7 @@ export class CoapClient {
 	 * Sets the security params to be used for the given hostname
 	 */
 	public static setSecurityParams(hostname: string, params: SecurityParameters) {
+		hostname = normalizeHostname(hostname);
 		CoapClient.dtlsParams.set(hostname, params);
 	}
 
@@ -1041,8 +1056,9 @@ export class CoapClient {
 	/**
 	 * Establishes a new or retrieves an existing connection to the given origin
 	 * @param origin - The other party
+	 * @internal
 	 */
-	private static getConnection(origin: Origin): Promise<ConnectionInfo> {
+	public static getConnection(origin: Origin): Promise<ConnectionInfo> {
 		const originString = origin.toString();
 		if (CoapClient.connections.has(originString)) {
 			debug(`getConnection(${originString}) => found existing connection`);
@@ -1127,8 +1143,6 @@ export class CoapClient {
 				// simply return a normal udp socket
 				return Promise.resolve(new SocketWrapper(dgram.createSocket("udp4")));
 			case "coaps:":
-				// return a promise we resolve as soon as the connection is secured
-				const ret = createDeferredPromise<SocketWrapper>();
 				// try to find security parameters
 				if (!CoapClient.dtlsParams.has(origin.hostname)) {
 					return Promise.reject(new Error(`No security parameters given for the resource at ${origin.toString()}`));
@@ -1141,6 +1155,10 @@ export class CoapClient {
 					} as dtls.Options),
 					CoapClient.dtlsParams.get(origin.hostname),
 				);
+
+				// return a promise we resolve as soon as the connection is secured
+				const ret = createDeferredPromise<SocketWrapper>();
+
 				// try connecting
 				const onConnection = () => {
 					debug("successfully created socket for origin " + origin.toString());