#ifndef SRC_NODE_CRYPTO_H_
#define SRC_NODE_CRYPTO_H_

#include 
#include 
#include 

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

#define EVP_F_EVP_DECRYPTFINAL 101


namespace node {
namespace crypto {

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

  SSL_CTX *ctx_;
  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 Close(const v8::Arguments& args);

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

  ~SecureContext() {
    if (ctx_) {
      SSL_CTX_free(ctx_);
      ctx_ = NULL;
      ca_store_ = NULL;
    } else {
      assert(ca_store_ == NULL);
    }
  }

 private:
};

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

 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 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);

  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;
    }
  }

 private:
  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_