@tier0/node-red-contrib-opcda-client 1.0.5 → 1.0.7

package/node_modules/@tier0/node-dcom/dcom/ndr/networkdatarepresentation.js

@@ -0,0 +1,112 @@
+var hexDump = require("./hexdump");
+var Format = require("./format.js");
+
+function NetworkDataRepresentation(){
+  this.NDR_UUID = "8a885d04-1ceb-11c9-9fe8-08002b104860";
+
+  this.NDR_MAJOR_VERSION = 2;
+
+  this.NDR_MINOR_VERSION = 0;
+
+  this.NDR_SYNTAX = String(this.NDR_UUID + ":" + this.NDR_MAJOR_VERSION + "."
+  + this.NDR_MINOR_VERSION);
+
+  this.ptr;
+  this.buf;
+  this.format;
+};
+
+NetworkDataRepresentation.prototype.setBuffer = function (buf){
+  this.buf = buf;
+}
+
+NetworkDataRepresentation.prototype.getBuffer = function (){
+  return this.buf;
+}
+
+NetworkDataRepresentation.prototype.hexdump = function (count){
+  hexDump.hexdump(buf.buf, buf.index, count);
+}
+
+NetworkDataRepresentation.prototype.readBoolean = function (){
+  return buf.dec_ndr_small() == 0 ? false : true;
+}
+
+NetworkDataRepresentation.prototype.writeBoolean = function (value){
+  this.buf.enc_ndr_small(value ? 1 : 0);
+}
+
+NetworkDataRepresentation.prototype.readUnsignedSmall = function (){
+  return this.buf.dec_ndr_small();
+}
+
+NetworkDataRepresentation.prototype.readUnsignedShort = function (){
+  return this.buf.dec_ndr_short();
+}
+
+NetworkDataRepresentation.prototype.readUnsignedLong = function (){
+  return this.buf.dec_ndr_long();
+}
+
+NetworkDataRepresentation.prototype.writeUnsignedSmall = function (value){
+  this.buf.enc_ndr_small(value);
+}
+
+NetworkDataRepresentation.prototype.writeUnsignedShort = function (value){
+  this.buf.enc_ndr_short(value);
+}
+
+NetworkDataRepresentation.prototype.writeUnsignedLong = function (value){
+  this.buf.enc_ndr_long(value);
+}
+
+NetworkDataRepresentation.prototype.setFormat = function (format){
+  this.format = format;
+}
+
+NetworkDataRepresentation.prototype.getFormat = function (){
+  return this.format;
+}
+
+NetworkDataRepresentation.prototype.readFormat = function (connectionless){
+  var format = new Format().readFormat(this.buf.buf, this.buf.index, connectionless);
+  this.buf.index += 4;
+  return format;
+}
+
+NetworkDataRepresentation.prototype.writeFormat = function (format){
+  format.writeFormat(this.buf.buf, this.buf,index, false);
+  this.buf.index += 4;
+}
+
+NetworkDataRepresentation.prototype.writeFormatBool = function (connectionless){
+  var index = this.buf.getIndex();
+  this.buf.index += connectionless ? 3 : 4;
+  this.format.writeFormat(this.buf.buf, index, connectionless);
+}
+
+NetworkDataRepresentation.prototype.readCharacterArray = function (array, offset, length){
+  if (array == null || length == 0) return;
+  length += offset;
+  for (var i = offset; i < length; i++){
+    array[i] = Buffer.from([this.buf.buf[this.buf.index++]]).toString();
+  }
+}
+
+NetworkDataRepresentation.prototype.writeCharacterArray = function (array, offset, length){
+  if ( array == null || length == 0 )
+    return;
+  length += offset;
+  for (let i = offset; i < length; i++ )
+    this.buf.buf[buf.index++] = Buffer.from(array[i]);
+}
+
+NetworkDataRepresentation.prototype.writeOctetArray = function (b, i, l){
+  this.buf.writeOctetArray(b, i, l);
+}
+
+NetworkDataRepresentation.prototype.readOctetArray = function (b, i, l){
+  return this.buf.readOctetArray(b, i, l);
+}
+
+module.exports = NetworkDataRepresentation;

package/node_modules/@tier0/node-dcom/dcom/ndr/smbconstants.js

@@ -0,0 +1,103 @@
+/*
+ * Defines a few constants used by Encdec. MOst constants listed
+ * here are never used by our code, but I decided to put most of them here
+ * just in case.
+ */
+
+var SmbConstants = {
+  DEFAULT_PORT: 445,
+  DEFAULT_MAX_MPX_COUNT: 10,
+  DEFAULT_RESPONSE_TIMEOUT: 30000,
+  DEFAULT_SO_TIMEOUT: 35000,
+  DEFAULT_RCV_BUF_SIZE: 0xFFFF,
+  DEFAULT_SND_BUF_SIZE: 0XFFFF,
+  DEFAULT_NOTIFY_BUF_SIZE: 1024,
+  DEFAULT_SSN_LIMIT: 250,
+  DEFAULT_CONN_TIMEOUT: 35000,
+  // basic flags
+  FLAGS_NONE: 0x00,
+  FLAGS_LOCK_AND_READ_WRITE_AND_UNLOCK: 0x01,
+  FLAGS_RECEIVE_BUFFER_POSTED: 0x02,
+  FLAGS_PATH_NAMES_CASELESS: 0x08,
+  FLAGS_PATH_NAMES_CANONICALIZED: 0x10 ,
+  FLAGS_OPLOCK_REQUESTED_OR_GRANTED: 0x20 ,
+  FLAGS_NOTIFY_OF_MODIFY_ACTION: 0x40 ,
+  FLAGS_RESPONSE : 0x80,
+  FLAGS2_NONE: 0x0000,
+  FLAGS2_LONG_FILENAMES: 0x0001,
+  FLAGS2_EXTENDED_ATTRIBUTES: 0x0002,
+  FLAGS2_SECURITY_SIGNATURES: 0x0004,
+  FLAGS2_SECURITY_REQUIRE_SIGNATURES: 0x0010,
+  FLAGS2_EXTENDED_SECURITY_NEGOTIATION: 0x0800,
+  FLAGS2_RESOLVE_PATHS_IN_DFS: 0x1000,
+  FLAGS2_PERMIT_READ_IF_EXECUTE_PERM: 0x2000,
+  FLAGS2_STATUS32: 0x4000,
+  FLAGS2_UNICODE: 0x8000,
+  CAP_NONE: 0x0000,
+  CAP_RAW_MODE: 0x0001,
+  CAP_MPX_MODE: 0x0002,
+  CAP_UNICODE: 0x0004,
+  CAP_LARGE_FILES: 0x0008,
+  CAP_NT_SMBS: 0x0010,
+  CAP_RPC_REMOTE_APIS: 0x0020,
+  CAP_STATUS32: 0x0040,
+  CAP_LEVEL_II_OPLOCKS: 0x0080,
+  CAP_LOCK_AND_READ: 0x0100,
+  CAP_NT_FIND: 0x0200,
+  CAP_DFS: 0x1000,
+  CAP_LARGE_READX: 0x4000,
+  CAP_LARGE_WRITEX: 0x8000,
+  CAP_EXTENDED_SECURITY: 0x80000000,
+  // File attributes encoding
+  ATTR_READONLY: 0x01,
+  ATTR_HIDDEN: 0x02,
+  ATTR_SYSTEM: 0x04,
+  ATTR_VOLUME: 0x08,
+  ATTR_DIRECTORY: 0x10,
+  ATTR_ARCHIVE: 0x20,
+  ATTR_COMPRESSED: 0x800,
+  ATTR_NORMAL: 0x080,
+  ATTR_TEMPORARY: 0x100,
+  // access mask encoding
+  FILE_READ_DATA: 0x00000001, // 1
+  FILE_WRITE_DATA: 0x00000002, // 2
+  FILE_APPEND_DATA: 0x00000004, // 3
+  FILE_READ_EA: 0x00000008, // 4
+  FILE_WRITE_EA: 0x00000010, // 5
+  FILE_EXECUTE: 0x00000020, // 6
+  FILE_DELETE: 0x00000040, // 7
+  FILE_READ_ATTRIBUTES: 0x00000080, // 8
+  FILE_WRITE_ATTRIBUTES: 0x00000100, // 9
+  DELETE: 0x00010000, // 16
+  READ_CONTROL: 0x00020000, // 17
+  WRITE_DAC: 0x00040000, // 18
+  WRITE_OWNER: 0x00080000, // 19
+  SYNCHRONIZE: 0x00100000, // 20
+  GENERIC_ALL: 0x10000000, // 28
+  GENERIC_EXECUTE: 0x20000000, // 29
+  GENERIC_WRITE: 0x40000000, // 30
+  GENERIC_READ: 0x80000000, // 31
+  // move and copy flags
+  FLAGS_TARGET_MUST_BE_FILE: 0x0001,
+  FLAGS_TARGET_MUST_BE_DIRECTORY: 0x0002,
+  FLAGS_COPY_TARGET_MODE_ASCII: 0x0004,
+  FLAGS_COPY_SOURCE_MODE_ASCII: 0x0008,
+  FLAGS_VERIFY_ALL_WRITES: 0x0010,
+  FLAGS_TREE_COPY: 0x0020,
+  // open function flags
+  OPEN_FUNCTION_FAIL_IF_EXISTS: 0x0000,
+  OPEN_FUNCTION_OVERWRITE_IF_EXISTS: 0x0020,
+  SECURITY_SHARE: 0x00,
+  SECURITY_USER: 0x01,
+  CMD_OFFSET: 4,
+  ERROR_CODE_OFFSET: 5,
+  FLAGS_OFFSET: 9,
+  SIGNATURE_OFFSET: 14,
+  TID_OFFSET: 24,
+  SMB1_HEADER_LENGTH: 32,
+  MILLISECONDS_BETWEEN_1970_AND_1601: "11644473600000",
+  DEFAULT_OEM_ENCODING: "Cp850",
+  FOREVER: -1
+};
+
+module.exports = Object.freeze(SmbConstants);

package/node_modules/@tier0/node-dcom/dcom/rpc/basicconnectioncontext.js

@@ -0,0 +1,111 @@
+var PresentationContext = require("./core/presentationcontext.js");
+var PresentationResult = require("./core/presentationresult.js");
+var AlterContextPdu = require("./pdu/altercontextpdu.js");
+var AlterContextResponsePdu = require("./pdu/altercontextresponsepdu.js");
+var BindAcknowledgePdu = require("./pdu/bindacknowledgepdu.js");
+var BindNoAcknowledgePdu = require('./pdu/bindnoacknowledgepdu.js');
+var BindPdu = require('./pdu/bindPdu.js');
+var FaultCoPdu = require('./pdu/faultCoPdu.js');
+var ShutdownPdu = require('./pdu/shutdownpdu.js');
+var DefaultConnection = require('./defaultconnection.js');
+
+class BasicConnectionContext {
+  constructor(){
+    this.DEFAULT_MAX_TRANSMIT_FRAGMENT = 4280;
+    this.DEFAULT_MAX_RECEIVE_FRAGMENT = 4280;
+
+    this.maxTransmitFragment = this.DEFAULT_MAX_TRANSMIT_FRAGMENT;
+    this.maxReceiveFragment = this.DEFAULT_MAX_RECEIVE_FRAGMENT;
+
+    this.MAX_TRANSMIT_FRAGMENT = this.maxTransmitFragment;
+    this.MAX_RECEIVE_FRAGMENT = this.maxReceiveFragment;
+
+    this.connection;
+    this.established;
+    this.transmitLength;
+    this.receiveLength;
+  }
+
+  init(context){
+    this.established = false;
+    this.connection = new DefaultConnection()
+    //if (properties != null){
+    var maxTransmit = this.MAX_TRANSMIT_FRAGMENT;
+    if (maxTransmit != null){
+      this.maxTransmitFragment = Number.parseInt(maxTransmit);
+    }
+    var maxReceive = this.MAX_RECEIVE_FRAGMENT;
+    if (maxReceive != null){
+      this.maxReceiveFragment = Number.parseInt(maxReceive);
+    }
+    //}
+    var pdu = new BindPdu();
+    pdu.setContextList([context]);
+    pdu.setMaxTransmitFragment(this.maxTransmitFragment);
+    pdu.setMaxReceiveFragment(this.maxReceiveFragment);
+    return pdu;
+  }
+
+  alter(context){
+    this.established = false;
+    var pdu = new AlterContextPdu();
+    pdu.setContextList([context]);
+    return pdu;
+  }
+
+  accept(pdu){
+    var results = null;
+    switch (pdu.getType()){
+      case BindAcknowledgePdu.BIND_ACKNOWLEDGE_TYPE:
+        var bindAck = pdu;
+        results = bindAck.getResultList();
+        if (results == null){
+          throw new Error("No presentation context results.");
+        }
+        for (var i = results.length - 1; i >= 0; i--){
+          if (results[i].result != PresentationResult.ACCEPTANCE){
+            throw new Error("Context rejected.", results[i]);
+          }
+        }
+        this.transmitLength = bindAck.getMaxReceiveFragment();
+        this.receiveLength = bindAck.getMaxTransmitFragmetn();
+        this.established = true;
+        this.connection = new DefaultConnection(transmitLength, receiveLength);
+        return null;
+      case AlterContextResponsePdu.ALTER_CONTEXT_RESPONSE_TYPE:
+        var alterContextResponse = pdu;
+        results = alterContextResponse.getResultList();
+        if (results == null){
+          throw new Error("No prsentation context results.");
+        }
+        for (var i = reults.length - 1; i >= 0; i--){
+          if (results[i].result != PresentationResult.ACCEPTANCE){
+            throw new Error("Context rejected.", results[i]);
+          }
+        }
+        this.established = true;
+        return null;
+      case BindNoAcknowledgePdu.BIND_NO_ACKNOWLEDGE_TYPE:
+        throw new Error("Unable to bind.", pdu.getRejectReason());
+      case FaultCoPdu.FAULT_TYPE:
+        throw new Error("Fault ocurred.", pdu.getStatus());
+      case ShutdownPdu.SHUTDOWN_TYPE:
+        throw new Error("Server shutdown connection.");
+      case BindPdu.BIND_TYPE:
+      case AlterContextPdu.ALTER_CONTEXT_TYPE:
+        throw new Error("Server-side currently unsupported.");
+      default:
+        throw new Error("Unkonwn/unnacceptable PDU type.");
+    }
+  }
+
+  getConnection(){
+    return this.connection;
+  }
+
+  isEstablished(){
+    return this.restablished;
+  }
+}
+
+module.exports = BasicConnectionContext;

package/node_modules/@tier0/node-dcom/dcom/rpc/buffer.js

@@ -0,0 +1,119 @@
+
+class Buffer {
+  constructor(buffer, capacityIncrement){
+    this.NO_INCREMENT = 0;
+
+    if(buffer == undefined){
+      this.buffer = null;
+    }else{ this.buffer = buffer;}
+
+    if(capacityIncrement == undefined){
+      this.capacityIncrement = NO_INCREMENT;
+    }else{this.capacityIncrement = capacityIncrement;}
+
+    this.index = 0;
+    this.length;
+  }
+
+  get capacityIncrement(){
+    return this.capacityIncrement;
+  }
+
+  get capacity(){
+    return this.buffer.length;
+  }
+
+  set capacityIncrement(capacityIncrement){
+    this.capacityIncrement = capacityIncrement;
+  }
+
+  get buffer(){
+    return this.buffer;
+  }
+
+  set buffer(buffer){
+    this.buffer = buffer;
+  }
+
+  get length(){
+    return this.length;
+  }
+
+  set length(length){
+    this.length = length;
+  }
+
+  copy(){
+    var copy = [this.length];
+    var temp = buffer.slice(0, this.length);
+    var temp_index= 0;
+    while(temp > 0)
+      copy.splice(temp_index++, 0, temp.shift());
+    return copy;
+  }
+
+  reset(){
+    this.lenght = 0
+    this.index = 0;
+  }
+
+  get index(){
+    return this.index;
+  }
+
+  getIndex(advance){
+    try{
+      return this.index;
+    }finally{
+      this.index += advance;
+      if(this.index > this.length) this.length = this.index;
+      if(this.length > this.buffer.length) grow(this.length);
+    }
+  }
+
+  set index(index){
+    this.index = index;
+    if (this.index > this.length) this.length = this.index;
+    if (this.length > this.buffer.length) grow(this.length);
+  }
+
+  align(boundary, value){
+    var align = this.index % boundary;
+    if (align == 0) return 0;
+    if(value == undefined){
+      advance(align = boundary - align);
+      return align;
+    }else{
+      advance(align = boundary - align, value);
+      return align;
+    }
+  }
+
+  advance(step, value){
+    if (value == undefined){
+      this.index += step;
+    }else{
+      for (var finish = this.index + step;this.index < finish; this.index++){
+        buffer[this.index] = value;
+      }
+    }
+    if (this.index > this.length) this.length = this.index;
+    if (this.length > this.buffer.length) grow(this.length);
+  }
+
+  grow(length){
+    var newLength = this.buffer.length;
+    while (this.newLength < this.length){
+      this.newLength += capacityIncrement;
+    }
+    var newBuffer = [this.newLength];
+
+    var temp = this.buffer.slice(0, this.buffer.length);
+    var temp_index;
+    while(temp.length > 0)
+      newBuffer.splice(temp_index, 0, temp.shift());
+    this.buffer = newBuffer;
+  }
+}
+
+module.export = Buffer;

package/node_modules/@tier0/node-dcom/dcom/rpc/connection.js

@@ -0,0 +1,7 @@
+class Connection{
+  constructor(){};
+
+  transmit(pdu, transport){};
+
+  receive(transport){};
+}

package/node_modules/@tier0/node-dcom/dcom/rpc/connectionorientedendpoint.js

@@ -0,0 +1,261 @@
+const HashMap = require("hashmap");
+const RequestCoPdu = require('./pdu/requestcopdu.js');
+const NdrBuffer = require('../ndr/ndrbuffer.js');
+const NetworkDataRepresentation = require('../ndr/networkdatarepresentation.js');
+const ConnectionOrientedPdu = require('./connectionorientedpdu.js');
+const ResponseCoPdu = require('./pdu/responsecopdu.js');
+const FaultCoPdu = require('./pdu/faultCoPdu.js');
+const ShutdownPdu = require('./pdu/shutdownpdu.js');
+const PresentationSyntax = require('./core/presentationsyntax.js');
+const PresentationContext = require('./core/presentationcontext.js');
+const BindAcknowledgePdu = require('./pdu/bindacknowledgepdu.js');
+const AlterContextResponsePdu = require('./pdu/altercontextresponsepdu.js');
+const BasicConnectionContext = require('./basicconnectioncontext.js');
+const NTLMConnectionContext = require('./security/ntlmconnectioncontext.js');
+const Events = require('events');
+
+/**
+ * This class is responsible for connection oriented communications
+ * in general (TCP based)
+ */
+class ConnectionOrientedEndpoint extends Events.EventEmitter{
+  /**
+   *
+   * @param {ComTransport} transport
+   * @param {PresentationSyntax} syntax
+   */
+  constructor(transport, syntax) {
+    super();
+    this.MAYBE = 0x01;
+    this.IDEMPOTENT = 0x02;
+    this.BROADCAST = 0x04;
+
+    this.CONNECTION_CONTEXT = "rpc.connectionContext";
+    try {
+      this.transport = transport;
+
+      // now we create event listeners to listen for transport events
+      let self = this;
+      this.transport.on('disconnected', function() {
+        self.emit('disconnected');
+      });
+      this.syntax = syntax;
+    } catch (e) {
+      debug(e);
+    }
+    this.bound;
+    this.callId;
+    this.contextIdCounter = 0;
+    this.contextIdToUse = this.contextIdCounter;
+    this.context;
+    this.uuidsVsContextIds = new HashMap();
+    this.currentIID = null;
+    this.locked = false;
+    this.ee = new Events.EventEmitter();
+    this.ee.setMaxListeners(30);
+  }
+
+  getTransport(){
+    return this.transport;
+  }
+
+  getSyntax(){
+    return this.syntax;
+  }
+
+  async call(semantics, object, opnum, ndrobj, info){
+    await this.bind(info);
+    let request = new RequestCoPdu();
+    request.setContextId(this.contextIdToUse);
+
+    let b = new Array(1024);
+    let buffer = new NdrBuffer(b, 0);
+    let ndr = new NetworkDataRepresentation();
+    
+    ndrobj.encode(ndr, buffer);
+    let stub = new Array(buffer.getLength());
+    let aux = buffer.buf.slice(0, stub.length);
+    //while (aux.length > 0)
+      //stub.splice(aux_i++, 1, aux.shift());
+
+    request.setStub(aux);
+    request.setAllocationHint(buffer.getLength());
+    request.setOpnum(opnum);
+    request.setObject(object);
+
+    if ((semantics & this.MAYBE) != 0){
+      request.setFlag(new ConnectionOrientedPdu().PFC_MAYBE, true);
+    }
+    
+    await this.send(request, info);
+    
+    if (request.getFlag(new ConnectionOrientedPdu().PFC_MAYBE)) return;
+    var rply = await this.receive()
+    .catch(function(error){
+      console.log(error);
+    });
+    //console.log(rply);
+    if (rply instanceof ResponseCoPdu){
+      ndr.setFormat(rply.getFormat());
+      buffer = new NdrBuffer(rply.getStub(), 0);
+      await ndrobj.decode(ndr, buffer);
+    } else if (rply instanceof FaultCoPdu){
+      var fault = rply;
+      throw fault.getStatus();
+    }  else if (rply instanceof ShutdownPdu){
+      throw new Error("Received shutdown request from server.");
+    } else{
+      throw new Error("Received unexpected PDU from server.");
+    }
+  }
+
+  async rebind(info){
+    this.info = info;
+    this.bound = false;
+    await this.bind(this.info)
+  }
+
+  /**
+   *
+   * @param {Object} info
+   */
+  async bind(info) {
+    if (this.bound) return;
+    if (this.context != null) {
+      this.bound = true;
+      
+      let vsctxt = this.uuidsVsContextIds.get(this.getSyntax().toHexString().toUpperCase());
+      let cid = vsctxt == undefined? vsctxt : Number.parseInt(vsctxt);
+      let pdu = this.context.alter(new PresentationContext(cid == null? ++this.contextIdCounter : cid,
+        this.getSyntax()));
+      let sendAlter = false;
+
+      if (cid == null){
+        this.uuidsVsContextIds.set(this.getSyntax().toHexString().toUpperCase(), Number.parseInt(this.contextIdCounter));
+        this.contextIdToUse = this.contextIdCounter;
+        sendAlter = true;
+      } else{
+        this.contextIdToUse = cid;
+      }
+
+      if (sendAlter){
+        if (pdu != null)await this.send(pdu, info);
+        while (!this.context.isEstablished()){
+          let recieved = await this.receive()
+            .catch(function(rej) {
+              throw new Error('ConnectionOrientedEndpoint: Bind - ' + rej);
+            });;
+          if ((pdu = this.context.accept(recieved)) != null){
+            switch (pdu.getType()){
+              case new BindAcknowledgePdu().BIND_ACKNOWLEDGE_TYPE:
+                if (pdu.getResultList()[0].reason != PresentationResult.PROVIDER_REJECTION){
+                  this.currentIID = String(recieved.getContextList()[0].abstractSyntax.getUuid());
+                }
+                break;
+              case new AlterContextResponsePdu().ALTER_CONTEXT_RESPONSE_TYPE:
+                if (pdu.getResultList()[0].reason != PresentationResult.PROVIDER_REJECTION){
+                  this.currentIID = String(recieved.getContextList()[0].abstractSyntax.getUuid());
+                }
+                break;
+              default:
+            }
+            await this.send(pdu, info);
+          }
+        }
+      }
+    }else{
+      await this.connect(info);
+    }
+  }
+
+  async send(request, info){
+    await this.bind(this.info);
+    this.context.getConnection().transmit(request, this.getTransport(), info);
+  }
+
+  async receive(){
+    return await this.context.getConnection().receive(this.getTransport());
+  }
+
+  async detach(){
+    this.bound = false;
+    this.context = null;
+    await this.getTransport().close();
+  }
+
+  async connect(info){
+    this.bound = true;
+    this.contextIdCounter = 0;
+    this.currentIID = null;
+
+    this.uuidsVsContextIds.set(this.getSyntax().toHexString().toUpperCase(), Number.parseInt(this.contextIdCounter));
+    this.context = this.createContext();
+
+    var pdu = this.context.init(new PresentationContext(this.contextIdCounter, this.getSyntax()),
+      info);
+    this.contextIdToUse = this.contextIdCounter;
+
+    if (pdu != null) await this.send(pdu, info);
+    
+    while (!this.context.isEstablished()){
+      var received = await this.receive();
+      pdu = this.context.accept(received);
+
+      if (pdu != null){
+        switch (pdu.getType()){
+          case new BindAcknowledgePdu().BIND_ACKNOWLEDGE_TYPE:
+            if (pdu.getResultList()[0].reason != new PresentationResult().PROVIDER_REJECTION){
+              this.currentIID = String(received.getContextList()[0].abstractSyntax.getUuid());
+            }
+            break;
+          case new AlterContextResponsePdu().ALTER_CONTEXT_RESPONSE_TYPE:
+            if (pdu.getResultList()[0].reason != new PresentationResult().PROVIDER_REJECTION){
+              this.currentIID = String(received.getContextList()[0].abstractSyntax.getUuid());
+            }
+            break;
+          default:
+        }
+        await this.send(pdu, info);
+      }
+    }
+  }
+
+  createContext(info) {
+    var properties = this.properties;
+    if (!properties) {
+      return new NTLMConnectionContext();
+    }
+    var context = String(properties.CONNECTION_CONTEXT);
+    if (!context) {
+      return new NTLMConnectionContext();
+    }
+    return new NTLMConnectionContext();
+  }
+
+  acquire() {
+    let self = this;
+    //console.log(this.ee.listenerCount('release'));
+    return new Promise(function(resolve, reject){
+      if (!self.locked){
+        self.locked = true;
+        return resolve();
+      }
+
+      const tryAcquire = () => {
+        if (!self.locked) {
+          self.locked = true;
+          self.ee.removeListener('release', tryAcquire);
+          return resolve();
+        }
+      };
+      self.ee.on('release', tryAcquire);
+    });
+  }
+
+  release() {
+    this.locked = false;
+    setImmediate(() => this.ee.emit('release'));
+  }
+}
+ConnectionOrientedEndpoint.IDEMPOTENT = ConnectionOrientedEndpoint.prototype.IDEMPOTENT;
+module.exports = ConnectionOrientedEndpoint;