Where Online Learning is simpler!

The C and C++ Include Header Files

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

     1	#ifndef SRC_CRYPTO_CRYPTO_RANDOM_H_
     2	#define SRC_CRYPTO_CRYPTO_RANDOM_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 "node_internals.h"
    11	#include "v8.h"
    12	
    13	namespace node {
    14	namespace crypto {
    15	struct RandomBytesConfig final : public MemoryRetainer {
    16	  unsigned char* buffer;
    17	  size_t size;
    18	  SET_NO_MEMORY_INFO()
    19	  SET_MEMORY_INFO_NAME(RandomBytesConfig)
    20	  SET_SELF_SIZE(RandomBytesConfig)
    21	};
    22	
    23	struct RandomBytesTraits final {
    24	  using AdditionalParameters = RandomBytesConfig;
    25	  static constexpr const char* JobName = "RandomBytesJob";
    26	  static constexpr AsyncWrap::ProviderType Provider =
    27	      AsyncWrap::PROVIDER_RANDOMBYTESREQUEST;
    28	
    29	  static v8::Maybe<void> AdditionalConfig(
    30	      CryptoJobMode mode,
    31	      const v8::FunctionCallbackInfo<v8::Value>& args,
    32	      unsigned int offset,
    33	      RandomBytesConfig* params);
    34	
    35	  static bool DeriveBits(Environment* env,
    36	                         const RandomBytesConfig& params,
    37	                         ByteSource* out_,
    38	                         CryptoJobMode mode);
    39	
    40	  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
    41	                                                const RandomBytesConfig& params,
    42	                                                ByteSource* unused);
    43	};
    44	
    45	using RandomBytesJob = DeriveBitsJob<RandomBytesTraits>;
    46	
    47	struct RandomPrimeConfig final : public MemoryRetainer {
    48	  ncrypto::BignumPointer prime;
    49	  ncrypto::BignumPointer rem;
    50	  ncrypto::BignumPointer add;
    51	  int bits;
    52	  bool safe;
    53	  void MemoryInfo(MemoryTracker* tracker) const override;
    54	  SET_MEMORY_INFO_NAME(RandomPrimeConfig)
    55	  SET_SELF_SIZE(RandomPrimeConfig)
    56	};
    57	
    58	struct RandomPrimeTraits final {
    59	  using AdditionalParameters = RandomPrimeConfig;
    60	  static constexpr const char* JobName = "RandomPrimeJob";
    61	  static constexpr AsyncWrap::ProviderType Provider =
    62	      AsyncWrap::PROVIDER_RANDOMPRIMEREQUEST;
    63	
    64	  static v8::Maybe<void> AdditionalConfig(
    65	      CryptoJobMode mode,
    66	      const v8::FunctionCallbackInfo<v8::Value>& args,
    67	      unsigned int offset,
    68	      RandomPrimeConfig* params);
    69	
    70	  static bool DeriveBits(Environment* env,
    71	                         const RandomPrimeConfig& params,
    72	                         ByteSource* out_,
    73	                         CryptoJobMode mode);
    74	
    75	  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
    76	                                                const RandomPrimeConfig& params,
    77	                                                ByteSource* unused);
    78	};
    79	
    80	using RandomPrimeJob = DeriveBitsJob<RandomPrimeTraits>;
    81	
    82	struct CheckPrimeConfig final : public MemoryRetainer {
    83	  ncrypto::BignumPointer candidate;
    84	  int checks = 1;
    85	
    86	  void MemoryInfo(MemoryTracker* tracker) const override;
    87	  SET_MEMORY_INFO_NAME(CheckPrimeConfig)
    88	  SET_SELF_SIZE(CheckPrimeConfig)
    89	};
    90	
    91	struct CheckPrimeTraits final {
    92	  using AdditionalParameters = CheckPrimeConfig;
    93	  static constexpr const char* JobName = "CheckPrimeJob";
    94	
    95	  static constexpr AsyncWrap::ProviderType Provider =
    96	      AsyncWrap::PROVIDER_CHECKPRIMEREQUEST;
    97	
    98	  static v8::Maybe<void> AdditionalConfig(
    99	      CryptoJobMode mode,
   100	      const v8::FunctionCallbackInfo<v8::Value>& args,
   101	      unsigned int offset,
   102	      CheckPrimeConfig* params);
   103	
   104	  static bool DeriveBits(Environment* env,
   105	                         const CheckPrimeConfig& params,
   106	                         ByteSource* out,
   107	                         CryptoJobMode mode);
   108	
   109	  static v8::MaybeLocal<v8::Value> EncodeOutput(Environment* env,
   110	                                                const CheckPrimeConfig& params,
   111	                                                ByteSource* out);
   112	};
   113	
   114	using CheckPrimeJob = DeriveBitsJob<CheckPrimeTraits>;
   115	
   116	namespace Random {
   117	void Initialize(Environment* env, v8::Local<v8::Object> target);
   118	void RegisterExternalReferences(ExternalReferenceRegistry* registry);
   119	}  // namespace Random
   120	}  // namespace crypto
   121	}  // namespace node
   122	
   123	#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
   124	#endif  // SRC_CRYPTO_CRYPTO_RANDOM_H_