Where Online Learning is simpler!

The C and C++ Include Header Files

cat -n /usr/include/nodejs/src/node_sockaddr-inl.h

     1	#ifndef SRC_NODE_SOCKADDR_INL_H_
     2	#define SRC_NODE_SOCKADDR_INL_H_
     3	
     4	#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
     5	
     6	#include "node.h"
     7	#include "env-inl.h"
     8	#include "node_internals.h"
     9	#include "node_sockaddr.h"
    10	#include "util-inl.h"
    11	#include "memory_tracker-inl.h"
    12	
    13	#include <string>
    14	
    15	namespace node {
    16	
    17	static constexpr uint32_t kLabelMask = 0xFFFFF;
    18	
    19	inline void hash_combine(size_t* seed) { }
    20	
    21	template <typename T, typename... Args>
    22	inline void hash_combine(size_t* seed, const T& value, Args... rest) {
    23	    *seed ^= std::hash<T>{}(value) + 0x9e3779b9 + (*seed << 6) + (*seed >> 2);
    24	    hash_combine(seed, rest...);
    25	}
    26	
    27	bool SocketAddress::is_numeric_host(const char* hostname) {
    28	  return is_numeric_host(hostname, AF_INET) ||
    29	         is_numeric_host(hostname, AF_INET6);
    30	}
    31	
    32	bool SocketAddress::is_numeric_host(const char* hostname, int family) {
    33	  in6_addr dst;
    34	  return inet_pton(family, hostname, &dst) == 1;
    35	}
    36	
    37	int SocketAddress::GetPort(const sockaddr* addr) {
    38	  CHECK(addr->sa_family == AF_INET || addr->sa_family == AF_INET6);
    39	  return ntohs(addr->sa_family == AF_INET ?
    40	      reinterpret_cast<const sockaddr_in*>(addr)->sin_port :
    41	      reinterpret_cast<const sockaddr_in6*>(addr)->sin6_port);
    42	}
    43	
    44	int SocketAddress::GetPort(const sockaddr_storage* addr) {
    45	  return GetPort(reinterpret_cast<const sockaddr*>(addr));
    46	}
    47	
    48	std::string SocketAddress::GetAddress(const sockaddr* addr) {
    49	  CHECK(addr->sa_family == AF_INET || addr->sa_family == AF_INET6);
    50	  char host[INET6_ADDRSTRLEN];
    51	  const void* src = addr->sa_family == AF_INET ?
    52	      static_cast<const void*>(
    53	          &(reinterpret_cast<const sockaddr_in*>(addr)->sin_addr)) :
    54	      static_cast<const void*>(
    55	          &(reinterpret_cast<const sockaddr_in6*>(addr)->sin6_addr));
    56	  uv_inet_ntop(addr->sa_family, src, host, INET6_ADDRSTRLEN);
    57	  return std::string(host);
    58	}
    59	
    60	std::string SocketAddress::GetAddress(const sockaddr_storage* addr) {
    61	  return GetAddress(reinterpret_cast<const sockaddr*>(addr));
    62	}
    63	
    64	size_t SocketAddress::GetLength(const sockaddr* addr) {
    65	  return addr->sa_family == AF_INET ?
    66	      sizeof(sockaddr_in) : sizeof(sockaddr_in6);
    67	}
    68	
    69	size_t SocketAddress::GetLength(const sockaddr_storage* addr) {
    70	  return GetLength(reinterpret_cast<const sockaddr*>(addr));
    71	}
    72	
    73	SocketAddress::SocketAddress(const sockaddr* addr) {
    74	  memcpy(&address_, addr, GetLength(addr));
    75	}
    76	
    77	SocketAddress::SocketAddress(const SocketAddress& addr) {
    78	  memcpy(&address_, &addr.address_, addr.length());
    79	}
    80	
    81	SocketAddress& SocketAddress::operator=(const sockaddr* addr) {
    82	  if (reinterpret_cast<const sockaddr*>(&address_) != addr) {
    83	    memcpy(&address_, addr, GetLength(addr));
    84	  }
    85	  return *this;
    86	}
    87	
    88	SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
    89	  if (this != &addr) {
    90	    memcpy(&address_, &addr.address_, addr.length());
    91	  }
    92	  return *this;
    93	}
    94	
    95	const sockaddr& SocketAddress::operator*() const {
    96	  return *data();
    97	}
    98	
    99	const sockaddr* SocketAddress::operator->() const {
   100	  return data();
   101	}
   102	
   103	size_t SocketAddress::length() const {
   104	  return GetLength(&address_);
   105	}
   106	
   107	const sockaddr* SocketAddress::data() const {
   108	  return reinterpret_cast<const sockaddr*>(&address_);
   109	}
   110	
   111	const uint8_t* SocketAddress::raw() const {
   112	  return reinterpret_cast<const uint8_t*>(&address_);
   113	}
   114	
   115	sockaddr* SocketAddress::storage() {
   116	  return reinterpret_cast<sockaddr*>(&address_);
   117	}
   118	
   119	int SocketAddress::family() const {
   120	  return address_.ss_family;
   121	}
   122	
   123	std::string SocketAddress::address() const {
   124	  return GetAddress(&address_);
   125	}
   126	
   127	int SocketAddress::port() const {
   128	  return GetPort(&address_);
   129	}
   130	
   131	uint32_t SocketAddress::flow_label() const {
   132	  if (family() != AF_INET6)
   133	    return 0;
   134	  const sockaddr_in6* in = reinterpret_cast<const sockaddr_in6*>(data());
   135	  return in->sin6_flowinfo;
   136	}
   137	
   138	void SocketAddress::set_flow_label(uint32_t label) {
   139	  if (family() != AF_INET6)
   140	    return;
   141	  CHECK_LE(label, kLabelMask);
   142	  sockaddr_in6* in = reinterpret_cast<sockaddr_in6*>(&address_);
   143	  in->sin6_flowinfo = label;
   144	}
   145	
   146	std::string SocketAddress::ToString() const {
   147	  if (family() != AF_INET && family() != AF_INET6) return "";
   148	  return (family() == AF_INET6 ?
   149	              std::string("[") + address() + "]:" :
   150	              address() + ":") +
   151	      std::to_string(port());
   152	}
   153	
   154	void SocketAddress::Update(uint8_t* data, size_t len) {
   155	  CHECK_LE(len, sizeof(address_));
   156	  memcpy(&address_, data, len);
   157	}
   158	
   159	void SocketAddress::Update(const sockaddr* data, size_t len) {
   160	  CHECK_LE(len, sizeof(address_));
   161	  memcpy(&address_, data, len);
   162	}
   163	
   164	v8::MaybeLocal<v8::Object> SocketAddress::ToJS(
   165	    Environment* env,
   166	    v8::Local<v8::Object> info) const {
   167	  return AddressToJS(env, data(), info);
   168	}
   169	
   170	bool SocketAddress::operator==(const SocketAddress& other) const {
   171	  if (family() != other.family()) return false;
   172	  return memcmp(raw(), other.raw(), length()) == 0;
   173	}
   174	
   175	bool SocketAddress::operator!=(const SocketAddress& other) const {
   176	  return !(*this == other);
   177	}
   178	
   179	std::partial_ordering SocketAddress::operator<=>(
   180	    const SocketAddress& other) const {
   181	  return compare(other);
   182	}
   183	
   184	template <typename T>
   185	SocketAddressLRU<T>::SocketAddressLRU(
   186	    size_t max_size)
   187	    : max_size_(max_size) {}
   188	
   189	template <typename T>
   190	typename T::Type* SocketAddressLRU<T>::Peek(
   191	    const SocketAddress& address) const {
   192	  auto it = map_.find(address);
   193	  return it == std::end(map_) ? nullptr : &it->second->second;
   194	}
   195	
   196	template <typename T>
   197	void SocketAddressLRU<T>::CheckExpired() {
   198	  auto it = list_.rbegin();
   199	  while (it != list_.rend()) {
   200	    if (T::CheckExpired(it->first, it->second)) {
   201	      map_.erase(it->first);
   202	      list_.pop_back();
   203	      it = list_.rbegin();
   204	      continue;
   205	    } else {
   206	      break;
   207	    }
   208	  }
   209	}
   210	
   211	template <typename T>
   212	void SocketAddressLRU<T>::MemoryInfo(MemoryTracker* tracker) const {
   213	  tracker->TrackFieldWithSize("list", size() * sizeof(Pair));
   214	}
   215	
   216	// If an item already exists for the given address, bump up it's
   217	// position in the LRU list and return it. If the item does not
   218	// exist, create it. If an item is created, check the size of the
   219	// cache and adjust if necessary. Whether the item exists or not,
   220	// purge expired items.
   221	template <typename T>
   222	typename T::Type* SocketAddressLRU<T>::Upsert(
   223	    const SocketAddress& address) {
   224	
   225	  auto on_exit = OnScopeLeave([&]() { CheckExpired(); });
   226	
   227	  auto it = map_.find(address);
   228	  if (it != std::end(map_)) {
   229	    list_.splice(list_.begin(), list_, it->second);
   230	    T::Touch(it->first, &it->second->second);
   231	    return &it->second->second;
   232	  }
   233	
   234	  list_.push_front(Pair(address, { }));
   235	  map_[address] = list_.begin();
   236	  T::Touch(list_.begin()->first, &list_.begin()->second);
   237	
   238	  // Drop the last item in the list if we are
   239	  // over the size limit...
   240	  if (map_.size() > max_size_) {
   241	    auto last = list_.end();
   242	    map_.erase((--last)->first);
   243	    list_.pop_back();
   244	  }
   245	
   246	  return &map_[address]->second;
   247	}
   248	
   249	v8::MaybeLocal<v8::Value> SocketAddressBlockList::Rule::ToV8String(
   250	    Environment* env) {
   251	  std::string str = ToString();
   252	  return ToV8Value(env->context(), str);
   253	}
   254	}  // namespace node
   255	
   256	#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
   257	#endif  // SRC_NODE_SOCKADDR_INL_H_