lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Rename node::SecureStream to node::crypto::Connection 

node::SecureStream is definitely not a "stream" in the Node sense. Renaming
it to avoid ambiguity. (Adding namespace to not confuse with some other
Connection object.)
v0.7.4-release
Ryan Dahl 14 years ago
parent
6636bfaa0a
commit
e3d1808ef0
4 changed files with 74 additions and 71 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      lib/crypto.js
  2. 19
      lib/tls.js
  3. 104
      src/node_crypto.cc
  4. 11
      src/node_crypto.h

1
lib/crypto.js
View File

@ -2,7 +2,6 @@
try {
var binding = process.binding('crypto');
var SecureContext = binding.SecureContext;
var SecureStream = binding.SecureStream;
var Hmac = binding.Hmac;
var Hash = binding.Hash;
var Cipher = binding.Cipher;

19
lib/tls.js
View File

@ -15,8 +15,14 @@ if (debugLevel & 0x2) {
}
/* Lazy Loaded crypto object */
var SecureStream = null; // note SecureStream is not a "real" stream.
var Connection = null;
try {
Connection = process.binding('crypto').Connection;
}
catch (e) {
throw new Error('node.js not compiled with openssl crypto support.');
}
// Base class of both CleartextStream and EncryptedStream
function CryptoStream (pair) {
@ -231,13 +237,6 @@ function SecurePair(credentials, isServer, requestCert, rejectUnauthorized) {
var self = this;
try {
SecureStream = process.binding('crypto').SecureStream;
}
catch (e) {
throw new Error('node.js not compiled with openssl crypto support.');
}
events.EventEmitter.call(this);
this._secureEstablished = false;
@ -264,7 +263,7 @@ function SecurePair(credentials, isServer, requestCert, rejectUnauthorized) {
this._rejectUnauthorized = rejectUnauthorized ? true : false;
this._requestCert = requestCert ? true : false;
this._ssl = new SecureStream(this.credentials.context,
this._ssl = new Connection(this.credentials.context,
this._isServer ? true : false,
this._requestCert,
this._rejectUnauthorized);

104
src/node_crypto.cc
View File

@ -17,6 +17,7 @@
#endif
namespace node {
namespace crypto {
using namespace v8;
@ -307,29 +308,29 @@ static int serr(SSL *ssl, const char* func, int rv) {
return 0;
}
void SecureStream::Initialize(Handle<Object> target) {
void Connection::Initialize(Handle<Object> target) {
HandleScope scope;
Local<FunctionTemplate> t = FunctionTemplate::New(SecureStream::New);
Local<FunctionTemplate> t = FunctionTemplate::New(Connection::New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(String::NewSymbol("SecureStream"));
t->SetClassName(String::NewSymbol("Connection"));
NODE_SET_PROTOTYPE_METHOD(t, "encIn", SecureStream::EncIn);
NODE_SET_PROTOTYPE_METHOD(t, "clearOut", SecureStream::ClearOut);
NODE_SET_PROTOTYPE_METHOD(t, "clearIn", SecureStream::ClearIn);
NODE_SET_PROTOTYPE_METHOD(t, "encOut", SecureStream::EncOut);
NODE_SET_PROTOTYPE_METHOD(t, "clearPending", SecureStream::ClearPending);
NODE_SET_PROTOTYPE_METHOD(t, "encPending", SecureStream::EncPending);
NODE_SET_PROTOTYPE_METHOD(t, "getPeerCertificate", SecureStream::GetPeerCertificate);
NODE_SET_PROTOTYPE_METHOD(t, "isInitFinished", SecureStream::IsInitFinished);
NODE_SET_PROTOTYPE_METHOD(t, "verifyError", SecureStream::VerifyError);
NODE_SET_PROTOTYPE_METHOD(t, "getCurrentCipher", SecureStream::GetCurrentCipher);
NODE_SET_PROTOTYPE_METHOD(t, "start", SecureStream::Start);
NODE_SET_PROTOTYPE_METHOD(t, "shutdown", SecureStream::Shutdown);
NODE_SET_PROTOTYPE_METHOD(t, "receivedShutdown", SecureStream::ReceivedShutdown);
NODE_SET_PROTOTYPE_METHOD(t, "close", SecureStream::Close);
NODE_SET_PROTOTYPE_METHOD(t, "encIn", Connection::EncIn);
NODE_SET_PROTOTYPE_METHOD(t, "clearOut", Connection::ClearOut);
NODE_SET_PROTOTYPE_METHOD(t, "clearIn", Connection::ClearIn);
NODE_SET_PROTOTYPE_METHOD(t, "encOut", Connection::EncOut);
NODE_SET_PROTOTYPE_METHOD(t, "clearPending", Connection::ClearPending);
NODE_SET_PROTOTYPE_METHOD(t, "encPending", Connection::EncPending);
NODE_SET_PROTOTYPE_METHOD(t, "getPeerCertificate", Connection::GetPeerCertificate);
NODE_SET_PROTOTYPE_METHOD(t, "isInitFinished", Connection::IsInitFinished);
NODE_SET_PROTOTYPE_METHOD(t, "verifyError", Connection::VerifyError);
NODE_SET_PROTOTYPE_METHOD(t, "getCurrentCipher", Connection::GetCurrentCipher);
NODE_SET_PROTOTYPE_METHOD(t, "start", Connection::Start);
NODE_SET_PROTOTYPE_METHOD(t, "shutdown", Connection::Shutdown);
NODE_SET_PROTOTYPE_METHOD(t, "receivedShutdown", Connection::ReceivedShutdown);
NODE_SET_PROTOTYPE_METHOD(t, "close", Connection::Close);
target->Set(String::NewSymbol("SecureStream"), t->GetFunction());
target->Set(String::NewSymbol("Connection"), t->GetFunction());
}
@ -373,16 +374,16 @@ static int VerifyCallback(int preverify_ok, X509_STORE_CTX *ctx) {
//
// Since we cannot perform I/O quickly enough in this callback, we ignore
// all preverify_ok errors and let the handshake continue. It is
// imparative that the user use SecureStream::VerifyError after the
// imparative that the user use Connection::VerifyError after the
// 'secure' callback has been made.
return 1;
}
Handle<Value> SecureStream::New(const Arguments& args) {
Handle<Value> Connection::New(const Arguments& args) {
HandleScope scope;
SecureStream *p = new SecureStream();
Connection *p = new Connection();
p->Wrap(args.Holder());
if (args.Length() < 1 || !args[0]->IsObject()) {
@ -435,10 +436,10 @@ Handle<Value> SecureStream::New(const Arguments& args) {
}
Handle<Value> SecureStream::EncIn(const Arguments& args) {
Handle<Value> Connection::EncIn(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (args.Length() < 3) {
return ThrowException(Exception::TypeError(
@ -477,10 +478,10 @@ Handle<Value> SecureStream::EncIn(const Arguments& args) {
}
Handle<Value> SecureStream::ClearOut(const Arguments& args) {
Handle<Value> Connection::ClearOut(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (args.Length() < 3) {
return ThrowException(Exception::TypeError(
@ -531,28 +532,28 @@ Handle<Value> SecureStream::ClearOut(const Arguments& args) {
}
Handle<Value> SecureStream::ClearPending(const Arguments& args) {
Handle<Value> Connection::ClearPending(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
int bytes_pending = BIO_pending(ss->bio_read_);
return scope.Close(Integer::New(bytes_pending));
}
Handle<Value> SecureStream::EncPending(const Arguments& args) {
Handle<Value> Connection::EncPending(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
int bytes_pending = BIO_pending(ss->bio_write_);
return scope.Close(Integer::New(bytes_pending));
}
Handle<Value> SecureStream::EncOut(const Arguments& args) {
Handle<Value> Connection::EncOut(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (args.Length() < 3) {
return ThrowException(Exception::TypeError(
@ -586,10 +587,10 @@ Handle<Value> SecureStream::EncOut(const Arguments& args) {
}
Handle<Value> SecureStream::ClearIn(const Arguments& args) {
Handle<Value> Connection::ClearIn(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (args.Length() < 3) {
return ThrowException(Exception::TypeError(
@ -642,10 +643,10 @@ Handle<Value> SecureStream::ClearIn(const Arguments& args) {
}
Handle<Value> SecureStream::GetPeerCertificate(const Arguments& args) {
Handle<Value> Connection::GetPeerCertificate(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (ss->ssl_ == NULL) return Undefined();
Local<Object> info = Object::New();
@ -700,11 +701,11 @@ Handle<Value> SecureStream::GetPeerCertificate(const Arguments& args) {
return scope.Close(info);
}
Handle<Value> SecureStream::Start(const Arguments& args) {
Handle<Value> Connection::Start(const Arguments& args) {
HandleScope scope;
int rv;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (!SSL_is_init_finished(ss->ssl_)) {
if (ss->is_server_) {
@ -728,10 +729,10 @@ Handle<Value> SecureStream::Start(const Arguments& args) {
}
Handle<Value> SecureStream::Shutdown(const Arguments& args) {
Handle<Value> Connection::Shutdown(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (ss->ssl_ == NULL) return False();
int r = SSL_shutdown(ss->ssl_);
@ -740,10 +741,10 @@ Handle<Value> SecureStream::Shutdown(const Arguments& args) {
}
Handle<Value> SecureStream::ReceivedShutdown(const Arguments& args) {
Handle<Value> Connection::ReceivedShutdown(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (ss->ssl_ == NULL) return False();
int r = SSL_get_shutdown(ss->ssl_);
@ -754,18 +755,18 @@ Handle<Value> SecureStream::ReceivedShutdown(const Arguments& args) {
}
Handle<Value> SecureStream::IsInitFinished(const Arguments& args) {
Handle<Value> Connection::IsInitFinished(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (ss->ssl_ == NULL) return False();
return SSL_is_init_finished(ss->ssl_) ? True() : False();
}
Handle<Value> SecureStream::VerifyError(const Arguments& args) {
Handle<Value> Connection::VerifyError(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (ss->ssl_ == NULL) return Null();
@ -906,10 +907,10 @@ Handle<Value> SecureStream::VerifyError(const Arguments& args) {
}
Handle<Value> SecureStream::GetCurrentCipher(const Arguments& args) {
Handle<Value> Connection::GetCurrentCipher(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
OPENSSL_CONST SSL_CIPHER *c;
if ( ss->ssl_ == NULL ) return Undefined();
@ -923,10 +924,10 @@ Handle<Value> SecureStream::GetCurrentCipher(const Arguments& args) {
return scope.Close(info);
}
Handle<Value> SecureStream::Close(const Arguments& args) {
Handle<Value> Connection::Close(const Arguments& args) {
HandleScope scope;
SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
Connection *ss = ObjectWrap::Unwrap<Connection>(args.Holder());
if (ss->ssl_ != NULL) {
SSL_free(ss->ssl_);
@ -2667,7 +2668,7 @@ void InitCrypto(Handle<Object> target) {
ERR_load_crypto_strings();
SecureContext::Initialize(target);
SecureStream::Initialize(target);
Connection::Initialize(target);
Cipher::Initialize(target);
Decipher::Initialize(target);
Hmac::Initialize(target);
@ -2684,7 +2685,8 @@ void InitCrypto(Handle<Object> target) {
version_symbol = NODE_PSYMBOL("version");
}
} // namespace crypto
} // namespace node
NODE_MODULE(node_crypto, node::InitCrypto);
NODE_MODULE(node_crypto, node::crypto::InitCrypto);

11
src/node_crypto.h
View File

@ -16,6 +16,7 @@
namespace node {
namespace crypto {
class SecureContext : ObjectWrap {
public:
@ -52,7 +53,7 @@ class SecureContext : ObjectWrap {
private:
};
class SecureStream : ObjectWrap {
class Connection : ObjectWrap {
public:
static void Initialize(v8::Handle<v8::Object> target);
@ -73,12 +74,12 @@ class SecureStream : ObjectWrap {
static v8::Handle<v8::Value> Start(const v8::Arguments& args);
static v8::Handle<v8::Value> Close(const v8::Arguments& args);
SecureStream() : ObjectWrap() {
Connection() : ObjectWrap() {
bio_read_ = bio_write_ = NULL;
ssl_ = NULL;
}
~SecureStream() {
~Connection() {
if (ssl_ != NULL) {
SSL_free(ssl_);
ssl_ = NULL;
@ -93,6 +94,8 @@ class SecureStream : ObjectWrap {
};
void InitCrypto(v8::Handle<v8::Object> target);
}
} // namespace crypto
} // namespace node
#endif // SRC_NODE_CRYPTO_H_

Write Preview
Loading…
Cancel
Save