grpc 1.30.0 → 1.46.3

data/src/core/lib/iomgr/resource_quota.h

@@ -1,177 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H
-#define GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/grpc.h>
-
-#include "src/core/lib/debug/trace.h"
-#include "src/core/lib/iomgr/closure.h"
-
-/** \file Tracks resource usage against a pool.
-
-    The current implementation tracks only memory usage, but in the future
-    this may be extended to (for example) threads and file descriptors.
-
-    A grpc_resource_quota represents the pooled resources, and
-    grpc_resource_user instances attach to the quota and consume those
-    resources. They also offer a vector for reclamation: if we become
-    resource constrained, grpc_resource_user instances are asked (in turn) to
-    free up whatever they can so that the system as a whole can make progress.
-
-    There are three kinds of reclamation that take place, in order of increasing
-    invasiveness:
-    - an internal reclamation, where cached resource at the resource user level
-      is returned to the quota
-    - a benign reclamation phase, whereby resources that are in use but are not
-      helping anything make progress are reclaimed
-    - a destructive reclamation, whereby resources that are helping something
-      make progress may be enacted so that at least one part of the system can
-      complete.
-
-    Only one reclamation will be outstanding for a given quota at a given time.
-    On each reclamation attempt, the kinds of reclamation are tried in order of
-    increasing invasiveness, stopping at the first one that succeeds. Thus, on a
-    given reclamation attempt, if internal and benign reclamation both fail, it
-    will wind up doing a destructive reclamation. However, the next reclamation
-    attempt may then be able to get what it needs via internal or benign
-    reclamation, due to resources that may have been freed up by the destructive
-    reclamation in the previous attempt.
-
-    Future work will be to expose the current resource pressure so that back
-    pressure can be applied to avoid reclamation phases starting.
-
-    Resource users own references to resource quotas, and resource quotas
-    maintain lists of users (which users arrange to leave before they are
-    destroyed) */
-
-extern grpc_core::TraceFlag grpc_resource_quota_trace;
-
-// TODO(juanlishen): This is a hack. We need to do real accounting instead of
-// hard coding.
-constexpr size_t GRPC_RESOURCE_QUOTA_CALL_SIZE = 15 * 1024;
-constexpr size_t GRPC_RESOURCE_QUOTA_CHANNEL_SIZE = 50 * 1024;
-
-grpc_resource_quota* grpc_resource_quota_ref_internal(
-    grpc_resource_quota* resource_quota);
-void grpc_resource_quota_unref_internal(grpc_resource_quota* resource_quota);
-grpc_resource_quota* grpc_resource_quota_from_channel_args(
-    const grpc_channel_args* channel_args, bool create = true);
-
-/* Return a number indicating current memory pressure:
-   0.0 ==> no memory usage
-   1.0 ==> maximum memory usage */
-double grpc_resource_quota_get_memory_pressure(
-    grpc_resource_quota* resource_quota);
-
-size_t grpc_resource_quota_peek_size(grpc_resource_quota* resource_quota);
-
-typedef struct grpc_resource_user grpc_resource_user;
-
-grpc_resource_user* grpc_resource_user_create(
-    grpc_resource_quota* resource_quota, const char* name);
-
-/* Returns a borrowed reference to the underlying resource quota for this
-   resource user. */
-grpc_resource_quota* grpc_resource_user_quota(
-    grpc_resource_user* resource_user);
-
-void grpc_resource_user_ref(grpc_resource_user* resource_user);
-void grpc_resource_user_unref(grpc_resource_user* resource_user);
-void grpc_resource_user_shutdown(grpc_resource_user* resource_user);
-
-/* Attempts to get quota from the resource_user to create 'thread_count' number
- * of threads. Returns true if successful (i.e the caller is now free to create
- * 'thread_count' number of threads) or false if quota is not available */
-bool grpc_resource_user_allocate_threads(grpc_resource_user* resource_user,
-                                         int thread_count);
-/* Releases 'thread_count' worth of quota back to the resource user. The quota
- * should have been previously obtained successfully by calling
- * grpc_resource_user_allocate_threads().
- *
- * Note: There need not be an exact one-to-one correspondence between
- * grpc_resource_user_allocate_threads() and grpc_resource_user_free_threads()
- * calls. The only requirement is that the number of threads allocated should
- * all be eventually released */
-void grpc_resource_user_free_threads(grpc_resource_user* resource_user,
-                                     int thread_count);
-
-/* Allocates from the resource user 'size' worth of memory if this won't exceed
- * the resource quota's total size. Returns whether the allocation is done
- * successfully. If allocated successfully, the memory should be freed by the
- * caller eventually. */
-bool grpc_resource_user_safe_alloc(grpc_resource_user* resource_user,
-                                   size_t size);
-/* Allocates from the resource user 'size' worth of memory.
- * If optional_on_done is NULL, then allocate immediately. This may push the
- * quota over-limit, at which point reclamation will kick in. The caller is
- * always responsible to free the memory eventually.
- * Returns true if the allocation was successful. Otherwise, if optional_on_done
- * is non-NULL, it will be scheduled without error when the allocation has been
- * granted by the quota, and the caller is responsible to free the memory
- * eventually. Or it may be scheduled with an error, in which case the caller
- * fails to allocate the memory and shouldn't free the memory.
- */
-bool grpc_resource_user_alloc(grpc_resource_user* resource_user, size_t size,
-                              grpc_closure* optional_on_done)
-    GRPC_MUST_USE_RESULT;
-/* Release memory back to the quota */
-void grpc_resource_user_free(grpc_resource_user* resource_user, size_t size);
-/* Post a memory reclaimer to the resource user. Only one benign and one
-   destructive reclaimer can be posted at once. When executed, the reclaimer
-   MUST call grpc_resource_user_finish_reclamation before it completes, to
-   return control to the resource quota. */
-void grpc_resource_user_post_reclaimer(grpc_resource_user* resource_user,
-                                       bool destructive, grpc_closure* closure);
-/* Finish a reclamation step */
-void grpc_resource_user_finish_reclamation(grpc_resource_user* resource_user);
-
-/* Helper to allocate slices from a resource user */
-typedef struct grpc_resource_user_slice_allocator {
-  /* Closure for when a resource user allocation completes */
-  grpc_closure on_allocated;
-  /* Closure to call when slices have been allocated */
-  grpc_closure on_done;
-  /* Length of slices to allocate on the current request */
-  size_t length;
-  /* Number of slices to allocate on the current request */
-  size_t count;
-  /* Destination for slices to allocate on the current request */
-  grpc_slice_buffer* dest;
-  /* Parent resource user */
-  grpc_resource_user* resource_user;
-} grpc_resource_user_slice_allocator;
-
-/* Initialize a slice allocator.
-   When an allocation is completed, calls \a cb with arg \p. */
-void grpc_resource_user_slice_allocator_init(
-    grpc_resource_user_slice_allocator* slice_allocator,
-    grpc_resource_user* resource_user, grpc_iomgr_cb_func cb, void* p);
-
-/* Allocate \a count slices of length \a length into \a dest. Only one request
-   can be outstanding at a time.
-   Returns whether the slice was allocated inline in the function. If true,
-   the \a slice_allocator->on_allocated callback will not be called. */
-bool grpc_resource_user_alloc_slices(
-    grpc_resource_user_slice_allocator* slice_allocator, size_t length,
-    size_t count, grpc_slice_buffer* dest) GRPC_MUST_USE_RESULT;
-
-#endif /* GRPC_CORE_LIB_IOMGR_RESOURCE_QUOTA_H */

data/src/core/lib/iomgr/sockaddr_custom.h

@@ -1,54 +0,0 @@
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_IOMGR_SOCKADDR_CUSTOM_H
-#define GRPC_CORE_LIB_IOMGR_SOCKADDR_CUSTOM_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stddef.h>
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_UV
-
-#include <uv.h>
-
-// TODO(kpayson)  It would be nice to abstract this so we don't
-// depend on anything uv specific
-typedef struct sockaddr grpc_sockaddr;
-typedef struct sockaddr_in grpc_sockaddr_in;
-typedef struct in_addr grpc_in_addr;
-typedef struct sockaddr_in6 grpc_sockaddr_in6;
-typedef struct in6_addr grpc_in6_addr;
-
-#define GRPC_INET_ADDRSTRLEN INET_ADDRSTRLEN
-#define GRPC_INET6_ADDRSTRLEN INET6_ADDRSTRLEN
-
-#define GRPC_SOCK_STREAM SOCK_STREAM
-#define GRPC_SOCK_DGRAM SOCK_DGRAM
-
-#define GRPC_AF_UNSPEC AF_UNSPEC
-#define GRPC_AF_UNIX AF_UNIX
-#define GRPC_AF_INET AF_INET
-#define GRPC_AF_INET6 AF_INET6
-
-#define GRPC_AI_PASSIVE AI_PASSIVE
-
-#endif  // GRPC_UV
-
-#endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_CUSTOM_H */

data/src/core/lib/iomgr/sockaddr_utils.cc

@@ -1,293 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/sockaddr_utils.h"
-
-#include <errno.h>
-#include <inttypes.h>
-#include <string.h>
-
-#include "absl/strings/str_format.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/socket_utils.h"
-#include "src/core/lib/iomgr/unix_sockets_posix.h"
-
-static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0,    0,
-                                          0, 0, 0, 0, 0xff, 0xff};
-
-int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr,
-                              grpc_resolved_address* resolved_addr4_out) {
-  GPR_ASSERT(resolved_addr != resolved_addr4_out);
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
-  grpc_sockaddr_in* addr4_out =
-      resolved_addr4_out == nullptr
-          ? nullptr
-          : reinterpret_cast<grpc_sockaddr_in*>(resolved_addr4_out->addr);
-  if (addr->sa_family == GRPC_AF_INET6) {
-    const grpc_sockaddr_in6* addr6 =
-        reinterpret_cast<const grpc_sockaddr_in6*>(addr);
-    if (memcmp(addr6->sin6_addr.s6_addr, kV4MappedPrefix,
-               sizeof(kV4MappedPrefix)) == 0) {
-      if (resolved_addr4_out != nullptr) {
-        /* Normalize ::ffff:0.0.0.0/96 to IPv4. */
-        memset(resolved_addr4_out, 0, sizeof(*resolved_addr4_out));
-        addr4_out->sin_family = GRPC_AF_INET;
-        /* s6_addr32 would be nice, but it's non-standard. */
-        memcpy(&addr4_out->sin_addr, &addr6->sin6_addr.s6_addr[12], 4);
-        addr4_out->sin_port = addr6->sin6_port;
-        resolved_addr4_out->len =
-            static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
-      }
-      return 1;
-    }
-  }
-  return 0;
-}
-
-int grpc_sockaddr_to_v4mapped(const grpc_resolved_address* resolved_addr,
-                              grpc_resolved_address* resolved_addr6_out) {
-  GPR_ASSERT(resolved_addr != resolved_addr6_out);
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
-  grpc_sockaddr_in6* addr6_out =
-      reinterpret_cast<grpc_sockaddr_in6*>(resolved_addr6_out->addr);
-  if (addr->sa_family == GRPC_AF_INET) {
-    const grpc_sockaddr_in* addr4 =
-        reinterpret_cast<const grpc_sockaddr_in*>(addr);
-    memset(resolved_addr6_out, 0, sizeof(*resolved_addr6_out));
-    addr6_out->sin6_family = GRPC_AF_INET6;
-    memcpy(&addr6_out->sin6_addr.s6_addr[0], kV4MappedPrefix, 12);
-    memcpy(&addr6_out->sin6_addr.s6_addr[12], &addr4->sin_addr, 4);
-    addr6_out->sin6_port = addr4->sin_port;
-    resolved_addr6_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
-    return 1;
-  }
-  return 0;
-}
-
-int grpc_sockaddr_is_wildcard(const grpc_resolved_address* resolved_addr,
-                              int* port_out) {
-  const grpc_sockaddr* addr;
-  grpc_resolved_address addr4_normalized;
-  if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr4_normalized)) {
-    resolved_addr = &addr4_normalized;
-  }
-  addr = reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
-  if (addr->sa_family == GRPC_AF_INET) {
-    /* Check for 0.0.0.0 */
-    const grpc_sockaddr_in* addr4 =
-        reinterpret_cast<const grpc_sockaddr_in*>(addr);
-    if (addr4->sin_addr.s_addr != 0) {
-      return 0;
-    }
-    *port_out = grpc_ntohs(addr4->sin_port);
-    return 1;
-  } else if (addr->sa_family == GRPC_AF_INET6) {
-    /* Check for :: */
-    const grpc_sockaddr_in6* addr6 =
-        reinterpret_cast<const grpc_sockaddr_in6*>(addr);
-    int i;
-    for (i = 0; i < 16; i++) {
-      if (addr6->sin6_addr.s6_addr[i] != 0) {
-        return 0;
-      }
-    }
-    *port_out = grpc_ntohs(addr6->sin6_port);
-    return 1;
-  } else {
-    return 0;
-  }
-}
-
-void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address* wild4_out,
-                                  grpc_resolved_address* wild6_out) {
-  grpc_sockaddr_make_wildcard4(port, wild4_out);
-  grpc_sockaddr_make_wildcard6(port, wild6_out);
-}
-
-void grpc_sockaddr_make_wildcard4(int port,
-                                  grpc_resolved_address* resolved_wild_out) {
-  grpc_sockaddr_in* wild_out =
-      reinterpret_cast<grpc_sockaddr_in*>(resolved_wild_out->addr);
-  GPR_ASSERT(port >= 0 && port < 65536);
-  memset(resolved_wild_out, 0, sizeof(*resolved_wild_out));
-  wild_out->sin_family = GRPC_AF_INET;
-  wild_out->sin_port = grpc_htons(static_cast<uint16_t>(port));
-  resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
-}
-
-void grpc_sockaddr_make_wildcard6(int port,
-                                  grpc_resolved_address* resolved_wild_out) {
-  grpc_sockaddr_in6* wild_out =
-      reinterpret_cast<grpc_sockaddr_in6*>(resolved_wild_out->addr);
-  GPR_ASSERT(port >= 0 && port < 65536);
-  memset(resolved_wild_out, 0, sizeof(*resolved_wild_out));
-  wild_out->sin6_family = GRPC_AF_INET6;
-  wild_out->sin6_port = grpc_htons(static_cast<uint16_t>(port));
-  resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
-}
-
-std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
-                                    bool normalize) {
-  const int save_errno = errno;
-  grpc_resolved_address addr_normalized;
-  if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
-    resolved_addr = &addr_normalized;
-  }
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
-  const void* ip = nullptr;
-  int port = 0;
-  uint32_t sin6_scope_id = 0;
-  if (addr->sa_family == GRPC_AF_INET) {
-    const grpc_sockaddr_in* addr4 =
-        reinterpret_cast<const grpc_sockaddr_in*>(addr);
-    ip = &addr4->sin_addr;
-    port = grpc_ntohs(addr4->sin_port);
-  } else if (addr->sa_family == GRPC_AF_INET6) {
-    const grpc_sockaddr_in6* addr6 =
-        reinterpret_cast<const grpc_sockaddr_in6*>(addr);
-    ip = &addr6->sin6_addr;
-    port = grpc_ntohs(addr6->sin6_port);
-    sin6_scope_id = addr6->sin6_scope_id;
-  }
-  char ntop_buf[GRPC_INET6_ADDRSTRLEN];
-  std::string out;
-  if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
-                                      sizeof(ntop_buf)) != nullptr) {
-    if (sin6_scope_id != 0) {
-      // Enclose sin6_scope_id with the format defined in RFC 6784 section 2.
-      std::string host_with_scope =
-          absl::StrFormat("%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
-      out = grpc_core::JoinHostPort(host_with_scope, port);
-    } else {
-      out = grpc_core::JoinHostPort(ntop_buf, port);
-    }
-  } else {
-    out = absl::StrFormat("(sockaddr family=%d)", addr->sa_family);
-  }
-  /* This is probably redundant, but we wouldn't want to log the wrong error. */
-  errno = save_errno;
-  return out;
-}
-
-void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port) {
-  memset(out, 0, sizeof(grpc_resolved_address));
-  grpc_sockaddr_in6* addr6 = (grpc_sockaddr_in6*)out->addr;
-  grpc_sockaddr_in* addr4 = (grpc_sockaddr_in*)out->addr;
-  if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
-    addr6->sin6_family = GRPC_AF_INET6;
-    out->len = sizeof(grpc_sockaddr_in6);
-  } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
-    addr4->sin_family = GRPC_AF_INET;
-    out->len = sizeof(grpc_sockaddr_in);
-  } else {
-    GPR_ASSERT(0);
-  }
-  grpc_sockaddr_set_port(out, port);
-}
-
-char* grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
-  if (resolved_addr->len == 0) return nullptr;
-  grpc_resolved_address addr_normalized;
-  if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
-    resolved_addr = &addr_normalized;
-  }
-  const char* scheme = grpc_sockaddr_get_uri_scheme(resolved_addr);
-  if (scheme == nullptr || strcmp("unix", scheme) == 0) {
-    return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
-  }
-  std::string path =
-      grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
-  char* uri_str = nullptr;
-  if (scheme != nullptr) {
-    gpr_asprintf(&uri_str, "%s:%s", scheme, path.c_str());
-  }
-  return uri_str;
-}
-
-const char* grpc_sockaddr_get_uri_scheme(
-    const grpc_resolved_address* resolved_addr) {
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
-  switch (addr->sa_family) {
-    case GRPC_AF_INET:
-      return "ipv4";
-    case GRPC_AF_INET6:
-      return "ipv6";
-    case GRPC_AF_UNIX:
-      return "unix";
-  }
-  return nullptr;
-}
-
-int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr) {
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
-  return addr->sa_family;
-}
-
-int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
-  switch (addr->sa_family) {
-    case GRPC_AF_INET:
-      return grpc_ntohs(((grpc_sockaddr_in*)addr)->sin_port);
-    case GRPC_AF_INET6:
-      return grpc_ntohs(((grpc_sockaddr_in6*)addr)->sin6_port);
-    default:
-      if (grpc_is_unix_socket(resolved_addr)) {
-        return 1;
-      }
-      gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_get_port",
-              addr->sa_family);
-      return 0;
-  }
-}
-
-int grpc_sockaddr_set_port(const grpc_resolved_address* resolved_addr,
-                           int port) {
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
-  switch (addr->sa_family) {
-    case GRPC_AF_INET:
-      GPR_ASSERT(port >= 0 && port < 65536);
-      ((grpc_sockaddr_in*)addr)->sin_port =
-          grpc_htons(static_cast<uint16_t>(port));
-      return 1;
-    case GRPC_AF_INET6:
-      GPR_ASSERT(port >= 0 && port < 65536);
-      ((grpc_sockaddr_in6*)addr)->sin6_port =
-          grpc_htons(static_cast<uint16_t>(port));
-      return 1;
-    default:
-      gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",
-              addr->sa_family);
-      return 0;
-  }
-}

data/src/core/lib/iomgr/sockaddr_utils.h

@@ -1,79 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H
-#define GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H
-
-#include <grpc/support/port_platform.h>
-
-#include <string>
-
-#include "src/core/lib/iomgr/resolve_address.h"
-
-/* Returns true if addr is an IPv4-mapped IPv6 address within the
-   ::ffff:0.0.0.0/96 range, or false otherwise.
-
-   If addr4_out is non-NULL, the inner IPv4 address will be copied here when
-   returning true. */
-int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* addr,
-                              grpc_resolved_address* addr4_out);
-
-/* If addr is an AF_INET address, writes the corresponding ::ffff:0.0.0.0/96
-   address to addr6_out and returns true.  Otherwise returns false. */
-int grpc_sockaddr_to_v4mapped(const grpc_resolved_address* addr,
-                              grpc_resolved_address* addr6_out);
-
-/* If addr is ::, 0.0.0.0, or ::ffff:0.0.0.0, writes the port number to
- *port_out (if not NULL) and returns true, otherwise returns false. */
-int grpc_sockaddr_is_wildcard(const grpc_resolved_address* addr, int* port_out);
-
-/* Writes 0.0.0.0:port and [::]:port to separate sockaddrs. */
-void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address* wild4_out,
-                                  grpc_resolved_address* wild6_out);
-
-/* Writes 0.0.0.0:port. */
-void grpc_sockaddr_make_wildcard4(int port, grpc_resolved_address* wild_out);
-
-/* Writes [::]:port. */
-void grpc_sockaddr_make_wildcard6(int port, grpc_resolved_address* wild_out);
-
-/* Return the IP port number of a sockaddr */
-int grpc_sockaddr_get_port(const grpc_resolved_address* addr);
-
-/* Set IP port number of a sockaddr */
-int grpc_sockaddr_set_port(const grpc_resolved_address* addr, int port);
-
-// Converts a sockaddr into a newly-allocated human-readable string.
-//
-// Currently, only the AF_INET and AF_INET6 families are recognized.
-// If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
-// displayed as plain IPv4.
-std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
-                                    bool normalize);
-
-void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port);
-
-/* Returns the URI string corresponding to \a addr */
-char* grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
-
-/* Returns the URI scheme corresponding to \a addr */
-const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);
-
-int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr);
-
-#endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H */

data/src/core/lib/iomgr/socket_utils_uv.cc

@@ -1,49 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_UV
-
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/socket_utils.h"
-
-#include <grpc/support/log.h>
-
-#include <uv.h>
-
-uint16_t grpc_htons(uint16_t hostshort) { return htons(hostshort); }
-
-uint16_t grpc_ntohs(uint16_t netshort) { return ntohs(netshort); }
-
-uint32_t grpc_htonl(uint32_t hostlong) { return htonl(hostlong); }
-
-uint32_t grpc_ntohl(uint32_t netlong) { return ntohl(netlong); }
-
-int grpc_inet_pton(int af, const char* src, void* dst) {
-  return inet_pton(af, src, dst);
-}
-
-const char* grpc_inet_ntop(int af, const void* src, char* dst, size_t size) {
-  uv_inet_ntop(af, src, dst, size);
-  return dst;
-}
-
-#endif /* GRPC_UV */

data/src/core/lib/iomgr/sys_epoll_wrapper.h

@@ -1,30 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_IOMGR_SYS_EPOLL_WRAPPER_H
-#define GRPC_CORE_LIB_IOMGR_SYS_EPOLL_WRAPPER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <sys/epoll.h>
-
-#ifndef EPOLLEXCLUSIVE
-#define EPOLLEXCLUSIVE (1 << 28)
-#endif
-
-#endif /* GRPC_CORE_LIB_IOMGR_SYS_EPOLL_WRAPPER_H */