node-firebird 0.9.6 → 1.0.0

package/lib/index.js

@@ -11,7 +11,9 @@ var
 	BitSet = serialize.BitSet,
     messages = require('./messages.js'),
     crypt = require('./unix-crypt.js'),
-    path = require('path');
+    path = require('path'),
+	srp = require('./srp'),
+	BigInt = require('big-integer');
 
 if (typeof(setImmediate) === 'undefined') {
     global.setImmediate = function(cb) {
@@ -274,7 +276,9 @@ const
 	ptype_rpc = 2, 			 // Simple remote procedure call
     ptype_batch_send = 3,    // Batch sends, no asynchrony
 	ptype_out_of_band = 4,   // Batch sends w/ out of band notification
-	ptype_lazy_send = 5;     // Deferred packets delivery;
+	ptype_lazy_send = 5,     // Deferred packets delivery;
+	ptype_mask = 0xFF,       // Mask - up to 255 types of protocol
+	pflag_compress = 0x100;  // Turn on compression if possible
 
 const SUPPORTED_PROTOCOL = [
 	[PROTOCOL_VERSION10, ARCHITECTURE_GENERIC, ptype_rpc, ptype_batch_send, 1],
@@ -790,11 +794,25 @@ const
     DEFAULT_PAGE_SIZE = 4096,
     DEFAULT_SVC_NAME = 'service_mgr';
 
-const AUTH_PLUGIN_LEGACY = 'Legacy_Auth';
+const AUTH_PLUGIN_LEGACY = 'Legacy_Auth',
+ 	  AUTH_PLUGIN_SRP = 'Srp';
+	  // AUTH_PLUGIN_SRP256 = 'Srp256';
 
 const
-	AUTH_PLUGIN_LIST = [AUTH_PLUGIN_LEGACY],
-    LEGACY_AUTH_SALT = '9z';
+	// AUTH_PLUGIN_LIST = [AUTH_PLUGIN_SRP256, AUTH_PLUGIN_SRP, AUTH_PLUGIN_LEGACY],
+	AUTH_PLUGIN_LIST = [AUTH_PLUGIN_SRP, AUTH_PLUGIN_LEGACY],
+	// AUTH_PLUGIN_SRP_LIST = [AUTH_PLUGIN_SRP256, AUTH_PLUGIN_SRP],
+	AUTH_PLUGIN_SRP_LIST = [AUTH_PLUGIN_SRP],
+    LEGACY_AUTH_SALT = '9z',
+	WIRE_CRYPT_DISABLE = 0,
+	WIRE_CRYPT_ENABLE = 1;
+
+exports.AUTH_PLUGIN_LEGACY = AUTH_PLUGIN_LEGACY;
+exports.AUTH_PLUGIN_SRP = AUTH_PLUGIN_SRP;
+// exports.AUTH_PLUGIN_SRP256 = AUTH_PLUGIN_SRP256;
+
+exports.WIRE_CRYPT_DISABLE = WIRE_CRYPT_DISABLE;
+exports.WIRE_CRYPT_ENABLE = WIRE_CRYPT_ENABLE;
 
 exports.ISOLATION_READ_UNCOMMITTED = ISOLATION_READ_UNCOMMITTED;
 exports.ISOLATION_READ_COMMITED = ISOLATION_READ_COMMITED;
@@ -812,16 +830,20 @@ if (!String.prototype.padLeft) {
 /**
  * Escape value
  * @param {Object} value
+ * @param {Number} protocolVersion (optional, default: PROTOCOL_VERSION13)
  * @return {String}
  */
-exports.escape = function(value) {
+exports.escape = function(value, protocolVersion) {
 
     if (value === null || value === undefined)
         return 'NULL';
 
     switch (typeof(value)) {
         case 'boolean':
-            return value ? '1' : '0';
+            if ((protocolVersion || PROTOCOL_VERSION13) >= PROTOCOL_VERSION13)
+                return value ? 'true' : 'false';
+            else
+                return value ? '1' : '0';
         case 'number':
             return value.toString();
         case 'string':
@@ -1280,7 +1302,9 @@ SQLParamBool.prototype.calcBlr = function(blr) {
  ***************************************/
 
 function isError(obj) {
-    return (obj instanceof Object && obj.status);
+    return Boolean(
+      obj != null && typeof obj === "object" && !Array.isArray(obj) && obj.status
+    );
 }
 
 function doCallback(obj, callback) {
@@ -1294,7 +1318,11 @@ function doCallback(obj, callback) {
     }
 
     if (isError(obj)) {
-        callback(new Error(obj.message));
+        var error = new Error(obj.message);
+        var status = obj.status && obj.status.length && obj.status[0] || {};
+        error.gdscode = status.gdscode; // main error gds code
+        error.gdsparams = status.params; // parameters (constraint name, table, etc.)
+        callback(error);
         return;
     }
 
@@ -1379,6 +1407,7 @@ Transaction.prototype.newStatement = function(query, callback) {
 Transaction.prototype.execute = function(query, params, callback, custom) {
 
     if (params instanceof Function) {
+        custom = callback;
         callback = params;
         params = undefined;
     }
@@ -1454,6 +1483,29 @@ Transaction.prototype.execute = function(query, params, callback, custom) {
     });
 };
 
+Transaction.prototype.sequentially = function (query, params, on, callback, asArray) {
+
+	if (params instanceof Function) {
+		asArray = callback;
+		callback = on;
+		on = params;
+		params = undefined;
+	}
+
+	if (on === undefined){
+		throw new Error('Expected "on" delegate.');
+	}
+
+	if (callback instanceof Boolean) {
+		asArray = callback;
+		callback = undefined;
+	}
+
+	var self = this;
+	self.execute(query, params, callback, { asObject: !asArray, asStream: true, on: on });
+	return self;
+};
+
 Transaction.prototype.query = function(query, params, callback) {
 
     if (params instanceof Function) {
@@ -1503,7 +1555,7 @@ Database.prototype.__proto__ = Object.create(Events.EventEmitter.prototype, {
 });
 
 Database.prototype.escape = function(value) {
-    return exports.escape(value);
+    return exports.escape(value, this.connection.accept.protocolVersion);
 };
 
 Database.prototype.detach = function(callback, force) {
@@ -1572,6 +1624,7 @@ Database.prototype.newStatement = function (query, callback) {
 Database.prototype.execute = function(query, params, callback, custom) {
 
     if (params instanceof Function) {
+        custom = callback;
         callback = params;
         params = undefined;
     }
@@ -1606,19 +1659,25 @@ Database.prototype.execute = function(query, params, callback, custom) {
 
 Database.prototype.sequentially = function(query, params, on, callback, asArray) {
 
-    if (params instanceof Function) {
-        asArray = callback;
-        callback = on;
-        on = params;
-        params = undefined;
-    }
+	if (params instanceof Function) {
+		asArray = callback;
+		callback = on;
+		on = params;
+		params = undefined;
+	}
 
-    if (on === undefined)
-        throw new Error('Expected "on" delegate.');
+	if (on === undefined){
+		throw new Error('Expected "on" delegate.');
+	}
 
-    var self = this;
-    self.execute(query, params, callback, { asObject: !asArray, asStream: true, on: on });
-    return self;
+	if (callback instanceof Boolean) {
+		asArray = callback;
+		callback = undefined;
+	}
+
+	var self = this;
+	self.execute(query, params, callback, { asObject: !asArray, asStream: true, on: on });
+	return self;
 };
 
 Database.prototype.query = function(query, params, callback) {
@@ -1793,7 +1852,7 @@ ServiceManager.prototype._infosmapping = {
     "63"/*isc_info_svc_to_eof*/ : "",
     "64"/*isc_info_svc_timeout*/ : "",
     "65"/*isc_info_svc_get_licensed_users*/ : "",
-    "66"/*isc_info_svc_limbo_trans*/ : "",
+    "66"/*isc_info_svc_limbo_trans*/ : "limbotrans",
     "67"/*isc_info_svc_running*/ : "",
     "68"/*isc_info_svc_get_users*/ : "fbusers",
     "78"/*isc_info_svc_stdin*/ : ""
@@ -2175,11 +2234,11 @@ ServiceManager.prototype._fixpropertie = function (options, callback) {
     var online = options.bringonline || false;
     var shutdown = options.shutdown != null ? options.shutdown : null; // 0 Forced, 1 deny transaction, 2 deny attachment
     var shutdowndelay = options.shutdowndelay || 0;
-    var shutdownmode = options.shutdownmode != null ? options.shutdownmode : null; // 0 normal 1 multi 2 single 3 full
+    var shutdownmode = options.shutdownmode; // 0 normal 1 multi 2 single 3 full
     var shadow = options.activateshadow || false;
-    var forcewrite = options.forcewrite!=null?options.forcewrite:null;
-    var reservespace = options.reservespace!=null?options.reservespace:null;
-    var accessmode = options.accessmode!=null?options.accessmode:null; // 0 readonly 1 readwrite
+    var forcewrite = options.forcewrite;
+    var reservespace = options.reservespace;
+    var accessmode = options.accessmode; // 0 readonly 1 readwrite
 
     if (dbpath == null || dbpath.length === 0) {
         doError(new Error('No database specified'), callback);
@@ -2213,9 +2272,9 @@ ServiceManager.prototype._fixpropertie = function (options, callback) {
 		}
     }
     if (forcewrite) blr.addBytes([isc_spb_prp_write_mode, isc_spb_prp_wm_sync]);
-    if (forcewrite != null && !forcewrite) blr.addBytes([isc_spb_prp_write_mode, isc_spb_prp_wm_async]);
-    if (accessmode) blr.addBytes([isc_spb_prp_access_mode, isc_spb_prp_am_readwrite]);
-    if (accessmode != null && !accessmode) blr.addBytes([isc_spb_prp_access_mode, isc_spb_prp_am_readonly]);
+    if (forcewrite === false) blr.addBytes([isc_spb_prp_write_mode, isc_spb_prp_wm_async]);
+    if (accessmode === 1) blr.addBytes([isc_spb_prp_access_mode, isc_spb_prp_am_readwrite]);
+    if (accessmode === 0) blr.addBytes([isc_spb_prp_access_mode, isc_spb_prp_am_readonly]);
     if (reservespace) blr.addBytes([isc_spb_prp_reserve_space, isc_spb_prp_res]);
     if (reservespace != null && !reservespace) blr.addBytes([isc_spb_prp_reserve_space, isc_spb_prp_res_use_full]);
     var opts = 0;
@@ -2265,6 +2324,11 @@ const SHUTDOWNEX_MODE = {
 	2: isc_spb_prp_sm_single,
 	3: isc_spb_prp_sm_full
 };
+const ShutdownMode = { NORMAL: 0, MULTI: 1, SINGLE: 2, FULL: 3 };
+const ShutdownKind = { FORCED: 0, DENY_TRANSACTION: 1, DENY_ATTACHMENT: 2 };
+exports.ShutdownMode = ShutdownMode;
+exports.ShutdownKind = ShutdownKind;
+
 ServiceManager.prototype.Shutdown = function (db, kind, delay, mode, callback) {
     // mode parameter is for server version >= 2.0
 	if (mode instanceof Function) {
@@ -2355,7 +2419,7 @@ ServiceManager.prototype.commit = function(db, transactid, callback) {
             doError(new Error(err), callback);
             return;
         }
-        self._createOutputStream(options.optread, options.buffersize, callback);
+        self._createOutputStream(null, null, callback);
     });
 }
 
@@ -2376,7 +2440,7 @@ ServiceManager.prototype.rollback = function (db, transactid, callback) {
             doError(new Error(err), callback);
             return;
         }
-        self._createOutputStream(options.optread, options.buffersize, callback);
+        self._createOutputStream(null, null, callback);
     });
 }
 
@@ -2397,7 +2461,7 @@ ServiceManager.prototype.recover = function (db, transactid, callback) {
             doError(new Error(err), callback);
             return;
         }
-        self._createOutputStream(options.optread, options.buffersize, callback);
+        self._createOutputStream(null, null, callback);
     });
 }
 
@@ -2576,12 +2640,11 @@ ServiceManager.prototype.getFbserverInfos = function (infos, options, callback)
     };
     // if infos is empty all options are asked to the service
 
-    var tops = [];
+    var tops = [], empty = isEmpty(infos);
     for (popts in opts)
-        if (infos[popts] || infos.length == 0)
+        if (empty || infos[popts])
             tops.push(opts[popts]);
 
-
     var self = this;
     this.connection.svcquery(tops, buffersize, timeout, function (err, data) {
         if (err || !data.buffer) {
@@ -2592,6 +2655,11 @@ ServiceManager.prototype.getFbserverInfos = function (infos, options, callback)
     });
 }
 
+function isEmpty(obj){
+    for(var p in obj) return false;
+    return true;
+}
+
 ServiceManager.prototype.startTrace = function (options, callback) {
     var self = this;
     var blr = this.connection._blr;
@@ -2689,7 +2757,6 @@ ServiceManager.prototype.stopTrace = function (options, callback) {
 ServiceManager.prototype.getTraceList = function (options, callback) {
     var self = this;
     var blr = this.connection._blr;
-    var optread = options.optread || 'byline';
     blr.pos = 0;
     blr.addByte(isc_action_svc_trace_list);
     this.connection.svcstart(blr, function (err, data) {
@@ -2767,7 +2834,7 @@ ServiceManager.prototype.readlimbo = function (options, callback) {
 }
 
 // Pooling
-exports.pool = function(max, options, callback) {
+exports.pool = function(max, options) {
 	return new Pool(max, Object.assign({}, options, { isPool: true }));
 };
 
@@ -2838,17 +2905,40 @@ Pool.prototype.check = function() {
     return self;
 };
 
-Pool.prototype.destroy = function() {
+Pool.prototype.destroy = function(callback) {
     var self = this;
+
+    var connectionCount = this.internaldb.length;
+
+    if (connectionCount === 0 && callback) {
+        callback();
+    }
+
+    function detachCallback(err) {
+        if (err) {
+            if (callback) {
+                callback(err);
+            }
+            return;
+        }
+
+        connectionCount--;
+        if (connectionCount === 0 && callback) {
+            callback();
+        }
+    }
+
     this.internaldb.forEach(function(db) {
-        if (db.connection._pooled === false)
+        if (db.connection._pooled === false) {
+            detachCallback();
             return;
+        }
         // check if the db is not free into the pool otherwise user should manual detach it
         var _db_in_pool = self.pooldb.indexOf(db);
         if (_db_in_pool !== -1) {
             self.pooldb.splice(_db_in_pool, 1);
             db.connection._pooled = false;
-            db.detach();
+            db.detach(detachCallback);
         }
     });
 };
@@ -2871,6 +2961,7 @@ var Connection = exports.Connection = function (host, port, callback, options, d
     this._detachAuto;
     this._socket = net.createConnection(port, host);
     this._pending = [];
+    this._isOpened = false;
     this._isClosed = false;
     this._isDetach = false;
     this._isUsed = false;
@@ -2878,6 +2969,8 @@ var Connection = exports.Connection = function (host, port, callback, options, d
     this.options = options;
     this._bind_events(host, port, callback);
     this.error;
+    this._retry_connection_id;
+    this._retry_connection_interval = options.retryConnectionInterval || 1000;
     this._max_cached_query = options.maxCachedQuery || -1;
     this._cache_query = options.cacheQuery?{}:null;
     this._messageFile = options.messageFile || path.join(__dirname, 'firebird.msg');
@@ -2903,10 +2996,11 @@ exports.Connection.prototype._bind_events = function(host, port, callback) {
 
     self._socket.on('close', function() {
 
-        self._isClosed = true;
-
-        if (self._isDetach)
+        if (!self._isOpened || self._isDetach) {
             return;
+        }
+
+        self._isOpened = false;
 
         if (!self.db) {
             if (callback)
@@ -2914,10 +3008,9 @@ exports.Connection.prototype._bind_events = function(host, port, callback) {
             return;
         }
 
-        setImmediate(function() {
+       self._retry_connection_id = setTimeout(function() {
+            self._socket.removeAllListeners();
             self._socket = null;
-            self._msg = null;
-            self._blr = null;
 
             var ctx = new Connection(host, port, function(err) {
                 ctx.connect(self.options, function(err) {
@@ -2941,8 +3034,10 @@ exports.Connection.prototype._bind_events = function(host, port, callback) {
                     }, self.db);
                 });
 
+				Object.assign(self, ctx);
+
             }, self.options, self.db);
-        });
+        }, self._retry_connection_interval);
 
     });
 
@@ -3165,14 +3260,7 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
 
                     data.fcolumn = 0;
                     statement.connection.db.emit('row', data.frow, statement.nbrowsfetched, custom.asObject);
-
-                    if (!custom.asStream) {
-                        data.frows.push(data.frow);
-                    }
-
-                    if (custom.on) {
-                        custom.on(data.frow, statement.nbrowsfetched);
-                    }
+                    data.frows.push(data.frow);
                     data.frow = custom.asObject ? {} : new Array(output.length);
 
                     try {
@@ -3215,22 +3303,77 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     protocolArchitecture: data.readInt(),
                     protocolMinimumType: data.readInt(),
                     pluginName: '',
-                    authData: ''
+                    authData: '',
+					sessionKey: ''
                 };
 
                 accept.protocolMinimumType = accept.protocolMinimumType & 0xFF;
+				//accept.compress = (accept.acceptType & pflag_compress) !== 0; // TODO Handle zlib compression
                 if (accept.protocolVersion < 0) {
                     accept.protocolVersion = (accept.protocolVersion & FB_PROTOCOL_MASK) | FB_PROTOCOL_FLAG;
                 }
 
                 if (r === op_cond_accept || r === op_accept_data) {
-                    var d = data.readString(DEFAULT_ENCODING);
+                    var d = new BlrReader(data.readArray());
                     accept.pluginName = data.readString(DEFAULT_ENCODING);
                     var is_authenticated = data.readInt();
                     var keys = data.readString(DEFAULT_ENCODING); // keys
 
                     if (is_authenticated === 0) {
-                        if (accept.pluginName === AUTH_PLUGIN_LEGACY) {
+                    	if (cnx.options.pluginName && cnx.options.pluginName !== accept.pluginName) {
+                    		doError(new Error('Server don\'t accept plugin : ' + cnx.options.pluginName + ', but support : ' + accept.pluginName), callback);
+						}
+
+                    	if (AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1) {
+							var crypto = {
+								Srp: 'sha1',
+								Srp256: 'sha256'
+							};
+							accept.srpAlgo = crypto[accept.pluginName];
+
+							// TODO : Fallback Srp256 to Srp ?
+							/*if (!d.buffer) {
+								cnx.sendOpContAuth(
+									cnx.clientKeys.public.toString(16),
+									DEFAULT_ENCODING,
+									accept.pluginName
+								);
+
+								return cb(new Error('login'));
+							}*/
+
+							// Check buffer contains salt
+							var saltLen = d.buffer.readUInt16LE(0);
+							if (saltLen > 32 * 2) {
+								console.log('salt to long'); // TODO : Throw error
+							}
+
+							// Check buffer contains key
+							var keyLen = d.buffer.readUInt16LE(saltLen + 2);
+							var keyStart = saltLen + 4;
+							if (d.buffer.length - keyStart !== keyLen) {
+								console.log('key error'); // TODO : Throw error
+							}
+
+							// Server keys
+							cnx.serverKeys = {
+								salt: d.buffer.slice(2, saltLen + 2).toString('utf8'),
+								public: BigInt(d.buffer.slice(keyStart, d.buffer.length).toString('utf8'), 16)
+							};
+
+							var proof = srp.clientProof(
+								cnx.options.user.toUpperCase(),
+								cnx.options.password,
+								cnx.serverKeys.salt,
+								cnx.clientKeys.public,
+								cnx.serverKeys.public,
+								cnx.clientKeys.private,
+								accept.srpAlgo
+							);
+
+							accept.authData = proof.authData.toString(16);
+							accept.sessionKey = proof.clientSessionKey;
+						} else if (accept.pluginName === AUTH_PLUGIN_LEGACY) {
                             accept.authData = crypt.crypt(cnx.options.password, LEGACY_AUTH_SALT).substring(2);
                         } else {
                             return cb(new Error('Unknow auth plugin : ' + accept.pluginName));
@@ -3240,7 +3383,35 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                         accept.sessionKey = '';
                     }
                 }
+
                 return cb(undefined, accept);
+			case op_cont_auth:
+				var d = new BlrReader(data.readArray());
+				var pluginName = data.readString(DEFAULT_ENCODING);
+				data.readString(DEFAULT_ENCODING); // plist
+				data.readString(DEFAULT_ENCODING); // pkey
+
+				if (!cnx.options.pluginName) {
+					if (cnx.accept.pluginName === pluginName) {
+						// Erreur plugin not able to connect
+						return cb(new Error("Unable to connect with plugin " + cnx.accept.pluginName));
+					}
+
+					if (pluginName === AUTH_PLUGIN_LEGACY) { // Fallback to LegacyAuth
+						cnx.accept.pluginName = pluginName;
+						cnx.accept.authData = crypt.crypt(cnx.options.password, LEGACY_AUTH_SALT).substring(2);
+
+						cnx.sendOpContAuth(
+							cnx.accept.authData,
+							DEFAULT_ENCODING,
+							pluginName
+						);
+
+						return {error: new Error('login')};
+					}
+				}
+
+				return data.accept;
             default:
                 return cb(new Error('Unexpected:' + r));
         }
@@ -3326,6 +3497,20 @@ function parseOpResponse(data, response, cb) {
     }
 }
 
+Connection.prototype.sendOpContAuth = function(authData, authDataEnc, pluginName) {
+	var msg = this._msg;
+	msg.pos = 0;
+
+	msg.addInt(op_cont_auth);
+	msg.addString(authData, authDataEnc);
+	msg.addString(pluginName, DEFAULT_ENCODING)
+	msg.addString(AUTH_PLUGIN_LIST.join(','), DEFAULT_ENCODING);
+	// msg.addInt(0); // p_list
+	msg.addInt(0); // keys
+
+	this._socket.write(msg.getData());
+}
+
 Connection.prototype._queueEvent = function(callback){
     var self = this;
 
@@ -3340,7 +3525,7 @@ Connection.prototype._queueEvent = function(callback){
 };
 
 Connection.prototype.connect = function (options, callback) {
-	var pluginName = AUTH_PLUGIN_LEGACY;
+	var pluginName = options.manager ? AUTH_PLUGIN_LEGACY : options.pluginName || AUTH_PLUGIN_LIST[0]; // TODO Srp for service
     var msg = this._msg;
     var blr = this._blr;
 
@@ -3353,13 +3538,19 @@ Connection.prototype.connect = function (options, callback) {
 	blr.addString(CNCT_plugin_name, pluginName, DEFAULT_ENCODING);
 	blr.addString(CNCT_plugin_list, AUTH_PLUGIN_LIST.join(','), DEFAULT_ENCODING);
 
-	if (pluginName === AUTH_PLUGIN_LEGACY) {
-		var specificData = crypt.crypt(options.password, LEGACY_AUTH_SALT).substring(2);
+	var specificData = '';
+	if (AUTH_PLUGIN_SRP_LIST.indexOf(pluginName) > -1) {
+		this.clientKeys = srp.clientSeed();
+		specificData = this.clientKeys.public.toString(16);
+		blr.addMultiblockPart(CNCT_specific_data, specificData, DEFAULT_ENCODING);
+	} else if (pluginName === AUTH_PLUGIN_LEGACY) {
+		specificData = crypt.crypt(options.password, LEGACY_AUTH_SALT).substring(2);
 		blr.addMultiblockPart(CNCT_specific_data, specificData, DEFAULT_ENCODING);
 	} else {
-		throw new Error('Invalide auth plugin');
+		doError(new Error('Invalide auth plugin \'' + pluginName + '\''), callback);
+		return;
 	}
-	blr.addBytes([CNCT_client_crypt, 4, 0, 0, 0, 0]); // WireCrypt = Disabled
+	blr.addBytes([CNCT_client_crypt, 4, WIRE_CRYPT_DISABLE, 0, 0, 0]); // WireCrypt = Disabled
 	blr.addString(CNCT_user, os.userInfo().username || 'Unknown', DEFAULT_ENCODING);
     blr.addString(CNCT_host, os.hostname(), DEFAULT_ENCODING);
     blr.addBytes([CNCT_user_verification, 0]);
@@ -3416,19 +3607,25 @@ Connection.prototype.attach = function (options, callback, db) {
     blr.addByte(isc_dpb_version1);
     blr.addString(isc_dpb_lc_ctype, 'UTF8', DEFAULT_ENCODING);
     blr.addString(isc_dpb_user_name, user, DEFAULT_ENCODING);
-	if (this.accept.protocolVersion < PROTOCOL_VERSION13) {
-		if (this.accept.protocolVersion === PROTOCOL_VERSION10) {
-			blr.addString(isc_dpb_password, password, DEFAULT_ENCODING);
-		} else {
-			blr.addString(isc_dpb_password_enc, crypt.crypt(password, LEGACY_AUTH_SALT).substring(2), DEFAULT_ENCODING);
+	if (options.password && !this.accept.authData) {
+		if (this.accept.protocolVersion < PROTOCOL_VERSION13) {
+			if (this.accept.protocolVersion === PROTOCOL_VERSION10) {
+				blr.addString(isc_dpb_password, password, DEFAULT_ENCODING);
+			} else {
+				blr.addString(isc_dpb_password_enc, crypt.crypt(password, LEGACY_AUTH_SALT).substring(2), DEFAULT_ENCODING);
+			}
 		}
 	}
+
     if (role)
         blr.addString(isc_dpb_sql_role_name, role, DEFAULT_ENCODING);
 
 	blr.addBytes([isc_dpb_process_id, 4]);
 	blr.addInt32(process.pid);
-    blr.addString(isc_dpb_process_name, process.title, DEFAULT_ENCODING);
+
+	let processName  = process.title || "";
+	blr.addString(isc_dpb_process_name, processName.length > 255 ? processName.substring(processName.length - 255,  processName.length) : processName, DEFAULT_ENCODING);
+
 	if (this.accept.authData) {
 		blr.addString(isc_dpb_specific_auth_data, this.accept.authData, DEFAULT_ENCODING);
 	}
@@ -3479,6 +3676,7 @@ Connection.prototype.detach = function (callback) {
     msg.addInt(0); // Database Object ID
 
     self._queueEvent(function(err, ret) {
+        clearTimeout(self._retry_connection_id);
         delete(self.dbhandle);
         if (callback)
             callback(err, ret);
@@ -3515,7 +3713,10 @@ Connection.prototype.createDatabase = function (options, callback) {
 
 	blr.addBytes([isc_dpb_process_id, 4]);
 	blr.addInt32(process.pid);
-	blr.addString(isc_dpb_process_name, process.title, DEFAULT_ENCODING);
+
+	let processName  = process.title || "";
+	blr.addString(isc_dpb_process_name, processName.length > 255 ? processName.substring(processName.length - 255,  processName.length) : processName, DEFAULT_ENCODING);
+
 	if (this.accept.authData) {
 		blr.addString(isc_dpb_specific_auth_data, this.accept.authData, DEFAULT_ENCODING);
 	}
@@ -3598,11 +3799,6 @@ Connection.prototype.startTransaction = function(isolation, callback) {
     blr.pos = 0;
     msg.pos = 0;
 
-    if (isolation instanceof Function) {
-        callback = isolation;
-        isolation = null;
-    }
-
     blr.addBytes(isolation || ISOLATION_REPEATABLE_READ);
     msg.addInt(op_transaction);
     msg.addInt(this.dbhandle);
@@ -4313,43 +4509,40 @@ Connection.prototype.fetch = function(statement, transaction, count, callback) {
     msg.addInt(0); // message number
     msg.addInt(count || DEFAULT_FETCHSIZE); // fetch count
 
-    if (!transaction) {
-        callback.statement = statement;
-        this._queueEvent(callback);
-        return;
-    }
-
     callback.statement = statement;
     this._queueEvent(callback);
 };
 
-Connection.prototype.fetchAll = function(statement, transaction, callback) {
-
-    var self = this;
-    var data;
-    var loop = function(err, ret) {
-
-        if (err) {
-            callback(err);
-            return;
-        }
-
-        if (!data) {
-            data = ret.data;
-        } else {
-            for (var i = 0, length = ret.data.length; i < length; i++)
-                data.push(ret.data[i]);
-        }
-
-        if (ret.fetched)
-            callback(undefined, data);
-        else
-            self.fetch(statement, transaction, DEFAULT_FETCHSIZE, loop);
-    }
+Connection.prototype.fetchAll = function (statement, transaction, callback) {
+	var self = this, data = [];
+	var loop = function (err, ret) {
+		if (err) {
+			return callback(err);
+		} else if (ret && ret.data && ret.data.length) {
+			for (var i = 0; i < ret.data.length; i++) {
+				var pos = data.push(ret.data[i]);
+				if (statement.custom && statement.custom.asStream && statement.custom.on) {
+					statement.custom.on(ret.data[i], pos - 1);
+				}
+				if (i === ret.data.length - 1) {
+					if (ret.fetched) {
+						return callback(undefined, data);
+					} else {
+						self.fetch(statement, transaction, DEFAULT_FETCHSIZE, loop);
+					}
+				}
+			}
+		} else if (ret.fetched) {
+			callback(undefined, data);
+		} else {
+			self.fetch(statement, transaction, DEFAULT_FETCHSIZE, loop);
+		}
+	}
 
-    this.fetch(statement, transaction, DEFAULT_FETCHSIZE, loop);
+	this.fetch(statement, transaction, DEFAULT_FETCHSIZE, loop);
 };
 
+
 Connection.prototype.openBlob = function(blob, transaction, callback) {
     var msg = this._msg;
     msg.pos = 0;