1 /*
2  *
3  * Copyright 2015 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *     http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
19 #ifndef GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H
20 #define GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H
21 
22 #include <grpc/support/port_platform.h>
23 
24 #include <string>
25 
26 #include <grpc/event_engine/event_engine.h>
27 
28 #include "src/core/lib/iomgr/resolve_address.h"
29 
30 /* Returns true if addr is an IPv4-mapped IPv6 address within the
31    ::ffff:0.0.0.0/96 range, or false otherwise.
32 
33    If addr4_out is non-NULL, the inner IPv4 address will be copied here when
34    returning true. */
35 int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* addr,
36                               grpc_resolved_address* addr4_out);
37 
38 /* If addr is an AF_INET address, writes the corresponding ::ffff:0.0.0.0/96
39    address to addr6_out and returns true.  Otherwise returns false. */
40 int grpc_sockaddr_to_v4mapped(const grpc_resolved_address* addr,
41                               grpc_resolved_address* addr6_out);
42 
43 /* If addr is ::, 0.0.0.0, or ::ffff:0.0.0.0, writes the port number to
44  *port_out (if not NULL) and returns true, otherwise returns false. */
45 int grpc_sockaddr_is_wildcard(const grpc_resolved_address* addr, int* port_out);
46 
47 /* Writes 0.0.0.0:port and [::]:port to separate sockaddrs. */
48 void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address* wild4_out,
49                                   grpc_resolved_address* wild6_out);
50 
51 /* Writes 0.0.0.0:port. */
52 void grpc_sockaddr_make_wildcard4(int port, grpc_resolved_address* wild_out);
53 
54 /* Writes [::]:port. */
55 void grpc_sockaddr_make_wildcard6(int port, grpc_resolved_address* wild_out);
56 
57 /* Return the IP port number of a sockaddr */
58 int grpc_sockaddr_get_port(const grpc_resolved_address* addr);
59 
60 /* Set IP port number of a sockaddr */
61 int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
62 
63 // Converts a sockaddr into a newly-allocated human-readable string.
64 //
65 // Currently, only the AF_INET and AF_INET6 families are recognized.
66 // If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
67 // displayed as plain IPv4.
68 std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
69                                     bool normalize) GRPC_MUST_USE_RESULT;
70 
71 // Newer form of grpc_string_to_sockaddr which returns an error instead of
72 // crashing if \a addr is not IPv6/IPv6
73 grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
74                                           const char* addr, int port);
75 
76 /* Returns the URI string corresponding to \a addr */
77 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
78 
79 /* Returns the URI scheme corresponding to \a addr */
80 const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);
81 
82 int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr);
83 
84 std::string grpc_sockaddr_get_packed_host(
85     const grpc_resolved_address* resolved_addr);
86 
87 // Applies a mask of \a mask_bits to IPv4/IPv6 addresses. Has no effect if the
88 // address type is not IPv4/IPv6.
89 void grpc_sockaddr_mask_bits(grpc_resolved_address* address,
90                              uint32_t mask_bits);
91 
92 // If \a address is IPv4/IPv6, checks if the IP address falls in the CIDR
93 // specified by \a subnet_address and \a mask_bits.
94 // Returns false if \a address is not an IPv4/IPv6 address. The ports (if set)
95 // are ignored for matching purposes. Note that, \a subnet_address should be
96 // normalized, i.e., `grpc_sockaddr_mask_bits` should have been called on it if
97 // necessary.
98 bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
99                                 const grpc_resolved_address* subnet_address,
100                                 uint32_t mask_bits);
101 
102 namespace grpc_event_engine {
103 namespace experimental {
104 
105 std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr);
106 
107 }  // namespace experimental
108 }  // namespace grpc_event_engine
109 
110 #endif /* GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H */
111