Skip to content
This repository has been archived by the owner on Apr 22, 2023. It is now read-only.

Commit

Permalink
TLS: Simplify code from suck and blow
Browse files Browse the repository at this point in the history
  • Loading branch information
@ry
ry committed Dec 11, 2010
1 parent 66767ed commit 6636bfa
Showing 1 changed file with 79 additions and 117 deletions.
196 changes: 79 additions & 117 deletions lib/tls.js
View file
Expand Up @@ -93,89 +93,73 @@ CryptoStream.prototype.destroy = function(err) {
};


function CleartextStream (pair) {
CryptoStream.call(this, pair);
}
util.inherits(CleartextStream, CryptoStream);


// Push in any clear data coming from the application.
// This arrives via some code like this:
//
// pair.cleartext.write("hello world");
//
CleartextStream.prototype._suck = function() {
var tmp, rv;
var havePending = this._pending.length > 0;

while (this._pending.length > 0) {
tmp = this._pending.shift();
try {
debug('writng from clearIn');
rv = this.pair._ssl.clearIn(tmp, 0, tmp.length);
} catch (e) {
return this.pair._error(e);
}

if (rv === 0) {
this._pending.unshift(tmp);
break;
}

assert(rv === tmp.length);
}

// If we've cleared all of incoming cleartext data, emit drain.
if (havePending && this._pending.length === 0) {
debug('cleartext drain');
this.emit('drain');
}
};


// Move decrypted, clear data out into the application.
// From the user's perspective this occurs as a 'data' event
// on the pair.cleartext.
CleartextStream.prototype._blow = function() {
var self = this;
self.pair._mover(
function(pool, offset, length) {
debug('reading from clearOut');
return self.pair._ssl.clearOut(pool, offset, length);
},
function(chunk) {
self.emit('data', chunk);
},
function() {
return self._writeState === true;
});
};

// also
// Move encrypted data to the stream. From the user's perspective this
// occurs as a 'data' event on the pair.encrypted. Usually the application
// will have some code which pipes the stream to a socket:
//
// pair.encrypted.on('data', function (d) {
// socket.write(d);
// });
//
CryptoStream.prototype._blow = function() {
var bytesRead;
var pool;
var chunkBytes;
var chunk;

do {
bytesRead = 0;
chunkBytes = 0;
pool = new Buffer(4096); // alloc every time?
pool.used = 0;

do {
try {
chunkBytes = this._blower(pool,
pool.used + bytesRead,
pool.length - pool.used - bytesRead);
} catch (e) {
return this.pair._error(e);
}
if (chunkBytes >= 0) {
bytesRead += chunkBytes;
}
} while ((chunkBytes > 0) && (pool.used + bytesRead < pool.length));

function EncryptedStream (pair) {
CryptoStream.call(this, pair);
}
util.inherits(EncryptedStream, CryptoStream);
if (bytesRead > 0) {
chunk = pool.slice(0, bytesRead);
this.emit('data', chunk);
}
} while (bytesRead > 0 && this._writeState === true);
};


// Push in any clear data coming from the application.
// This arrives via some code like this:
//
// pair.cleartext.write("hello world");
//
// also
//
// Push in incoming encrypted data from the socket.
// This arrives via some code like this:
//
// socket.on('data', function (d) {
// pair.encrypted.write(d)
// });
//
EncryptedStream.prototype._suck = function() {
CryptoStream.prototype._suck = function() {
var tmp, rv;
var havePending = this._pending.length > 0;
while (this._pending.length > 0) {
tmp = this._pending.shift();

try {
debug('writing from encIn');
rv = this.pair._ssl.encIn(tmp, 0, tmp.length);
rv = this._sucker(tmp);
} catch (e) {
return this.pair._error(e);
}
Expand All @@ -190,39 +174,48 @@ EncryptedStream.prototype._suck = function() {

// If we've cleared all of incoming encrypted data, emit drain.
if (havePending && this._pending && this._pending.length === 0) {
debug('encrypted drain');
debug('drain');
this.emit('drain');
}
};


function CleartextStream (pair) {
CryptoStream.call(this, pair);
}
util.inherits(CleartextStream, CryptoStream);


// Move encrypted data to the stream. From the user's perspective this
// occurs as a 'data' event on the pair.encrypted. Usually the application
// will have some code which pipes the stream to a socket:
//
// pair.encrypted.on('data', function (d) {
// socket.write(d);
// });
//
EncryptedStream.prototype._blow = function () {
var self = this;
CleartextStream.prototype._sucker = function(b) {
debug('writng from clearIn');
return this.pair._ssl.clearIn(b, 0, b.length);
};


CleartextStream.prototype._blower = function(pool, offset, length) {
debug('reading from clearOut');
return this.pair._ssl.clearOut(pool, offset, length);
};


self.pair._mover(
function(pool, offset, length) {
debug('reading from encOut');
if (!self.pair._ssl) return -1;
return self.pair._ssl.encOut(pool, offset, length);
},
function(chunk) {
self.emit('data', chunk);
},
function() {
if (!self.pair._ssl) return false;
return self._writeState === true;
});
function EncryptedStream (pair) {
CryptoStream.call(this, pair);
}
util.inherits(EncryptedStream, CryptoStream);


EncryptedStream.prototype._sucker = function(b) {
debug('writing from encIn');
return this.pair._ssl.encIn(b, 0, b.length);
};


EncryptedStream.prototype._blower = function(pool, offset, length) {
debug('reading from encOut');
if (!this.pair._ssl) return -1;
return this.pair._ssl.encOut(pool, offset, length);
};


/**
* Provides a pair of streams to do encrypted communication.
Expand Down Expand Up @@ -304,37 +297,6 @@ exports.createSecurePair = function(credentials,
};


SecurePair.prototype._mover = function(reader, writer, checker) {
var bytesRead;
var pool;
var chunkBytes;
var chunk;

do {
bytesRead = 0;
chunkBytes = 0;
pool = new Buffer(4096); // alloc every time?
pool.used = 0;

do {
try {
chunkBytes = reader(pool,
pool.used + bytesRead,
pool.length - pool.used - bytesRead);
} catch (e) {
return this._error(e);
}
if (chunkBytes >= 0) {
bytesRead += chunkBytes;
}
} while ((chunkBytes > 0) && (pool.used + bytesRead < pool.length));

if (bytesRead > 0) {
chunk = pool.slice(0, bytesRead);
writer(chunk);
}
} while (bytesRead > 0 && checker());
};


/**
Expand Down

0 comments on commit 6636bfa

Please sign in to comment.