From 4901353b982ddbe2820a69c5f7a7abf9f7d6374d Mon Sep 17 00:00:00 2001 From: Ben Noordhuis Date: Mon, 12 Aug 2013 23:39:13 +0200 Subject: [PATCH] crypto: use consistent variable names Code cleanup: don't call a Connection object `p` in some places, `c` in other places and `ss` in yet other places. Let's just call it `conn`. This also fixes about a million style errors in one fell swoop. --- src/node_crypto.cc | 339 +++++++++++++++++++++++++++-------------------------- src/node_crypto.h | 6 +- 2 files changed, 174 insertions(+), 171 deletions(-) diff --git a/src/node_crypto.cc b/src/node_crypto.cc index c9aba04..2d79dac 100644 --- a/src/node_crypto.cc +++ b/src/node_crypto.cc @@ -203,8 +203,8 @@ void SecureContext::Initialize(Handle target) { void SecureContext::New(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - SecureContext *p = new SecureContext(); - p->Wrap(args.This()); + SecureContext* sc = new SecureContext(); + sc->Wrap(args.This()); } @@ -279,11 +279,11 @@ SSL_SESSION* SecureContext::GetSessionCallback(SSL* s, int* copy) { HandleScope scope(node_isolate); - Connection* p = static_cast(SSL_get_app_data(s)); + Connection* conn = static_cast(SSL_get_app_data(s)); *copy = 0; - SSL_SESSION* sess = p->next_sess_; - p->next_sess_ = NULL; + SSL_SESSION* sess = conn->next_sess_; + conn->next_sess_ = NULL; return sess; } @@ -292,7 +292,7 @@ SSL_SESSION* SecureContext::GetSessionCallback(SSL* s, int SecureContext::NewSessionCallback(SSL* s, SSL_SESSION* sess) { HandleScope scope(node_isolate); - Connection* p = static_cast(SSL_get_app_data(s)); + Connection* conn = static_cast(SSL_get_app_data(s)); // Check if session is small enough to be stored int size = i2d_SSL_SESSION(sess, NULL); @@ -314,7 +314,7 @@ int SecureContext::NewSessionCallback(SSL* s, SSL_SESSION* sess) { onnewsession_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onnewsession"); } - MakeCallback(p->handle(node_isolate), + MakeCallback(conn->handle(node_isolate), onnewsession_sym, ARRAY_SIZE(argv), argv); @@ -799,7 +799,7 @@ void SecureContext::SetTicketKeys(const FunctionCallbackInfo& args) { void Connection::OnClientHello(void* arg, const ClientHelloParser::ClientHello& hello) { HandleScope scope(node_isolate); - Connection* c = static_cast(arg); + Connection* conn = static_cast(arg); if (onclienthello_sym.IsEmpty()) onclienthello_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onclienthello"); @@ -812,7 +812,7 @@ void Connection::OnClientHello(void* arg, hello.session_size())); Handle argv[1] = { obj }; - MakeCallback(c->handle(node_isolate), + MakeCallback(conn->handle(node_isolate), onclienthello_sym, ARRAY_SIZE(argv), argv); @@ -820,14 +820,14 @@ void Connection::OnClientHello(void* arg, void Connection::OnClientHelloParseEnd(void* arg) { - Connection* c = static_cast(arg); + Connection* conn = static_cast(arg); // Write all accumulated data - int r = BIO_write(c->bio_read_, - reinterpret_cast(c->hello_data_), - c->hello_offset_); - c->HandleBIOError(c->bio_read_, "BIO_write", r); - c->SetShutdownFlags(); + int r = BIO_write(conn->bio_read_, + reinterpret_cast(conn->hello_data_), + conn->hello_offset_); + conn->HandleBIOError(conn->bio_read_, "BIO_write", r); + conn->SetShutdownFlags(); } @@ -1074,14 +1074,14 @@ int Connection::AdvertiseNextProtoCallback_(SSL *s, const unsigned char** data, unsigned int *len, void *arg) { - Connection *p = static_cast(SSL_get_app_data(s)); + Connection* conn = static_cast(SSL_get_app_data(s)); - if (p->npnProtos_.IsEmpty()) { + if (conn->npnProtos_.IsEmpty()) { // No initialization - no NPN protocols *data = reinterpret_cast(""); *len = 0; } else { - Local obj = PersistentToLocal(node_isolate, p->npnProtos_); + Local obj = PersistentToLocal(node_isolate, conn->npnProtos_); *data = reinterpret_cast(Buffer::Data(obj)); *len = Buffer::Length(obj); } @@ -1093,24 +1093,24 @@ int Connection::SelectNextProtoCallback_(SSL *s, unsigned char** out, unsigned char* outlen, const unsigned char* in, unsigned int inlen, void *arg) { - Connection *p = static_cast SSL_get_app_data(s); + Connection* conn = static_cast(SSL_get_app_data(s)); // Release old protocol handler if present - p->selectedNPNProto_.Dispose(); + conn->selectedNPNProto_.Dispose(); - if (p->npnProtos_.IsEmpty()) { + if (conn->npnProtos_.IsEmpty()) { // We should at least select one protocol // If server is using NPN *out = reinterpret_cast(const_cast("http/1.1")); *outlen = 8; // set status unsupported - p->selectedNPNProto_.Reset(node_isolate, False(node_isolate)); + conn->selectedNPNProto_.Reset(node_isolate, False(node_isolate)); return SSL_TLSEXT_ERR_OK; } - Local obj = PersistentToLocal(node_isolate, p->npnProtos_); + Local obj = PersistentToLocal(node_isolate, conn->npnProtos_); const unsigned char* npnProtos = reinterpret_cast(Buffer::Data(obj)); @@ -1119,16 +1119,16 @@ int Connection::SelectNextProtoCallback_(SSL *s, switch (status) { case OPENSSL_NPN_UNSUPPORTED: - p->selectedNPNProto_.Reset(node_isolate, Null(node_isolate)); + conn->selectedNPNProto_.Reset(node_isolate, Null(node_isolate)); break; case OPENSSL_NPN_NEGOTIATED: { Local string = OneByteString(node_isolate, *out, *outlen); - p->selectedNPNProto_.Reset(node_isolate, string); + conn->selectedNPNProto_.Reset(node_isolate, string); break; } case OPENSSL_NPN_NO_OVERLAP: - p->selectedNPNProto_.Reset(node_isolate, False(node_isolate)); + conn->selectedNPNProto_.Reset(node_isolate, False(node_isolate)); break; default: break; @@ -1142,24 +1142,24 @@ int Connection::SelectNextProtoCallback_(SSL *s, int Connection::SelectSNIContextCallback_(SSL *s, int *ad, void* arg) { HandleScope scope(node_isolate); - Connection *p = static_cast SSL_get_app_data(s); + Connection* conn = static_cast(SSL_get_app_data(s)); const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name); if (servername) { - p->servername_.Reset(node_isolate, + conn->servername_.Reset(node_isolate, OneByteString(node_isolate, servername)); // Call the SNI callback and use its return value as context - if (!p->sniObject_.IsEmpty()) { - p->sniContext_.Dispose(); + if (!conn->sniObject_.IsEmpty()) { + conn->sniContext_.Dispose(); - Local arg = PersistentToLocal(node_isolate, p->servername_); - Local ret = MakeCallback(p->sniObject_, "onselect", 1, &arg); + Local arg = PersistentToLocal(node_isolate, conn->servername_); + Local ret = MakeCallback(conn->sniObject_, "onselect", 1, &arg); // If ret is SecureContext if (HasInstance(secure_context_constructor, ret)) { - p->sniContext_.Reset(node_isolate, ret); + conn->sniContext_.Reset(node_isolate, ret); SecureContext* sc = ObjectWrap::Unwrap(ret.As()); SSL_set_SSL_CTX(s, sc->ctx_); } else { @@ -1175,8 +1175,8 @@ int Connection::SelectSNIContextCallback_(SSL *s, int *ad, void* arg) { void Connection::New(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *p = new Connection(); - p->Wrap(args.This()); + Connection* conn = new Connection; + conn->Wrap(args.This()); if (args.Length() < 1 || !args[0]->IsObject()) { return ThrowError("First argument must be a crypto module Credentials"); @@ -1186,13 +1186,13 @@ void Connection::New(const FunctionCallbackInfo& args) { bool is_server = args[1]->BooleanValue(); - p->ssl_ = SSL_new(sc->ctx_); - p->bio_read_ = BIO_new(NodeBIO::GetMethod()); - p->bio_write_ = BIO_new(NodeBIO::GetMethod()); + conn->ssl_ = SSL_new(sc->ctx_); + conn->bio_read_ = BIO_new(NodeBIO::GetMethod()); + conn->bio_write_ = BIO_new(NodeBIO::GetMethod()); - SSL_set_app_data(p->ssl_, p); + SSL_set_app_data(conn->ssl_, conn); - if (is_server) SSL_set_info_callback(p->ssl_, SSLInfoCallback); + if (is_server) SSL_set_info_callback(conn->ssl_, SSLInfoCallback); #ifdef OPENSSL_NPN_NEGOTIATED if (is_server) { @@ -1214,15 +1214,15 @@ void Connection::New(const FunctionCallbackInfo& args) { SSL_CTX_set_tlsext_servername_callback(sc->ctx_, SelectSNIContextCallback_); } else { const String::Utf8Value servername(args[2]); - SSL_set_tlsext_host_name(p->ssl_, *servername); + SSL_set_tlsext_host_name(conn->ssl_, *servername); } #endif - SSL_set_bio(p->ssl_, p->bio_read_, p->bio_write_); + SSL_set_bio(conn->ssl_, conn->bio_read_, conn->bio_write_); #ifdef SSL_MODE_RELEASE_BUFFERS - long mode = SSL_get_mode(p->ssl_); - SSL_set_mode(p->ssl_, mode | SSL_MODE_RELEASE_BUFFERS); + long mode = SSL_get_mode(conn->ssl_); + SSL_set_mode(conn->ssl_, mode | SSL_MODE_RELEASE_BUFFERS); #endif @@ -1244,12 +1244,12 @@ void Connection::New(const FunctionCallbackInfo& args) { // Always allow a connection. We'll reject in javascript. - SSL_set_verify(p->ssl_, verify_mode, VerifyCallback); + SSL_set_verify(conn->ssl_, verify_mode, VerifyCallback); - if ((p->is_server_ = is_server)) { - SSL_set_accept_state(p->ssl_); + if ((conn->is_server_ = is_server)) { + SSL_set_accept_state(conn->ssl_); } else { - SSL_set_connect_state(p->ssl_); + SSL_set_connect_state(conn->ssl_); } } @@ -1260,21 +1260,21 @@ void Connection::SSLInfoCallback(const SSL *ssl_, int where, int ret) { SSL* ssl = const_cast(ssl_); if (where & SSL_CB_HANDSHAKE_START) { HandleScope scope(node_isolate); - Connection* c = static_cast(SSL_get_app_data(ssl)); + Connection* conn = static_cast(SSL_get_app_data(ssl)); if (onhandshakestart_sym.IsEmpty()) { onhandshakestart_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakestart"); } - MakeCallback(c->handle(node_isolate), onhandshakestart_sym, 0, NULL); + MakeCallback(conn->handle(node_isolate), onhandshakestart_sym, 0, NULL); } if (where & SSL_CB_HANDSHAKE_DONE) { HandleScope scope(node_isolate); - Connection* c = static_cast(SSL_get_app_data(ssl)); + Connection* conn = static_cast(SSL_get_app_data(ssl)); if (onhandshakedone_sym.IsEmpty()) { onhandshakedone_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakedone"); } - MakeCallback(c->handle(node_isolate), onhandshakedone_sym, 0, NULL); + MakeCallback(conn->handle(node_isolate), onhandshakedone_sym, 0, NULL); } } @@ -1282,7 +1282,7 @@ void Connection::SSLInfoCallback(const SSL *ssl_, int where, int ret) { void Connection::EncIn(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); if (args.Length() < 3) { return ThrowTypeError("Takes 3 parameters"); @@ -1304,25 +1304,25 @@ void Connection::EncIn(const FunctionCallbackInfo& args) { int bytes_written; char* data = buffer_data + off; - if (ss->is_server_ && !ss->hello_parser_.IsEnded()) { + if (conn->is_server_ && !conn->hello_parser_.IsEnded()) { // Just accumulate data, everything will be pushed to BIO later - if (ss->hello_parser_.IsPaused()) { + if (conn->hello_parser_.IsPaused()) { bytes_written = 0; } else { // Copy incoming data to the internal buffer // (which has a size of the biggest possible TLS frame) - size_t available = sizeof(ss->hello_data_) - ss->hello_offset_; + size_t available = sizeof(conn->hello_data_) - conn->hello_offset_; size_t copied = len < available ? len : available; - memcpy(ss->hello_data_ + ss->hello_offset_, data, copied); - ss->hello_offset_ += copied; + memcpy(conn->hello_data_ + conn->hello_offset_, data, copied); + conn->hello_offset_ += copied; - ss->hello_parser_.Parse(ss->hello_data_, ss->hello_offset_); + conn->hello_parser_.Parse(conn->hello_data_, conn->hello_offset_); bytes_written = copied; } } else { - bytes_written = BIO_write(ss->bio_read_, data, len); - ss->HandleBIOError(ss->bio_read_, "BIO_write", bytes_written); - ss->SetShutdownFlags(); + bytes_written = BIO_write(conn->bio_read_, data, len); + conn->HandleBIOError(conn->bio_read_, "BIO_write", bytes_written); + conn->SetShutdownFlags(); } args.GetReturnValue().Set(bytes_written); @@ -1332,7 +1332,7 @@ void Connection::EncIn(const FunctionCallbackInfo& args) { void Connection::ClearOut(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); if (args.Length() < 3) { return ThrowTypeError("Takes 3 parameters"); @@ -1351,21 +1351,21 @@ void Connection::ClearOut(const FunctionCallbackInfo& args) { return ThrowError("off + len > buffer.length"); } - if (!SSL_is_init_finished(ss->ssl_)) { + if (!SSL_is_init_finished(conn->ssl_)) { int rv; - if (ss->is_server_) { - rv = SSL_accept(ss->ssl_); - ss->HandleSSLError("SSL_accept:ClearOut", - rv, - kZeroIsAnError, - kSyscallError); + if (conn->is_server_) { + rv = SSL_accept(conn->ssl_); + conn->HandleSSLError("SSL_accept:ClearOut", + rv, + kZeroIsAnError, + kSyscallError); } else { - rv = SSL_connect(ss->ssl_); - ss->HandleSSLError("SSL_connect:ClearOut", - rv, - kZeroIsAnError, - kSyscallError); + rv = SSL_connect(conn->ssl_); + conn->HandleSSLError("SSL_connect:ClearOut", + rv, + kZeroIsAnError, + kSyscallError); } if (rv < 0) { @@ -1373,12 +1373,12 @@ void Connection::ClearOut(const FunctionCallbackInfo& args) { } } - int bytes_read = SSL_read(ss->ssl_, buffer_data + off, len); - ss->HandleSSLError("SSL_read:ClearOut", - bytes_read, - kZeroIsNotAnError, - kSyscallError); - ss->SetShutdownFlags(); + int bytes_read = SSL_read(conn->ssl_, buffer_data + off, len); + conn->HandleSSLError("SSL_read:ClearOut", + bytes_read, + kZeroIsNotAnError, + kSyscallError); + conn->SetShutdownFlags(); args.GetReturnValue().Set(bytes_read); } @@ -1386,16 +1386,16 @@ void Connection::ClearOut(const FunctionCallbackInfo& args) { void Connection::ClearPending(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); - int bytes_pending = BIO_pending(ss->bio_read_); + Connection* conn = Connection::Unwrap(args); + int bytes_pending = BIO_pending(conn->bio_read_); args.GetReturnValue().Set(bytes_pending); } void Connection::EncPending(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); - int bytes_pending = BIO_pending(ss->bio_write_); + Connection* conn = Connection::Unwrap(args); + int bytes_pending = BIO_pending(conn->bio_write_); args.GetReturnValue().Set(bytes_pending); } @@ -1403,7 +1403,7 @@ void Connection::EncPending(const FunctionCallbackInfo& args) { void Connection::EncOut(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); if (args.Length() < 3) { return ThrowTypeError("Takes 3 parameters"); @@ -1422,10 +1422,10 @@ void Connection::EncOut(const FunctionCallbackInfo& args) { return ThrowError("off + len > buffer.length"); } - int bytes_read = BIO_read(ss->bio_write_, buffer_data + off, len); + int bytes_read = BIO_read(conn->bio_write_, buffer_data + off, len); - ss->HandleBIOError(ss->bio_write_, "BIO_read:EncOut", bytes_read); - ss->SetShutdownFlags(); + conn->HandleBIOError(conn->bio_write_, "BIO_read:EncOut", bytes_read); + conn->SetShutdownFlags(); args.GetReturnValue().Set(bytes_read); } @@ -1434,7 +1434,7 @@ void Connection::EncOut(const FunctionCallbackInfo& args) { void Connection::ClearIn(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); if (args.Length() < 3) { return ThrowTypeError("Takes 3 parameters"); @@ -1453,20 +1453,20 @@ void Connection::ClearIn(const FunctionCallbackInfo& args) { return ThrowError("off + len > buffer.length"); } - if (!SSL_is_init_finished(ss->ssl_)) { + if (!SSL_is_init_finished(conn->ssl_)) { int rv; - if (ss->is_server_) { - rv = SSL_accept(ss->ssl_); - ss->HandleSSLError("SSL_accept:ClearIn", - rv, - kZeroIsAnError, - kSyscallError); + if (conn->is_server_) { + rv = SSL_accept(conn->ssl_); + conn->HandleSSLError("SSL_accept:ClearIn", + rv, + kZeroIsAnError, + kSyscallError); } else { - rv = SSL_connect(ss->ssl_); - ss->HandleSSLError("SSL_connect:ClearIn", - rv, - kZeroIsAnError, - kSyscallError); + rv = SSL_connect(conn->ssl_); + conn->HandleSSLError("SSL_connect:ClearIn", + rv, + kZeroIsAnError, + kSyscallError); } if (rv < 0) { @@ -1474,13 +1474,13 @@ void Connection::ClearIn(const FunctionCallbackInfo& args) { } } - int bytes_written = SSL_write(ss->ssl_, buffer_data + off, len); + int bytes_written = SSL_write(conn->ssl_, buffer_data + off, len); - ss->HandleSSLError("SSL_write:ClearIn", - bytes_written, - len == 0 ? kZeroIsNotAnError : kZeroIsAnError, - kSyscallError); - ss->SetShutdownFlags(); + conn->HandleSSLError("SSL_write:ClearIn", + bytes_written, + len == 0 ? kZeroIsNotAnError : kZeroIsAnError, + kSyscallError); + conn->SetShutdownFlags(); args.GetReturnValue().Set(bytes_written); } @@ -1489,11 +1489,11 @@ void Connection::ClearIn(const FunctionCallbackInfo& args) { void Connection::GetPeerCertificate(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); - if (ss->ssl_ == NULL) return; + if (conn->ssl_ == NULL) return; Local info = Object::New(); - X509* peer_cert = SSL_get_peer_certificate(ss->ssl_); + X509* peer_cert = SSL_get_peer_certificate(conn->ssl_); if (peer_cert != NULL) { BIO* bio = BIO_new(BIO_s_mem()); BUF_MEM* mem; @@ -1505,8 +1505,8 @@ void Connection::GetPeerCertificate(const FunctionCallbackInfo& args) { } (void) BIO_reset(bio); - if (X509_NAME_print_ex(bio, X509_get_issuer_name(peer_cert), 0, - X509_NAME_FLAGS) > 0) { + X509_NAME* issuer_name = X509_get_issuer_name(peer_cert); + if (X509_NAME_print_ex(bio, issuer_name, 0, X509_NAME_FLAGS) > 0) { BIO_get_mem_ptr(bio, &mem); info->Set(issuer_symbol, OneByteString(node_isolate, mem->data, mem->length)); @@ -1616,11 +1616,11 @@ void Connection::GetPeerCertificate(const FunctionCallbackInfo& args) { void Connection::GetSession(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); - if (ss->ssl_ == NULL) return; + if (conn->ssl_ == NULL) return; - SSL_SESSION* sess = SSL_get_session(ss->ssl_); + SSL_SESSION* sess = SSL_get_session(conn->ssl_); if (!sess) return; int slen = i2d_SSL_SESSION(sess, NULL); @@ -1637,7 +1637,7 @@ void Connection::GetSession(const FunctionCallbackInfo& args) { void Connection::SetSession(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); if (args.Length() < 1 || (!args[0]->IsString() && !Buffer::HasInstance(args[0]))) { @@ -1663,7 +1663,7 @@ void Connection::SetSession(const FunctionCallbackInfo& args) { if (!sess) return; - int r = SSL_set_session(ss->ssl_, sess); + int r = SSL_set_session(conn->ssl_, sess); SSL_SESSION_free(sess); if (!r) { @@ -1675,7 +1675,7 @@ void Connection::SetSession(const FunctionCallbackInfo& args) { void Connection::LoadSession(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); if (args.Length() >= 1 && Buffer::HasInstance(args[0])) { ssize_t slen = Buffer::Length(args[0].As()); @@ -1685,20 +1685,20 @@ void Connection::LoadSession(const FunctionCallbackInfo& args) { SSL_SESSION* sess = d2i_SSL_SESSION(NULL, &p, slen); // Setup next session and move hello to the BIO buffer - if (ss->next_sess_ != NULL) { - SSL_SESSION_free(ss->next_sess_); + if (conn->next_sess_ != NULL) { + SSL_SESSION_free(conn->next_sess_); } - ss->next_sess_ = sess; + conn->next_sess_ = sess; } - ss->hello_parser_.End(); + conn->hello_parser_.End(); } void Connection::IsSessionReused(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); - bool yes = ss->ssl_ && SSL_session_reused(ss->ssl_); + Connection* conn = Connection::Unwrap(args); + bool yes = conn->ssl_ && SSL_session_reused(conn->ssl_); args.GetReturnValue().Set(yes); } @@ -1706,19 +1706,22 @@ void Connection::IsSessionReused(const FunctionCallbackInfo& args) { void Connection::Start(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); int rv = 0; - if (!SSL_is_init_finished(ss->ssl_)) { - if (ss->is_server_) { - rv = SSL_accept(ss->ssl_); - ss->HandleSSLError("SSL_accept:Start", rv, kZeroIsAnError, kSyscallError); + if (!SSL_is_init_finished(conn->ssl_)) { + if (conn->is_server_) { + rv = SSL_accept(conn->ssl_); + conn->HandleSSLError("SSL_accept:Start", + rv, + kZeroIsAnError, + kSyscallError); } else { - rv = SSL_connect(ss->ssl_); - ss->HandleSSLError("SSL_connect:Start", - rv, - kZeroIsAnError, - kSyscallError); + rv = SSL_connect(conn->ssl_); + conn->HandleSSLError("SSL_connect:Start", + rv, + kZeroIsAnError, + kSyscallError); } } args.GetReturnValue().Set(rv); @@ -1728,31 +1731,32 @@ void Connection::Start(const FunctionCallbackInfo& args) { void Connection::Shutdown(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); - if (ss->ssl_ == NULL) { + if (conn->ssl_ == NULL) { return args.GetReturnValue().Set(false); } - int rv = SSL_shutdown(ss->ssl_); - ss->HandleSSLError("SSL_shutdown", rv, kZeroIsNotAnError, kIgnoreSyscall); - ss->SetShutdownFlags(); + int rv = SSL_shutdown(conn->ssl_); + conn->HandleSSLError("SSL_shutdown", rv, kZeroIsNotAnError, kIgnoreSyscall); + conn->SetShutdownFlags(); args.GetReturnValue().Set(rv); } void Connection::ReceivedShutdown(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); - bool yes = ss->ssl_ && SSL_get_shutdown(ss->ssl_) == SSL_RECEIVED_SHUTDOWN; + Connection* conn = Connection::Unwrap(args); + bool yes = + conn->ssl_ && SSL_get_shutdown(conn->ssl_) == SSL_RECEIVED_SHUTDOWN; args.GetReturnValue().Set(yes); } void Connection::IsInitFinished(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); - bool yes = ss->ssl_ && SSL_is_init_finished(ss->ssl_); + Connection* conn = Connection::Unwrap(args); + bool yes = conn->ssl_ && SSL_is_init_finished(conn->ssl_); args.GetReturnValue().Set(yes); } @@ -1760,14 +1764,14 @@ void Connection::IsInitFinished(const FunctionCallbackInfo& args) { void Connection::VerifyError(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); - if (ss->ssl_ == NULL) { + if (conn->ssl_ == NULL) { return args.GetReturnValue().SetNull(); } // XXX Do this check in JS land? - X509* peer_cert = SSL_get_peer_certificate(ss->ssl_); + X509* peer_cert = SSL_get_peer_certificate(conn->ssl_); if (peer_cert == NULL) { // We requested a certificate and they did not send us one. // Definitely an error. @@ -1779,7 +1783,7 @@ void Connection::VerifyError(const FunctionCallbackInfo& args) { } X509_free(peer_cert); - long x509_verify_error = SSL_get_verify_result(ss->ssl_); + long x509_verify_error = SSL_get_verify_result(conn->ssl_); Local s; @@ -1916,13 +1920,12 @@ void Connection::VerifyError(const FunctionCallbackInfo& args) { void Connection::GetCurrentCipher(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); - - OPENSSL_CONST SSL_CIPHER *c; + Connection* conn = Connection::Unwrap(args); + if (conn->ssl_ == NULL) return; - if (ss->ssl_ == NULL) return; - c = SSL_get_current_cipher(ss->ssl_); + OPENSSL_CONST SSL_CIPHER *c = SSL_get_current_cipher(conn->ssl_); if (c == NULL) return; + Local info = Object::New(); const char* cipher_name = SSL_CIPHER_get_name(c); info->Set(name_symbol, OneByteString(node_isolate, cipher_name)); @@ -1935,11 +1938,11 @@ void Connection::GetCurrentCipher(const FunctionCallbackInfo& args) { void Connection::Close(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); - if (ss->ssl_ != NULL) { - SSL_free(ss->ssl_); - ss->ssl_ = NULL; + if (conn->ssl_ != NULL) { + SSL_free(conn->ssl_); + conn->ssl_ = NULL; } } @@ -1948,13 +1951,13 @@ void Connection::Close(const FunctionCallbackInfo& args) { void Connection::GetNegotiatedProto(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); - if (ss->is_server_) { + if (conn->is_server_) { const unsigned char* npn_proto; unsigned int npn_proto_len; - SSL_get0_next_proto_negotiated(ss->ssl_, &npn_proto, &npn_proto_len); + SSL_get0_next_proto_negotiated(conn->ssl_, &npn_proto, &npn_proto_len); if (!npn_proto) { return args.GetReturnValue().Set(false); @@ -1963,7 +1966,7 @@ void Connection::GetNegotiatedProto(const FunctionCallbackInfo& args) { args.GetReturnValue().Set( OneByteString(node_isolate, npn_proto, npn_proto_len)); } else { - args.GetReturnValue().Set(ss->selectedNPNProto_); + args.GetReturnValue().Set(conn->selectedNPNProto_); } } @@ -1971,13 +1974,13 @@ void Connection::GetNegotiatedProto(const FunctionCallbackInfo& args) { void Connection::SetNPNProtocols(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); if (args.Length() < 1 || !Buffer::HasInstance(args[0])) { return ThrowError("Must give a Buffer as first argument"); } - ss->npnProtos_.Reset(node_isolate, args[0].As()); + conn->npnProtos_.Reset(node_isolate, args[0].As()); } #endif @@ -1986,10 +1989,10 @@ void Connection::SetNPNProtocols(const FunctionCallbackInfo& args) { void Connection::GetServername(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); - if (ss->is_server_ && !ss->servername_.IsEmpty()) { - args.GetReturnValue().Set(ss->servername_); + if (conn->is_server_ && !conn->servername_.IsEmpty()) { + args.GetReturnValue().Set(conn->servername_); } else { args.GetReturnValue().Set(false); } @@ -1999,7 +2002,7 @@ void Connection::GetServername(const FunctionCallbackInfo& args) { void Connection::SetSNICallback(const FunctionCallbackInfo& args) { HandleScope scope(node_isolate); - Connection *ss = Connection::Unwrap(args); + Connection* conn = Connection::Unwrap(args); if (args.Length() < 1 || !args[0]->IsFunction()) { return ThrowError("Must give a Function as first argument"); @@ -2007,7 +2010,7 @@ void Connection::SetSNICallback(const FunctionCallbackInfo& args) { Local obj = Object::New(); obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "onselect"), args[0]); - ss->sniObject_.Reset(node_isolate, obj); + conn->sniObject_.Reset(node_isolate, obj); } #endif diff --git a/src/node_crypto.h b/src/node_crypto.h index d695994..3ccd392 100644 --- a/src/node_crypto.h +++ b/src/node_crypto.h @@ -202,9 +202,9 @@ class Connection : ObjectWrap { void SetShutdownFlags(); static Connection* Unwrap(const v8::FunctionCallbackInfo& args) { - Connection* ss = ObjectWrap::Unwrap(args.This()); - ss->ClearError(); - return ss; + Connection* conn = ObjectWrap::Unwrap(args.This()); + conn->ClearError(); + return conn; } Connection() : ObjectWrap(), hello_offset_(0) { -- 2.7.4