Where Online Learning is simpler!

The C and C++ Include Header Files

cat -n /usr/include/nodejs/src/crypto/crypto_x509.h

     1	#ifndef SRC_CRYPTO_CRYPTO_X509_H_
     2	#define SRC_CRYPTO_CRYPTO_X509_H_
     3	
     4	#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
     5	
     6	#include "base_object.h"
     7	#include "crypto/crypto_util.h"
     8	#include "env.h"
     9	#include "memory_tracker.h"
    10	#include "ncrypto.h"
    11	#include "node_worker.h"
    12	#include "v8.h"
    13	
    14	namespace node {
    15	namespace crypto {
    16	
    17	// The ManagedX509 class is essentially a smart pointer for
    18	// X509 objects that allows an X509Certificate instance to
    19	// be cloned at the JS level while pointing at the same
    20	// underlying X509 instance.
    21	class ManagedX509 final : public MemoryRetainer {
    22	 public:
    23	  ManagedX509() = default;
    24	  explicit ManagedX509(ncrypto::X509Pointer&& cert);
    25	  ManagedX509(const ManagedX509& that);
    26	  ManagedX509& operator=(const ManagedX509& that);
    27	
    28	  operator bool() const { return !!cert_; }
    29	  X509* get() const { return cert_.get(); }
    30	  ncrypto::X509View view() const { return cert_; }
    31	  operator ncrypto::X509View() const { return cert_; }
    32	
    33	  void MemoryInfo(MemoryTracker* tracker) const override;
    34	  SET_MEMORY_INFO_NAME(ManagedX509)
    35	  SET_SELF_SIZE(ManagedX509)
    36	
    37	 private:
    38	  ncrypto::X509Pointer cert_;
    39	};
    40	
    41	class X509Certificate final : public BaseObject {
    42	 public:
    43	  enum class GetPeerCertificateFlag {
    44	    NONE,
    45	    SERVER
    46	  };
    47	
    48	  static void Initialize(Environment* env, v8::Local<v8::Object> target);
    49	  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
    50	  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
    51	      Environment* env);
    52	  static bool HasInstance(Environment* env, v8::Local<v8::Object> object);
    53	
    54	  static v8::MaybeLocal<v8::Object> New(
    55	      Environment* env,
    56	      ncrypto::X509Pointer cert,
    57	      STACK_OF(X509) * issuer_chain = nullptr);
    58	
    59	  static v8::MaybeLocal<v8::Object> New(
    60	      Environment* env,
    61	      std::shared_ptr<ManagedX509> cert,
    62	      STACK_OF(X509)* issuer_chain = nullptr);
    63	
    64	  static v8::MaybeLocal<v8::Object> GetCert(Environment* env,
    65	                                            const ncrypto::SSLPointer& ssl);
    66	
    67	  static v8::MaybeLocal<v8::Object> GetPeerCert(Environment* env,
    68	                                                const ncrypto::SSLPointer& ssl,
    69	                                                GetPeerCertificateFlag flag);
    70	
    71	  static v8::Local<v8::Object> Wrap(Environment* env,
    72	                                    v8::Local<v8::Object> object,
    73	                                    ncrypto::X509Pointer cert);
    74	
    75	  inline BaseObjectPtr<X509Certificate> getIssuerCert() const {
    76	    return issuer_cert_;
    77	  }
    78	
    79	  inline ncrypto::X509View view() const { return *cert_; }
    80	  X509* get() { return cert_->get(); }
    81	
    82	  v8::MaybeLocal<v8::Value> toObject(Environment* env);
    83	  static v8::MaybeLocal<v8::Value> toObject(Environment* env,
    84	                                            const ncrypto::X509View& cert);
    85	
    86	  void MemoryInfo(MemoryTracker* tracker) const override;
    87	  SET_MEMORY_INFO_NAME(X509Certificate)
    88	  SET_SELF_SIZE(X509Certificate)
    89	
    90	  class X509CertificateTransferData : public worker::TransferData {
    91	   public:
    92	    explicit X509CertificateTransferData(
    93	        const std::shared_ptr<ManagedX509>& data)
    94	        : data_(data) {}
    95	
    96	    BaseObjectPtr<BaseObject> Deserialize(
    97	        Environment* env,
    98	        v8::Local<v8::Context> context,
    99	        std::unique_ptr<worker::TransferData> self) override;
   100	
   101	    SET_MEMORY_INFO_NAME(X509CertificateTransferData)
   102	    SET_SELF_SIZE(X509CertificateTransferData)
   103	    SET_NO_MEMORY_INFO()
   104	
   105	   private:
   106	    std::shared_ptr<ManagedX509> data_;
   107	  };
   108	
   109	  BaseObject::TransferMode GetTransferMode() const override;
   110	  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
   111	
   112	 private:
   113	  X509Certificate(Environment* env,
   114	                  v8::Local<v8::Object> object,
   115	                  std::shared_ptr<ManagedX509> cert,
   116	                  v8::Local<v8::Object> issuer_chain = v8::Local<v8::Object>());
   117	
   118	  std::shared_ptr<ManagedX509> cert_;
   119	  BaseObjectPtr<X509Certificate> issuer_cert_;
   120	};
   121	
   122	inline X509Certificate::GetPeerCertificateFlag operator|(
   123	    X509Certificate::GetPeerCertificateFlag lhs,
   124	    X509Certificate::GetPeerCertificateFlag rhs) {
   125	  return static_cast<X509Certificate::GetPeerCertificateFlag>(
   126	      static_cast<int>(lhs) | static_cast<int>(rhs));
   127	}
   128	
   129	inline X509Certificate::GetPeerCertificateFlag operator&(
   130	    X509Certificate::GetPeerCertificateFlag lhs,
   131	    X509Certificate::GetPeerCertificateFlag rhs) {
   132	  return static_cast<X509Certificate::GetPeerCertificateFlag>(
   133	      static_cast<int>(lhs) & static_cast<int>(rhs));
   134	}
   135	
   136	}  // namespace crypto
   137	}  // namespace node
   138	
   139	#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
   140	#endif  // SRC_CRYPTO_CRYPTO_X509_H_