// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

#ifndef SRC_NODE_CRYPTO_H_
#define SRC_NODE_CRYPTO_H_

#include 

#include 
#include 

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#ifdef OPENSSL_NPN_NEGOTIATED
#include 
#endif

#define EVP_F_EVP_DECRYPTFINAL 101


namespace node {
namespace crypto {

static X509_STORE* root_cert_store;

class SecureContext : ObjectWrap {
 public:
  static void Initialize(v8::Handle target);

  SSL_CTX *ctx_;
  // TODO: ca_store_ should probably be removed, it's not used anywhere.
  X509_STORE *ca_store_;

 protected:
  static v8::Handle New(const v8::Arguments& args);
  static v8::Handle Init(const v8::Arguments& args);
  static v8::Handle SetKey(const v8::Arguments& args);
  static v8::Handle SetCert(const v8::Arguments& args);
  static v8::Handle AddCACert(const v8::Arguments& args);
  static v8::Handle AddCRL(const v8::Arguments& args);
  static v8::Handle AddRootCerts(const v8::Arguments& args);
  static v8::Handle SetCiphers(const v8::Arguments& args);
  static v8::Handle SetOptions(const v8::Arguments& args);
  static v8::Handle SetSessionIdContext(const v8::Arguments& args);
  static v8::Handle Close(const v8::Arguments& args);

  SecureContext() : ObjectWrap() {
    ctx_ = NULL;
    ca_store_ = NULL;
  }

  void FreeCTXMem() {
    if (ctx_) {
      if (ctx_->cert_store == root_cert_store) {
        // SSL_CTX_free() will attempt to free the cert_store as well.
        // Since we want our root_cert_store to stay around forever
        // we just clear the field. Hopefully OpenSSL will not modify this
        // struct in future versions.
        ctx_->cert_store = NULL;
      }
      SSL_CTX_free(ctx_);
      ctx_ = NULL;
      ca_store_ = NULL;
    } else {
      assert(ca_store_ == NULL);
    }
  }

  ~SecureContext() {
    FreeCTXMem();
  }

 private:
};

class Connection : ObjectWrap {
 public:
  static void Initialize(v8::Handle target);

#ifdef OPENSSL_NPN_NEGOTIATED
  v8::Persistent npnProtos_;
  v8::Persistent selectedNPNProto_;
#endif

#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
  v8::Persistent sniCallback_;
  v8::Persistent sniContext_;
  v8::Persistent servername_;
#endif

 protected:
  static v8::Handle New(const v8::Arguments& args);
  static v8::Handle EncIn(const v8::Arguments& args);
  static v8::Handle ClearOut(const v8::Arguments& args);
  static v8::Handle ClearPending(const v8::Arguments& args);
  static v8::Handle EncPending(const v8::Arguments& args);
  static v8::Handle EncOut(const v8::Arguments& args);
  static v8::Handle ClearIn(const v8::Arguments& args);
  static v8::Handle GetPeerCertificate(const v8::Arguments& args);
  static v8::Handle GetSession(const v8::Arguments& args);
  static v8::Handle SetSession(const v8::Arguments& args);
  static v8::Handle IsSessionReused(const v8::Arguments& args);
  static v8::Handle IsInitFinished(const v8::Arguments& args);
  static v8::Handle VerifyError(const v8::Arguments& args);
  static v8::Handle GetCurrentCipher(const v8::Arguments& args);
  static v8::Handle Shutdown(const v8::Arguments& args);
  static v8::Handle ReceivedShutdown(const v8::Arguments& args);
  static v8::Handle Start(const v8::Arguments& args);
  static v8::Handle Close(const v8::Arguments& args);

#ifdef OPENSSL_NPN_NEGOTIATED
  // NPN
  static v8::Handle GetNegotiatedProto(const v8::Arguments& args);
  static v8::Handle SetNPNProtocols(const v8::Arguments& args);
  static int AdvertiseNextProtoCallback_(SSL *s,
                                         const unsigned char **data,
                                         unsigned int *len,
                                         void *arg);
  static int SelectNextProtoCallback_(SSL *s,
                                      unsigned char **out, unsigned char *outlen,
                                      const unsigned char* in,
                                      unsigned int inlen, void *arg);
#endif

#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
  // SNI
  static v8::Handle GetServername(const v8::Arguments& args);
  static v8::Handle SetSNICallback(const v8::Arguments& args);
  static int SelectSNIContextCallback_(SSL *s, int *ad, void* arg);
#endif

  int HandleBIOError(BIO *bio, const char* func, int rv);
  int HandleSSLError(const char* func, int rv);

  void ClearError();
  void SetShutdownFlags();

  static Connection* Unwrap(const v8::Arguments& args) {
    Connection* ss = ObjectWrap::Unwrap(args.Holder());
    ss->ClearError();
    return ss;
  }

  Connection() : ObjectWrap() {
    bio_read_ = bio_write_ = NULL;
    ssl_ = NULL;
  }

  ~Connection() {
    if (ssl_ != NULL) {
      SSL_free(ssl_);
      ssl_ = NULL;
    }

#ifdef OPENSSL_NPN_NEGOTIATED
    if (!npnProtos_.IsEmpty()) npnProtos_.Dispose();
    if (!selectedNPNProto_.IsEmpty()) selectedNPNProto_.Dispose();
#endif

#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
   if (!sniCallback_.IsEmpty()) sniCallback_.Dispose();
   if (!sniContext_.IsEmpty()) sniContext_.Dispose();
   if (!servername_.IsEmpty()) servername_.Dispose();
#endif
  }

 private:
  static void SSLInfoCallback(const SSL *ssl, int where, int ret);

  BIO *bio_read_;
  BIO *bio_write_;
  SSL *ssl_;

  bool is_server_; /* coverity[member_decl] */
};

void InitCrypto(v8::Handle target);

}  // namespace crypto
}  // namespace node

#endif  // SRC_NODE_CRYPTO_H_