Line data Source code
1 : /*
2 : *
3 : * Copyright 2015, Google Inc.
4 : * All rights reserved.
5 : *
6 : * Redistribution and use in source and binary forms, with or without
7 : * modification, are permitted provided that the following conditions are
8 : * met:
9 : *
10 : * * Redistributions of source code must retain the above copyright
11 : * notice, this list of conditions and the following disclaimer.
12 : * * Redistributions in binary form must reproduce the above
13 : * copyright notice, this list of conditions and the following disclaimer
14 : * in the documentation and/or other materials provided with the
15 : * distribution.
16 : * * Neither the name of Google Inc. nor the names of its
17 : * contributors may be used to endorse or promote products derived from
18 : * this software without specific prior written permission.
19 : *
20 : * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 : * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 : * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 : * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 : * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 : * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 : * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 : * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 : * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 : * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 : *
32 : */
33 :
34 : #include "src/core/iomgr/sockaddr_utils.h"
35 :
36 : #include <errno.h>
37 : #include <string.h>
38 :
39 : #ifdef GPR_POSIX_SOCKET
40 : #include <sys/un.h>
41 : #endif
42 :
43 : #include <grpc/support/alloc.h>
44 : #include <grpc/support/host_port.h>
45 : #include <grpc/support/log.h>
46 : #include <grpc/support/port_platform.h>
47 : #include <grpc/support/string_util.h>
48 :
49 : #include "src/core/support/string.h"
50 :
51 : static const gpr_uint8 kV4MappedPrefix[] = {0, 0, 0, 0, 0, 0,
52 : 0, 0, 0, 0, 0xff, 0xff};
53 :
54 10276 : int grpc_sockaddr_is_v4mapped(const struct sockaddr *addr,
55 : struct sockaddr_in *addr4_out) {
56 10276 : GPR_ASSERT(addr != (struct sockaddr *)addr4_out);
57 10276 : if (addr->sa_family == AF_INET6) {
58 7402 : const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr;
59 7402 : if (memcmp(addr6->sin6_addr.s6_addr, kV4MappedPrefix,
60 : sizeof(kV4MappedPrefix)) == 0) {
61 7249 : if (addr4_out != NULL) {
62 : /* Normalize ::ffff:0.0.0.0/96 to IPv4. */
63 7132 : memset(addr4_out, 0, sizeof(*addr4_out));
64 7132 : addr4_out->sin_family = AF_INET;
65 : /* s6_addr32 would be nice, but it's non-standard. */
66 7132 : memcpy(&addr4_out->sin_addr, &addr6->sin6_addr.s6_addr[12], 4);
67 7132 : addr4_out->sin_port = addr6->sin6_port;
68 : }
69 7249 : return 1;
70 : }
71 : }
72 3027 : return 0;
73 : }
74 :
75 6617 : int grpc_sockaddr_to_v4mapped(const struct sockaddr *addr,
76 : struct sockaddr_in6 *addr6_out) {
77 6617 : GPR_ASSERT(addr != (struct sockaddr *)addr6_out);
78 6617 : if (addr->sa_family == AF_INET) {
79 5876 : const struct sockaddr_in *addr4 = (const struct sockaddr_in *)addr;
80 5876 : memset(addr6_out, 0, sizeof(*addr6_out));
81 5876 : addr6_out->sin6_family = AF_INET6;
82 5876 : memcpy(&addr6_out->sin6_addr.s6_addr[0], kV4MappedPrefix, 12);
83 5876 : memcpy(&addr6_out->sin6_addr.s6_addr[12], &addr4->sin_addr, 4);
84 5876 : addr6_out->sin6_port = addr4->sin_port;
85 5876 : return 1;
86 : }
87 741 : return 0;
88 : }
89 :
90 1792 : int grpc_sockaddr_is_wildcard(const struct sockaddr *addr, int *port_out) {
91 : struct sockaddr_in addr4_normalized;
92 1792 : if (grpc_sockaddr_is_v4mapped(addr, &addr4_normalized)) {
93 1417 : addr = (struct sockaddr *)&addr4_normalized;
94 : }
95 1792 : if (addr->sa_family == AF_INET) {
96 : /* Check for 0.0.0.0 */
97 1419 : const struct sockaddr_in *addr4 = (const struct sockaddr_in *)addr;
98 1419 : if (addr4->sin_addr.s_addr != 0) {
99 1392 : return 0;
100 : }
101 27 : *port_out = ntohs(addr4->sin_port);
102 27 : return 1;
103 373 : } else if (addr->sa_family == AF_INET6) {
104 : /* Check for :: */
105 52 : const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr;
106 : int i;
107 836 : for (i = 0; i < 16; i++) {
108 802 : if (addr6->sin6_addr.s6_addr[i] != 0) {
109 18 : return 0;
110 : }
111 : }
112 34 : *port_out = ntohs(addr6->sin6_port);
113 34 : return 1;
114 : } else {
115 321 : return 0;
116 : }
117 : }
118 :
119 59 : void grpc_sockaddr_make_wildcards(int port, struct sockaddr_in *wild4_out,
120 : struct sockaddr_in6 *wild6_out) {
121 59 : grpc_sockaddr_make_wildcard4(port, wild4_out);
122 59 : grpc_sockaddr_make_wildcard6(port, wild6_out);
123 59 : }
124 :
125 59 : void grpc_sockaddr_make_wildcard4(int port, struct sockaddr_in *wild_out) {
126 59 : GPR_ASSERT(port >= 0 && port < 65536);
127 59 : memset(wild_out, 0, sizeof(*wild_out));
128 59 : wild_out->sin_family = AF_INET;
129 59 : wild_out->sin_port = htons((gpr_uint16)port);
130 59 : }
131 :
132 59 : void grpc_sockaddr_make_wildcard6(int port, struct sockaddr_in6 *wild_out) {
133 59 : GPR_ASSERT(port >= 0 && port < 65536);
134 59 : memset(wild_out, 0, sizeof(*wild_out));
135 59 : wild_out->sin6_family = AF_INET6;
136 59 : wild_out->sin6_port = htons((gpr_uint16)port);
137 59 : }
138 :
139 7590 : int grpc_sockaddr_to_string(char **out, const struct sockaddr *addr,
140 : int normalize) {
141 7590 : const int save_errno = errno;
142 : struct sockaddr_in addr_normalized;
143 : char ntop_buf[INET6_ADDRSTRLEN];
144 7590 : const void *ip = NULL;
145 : int port;
146 : int ret;
147 :
148 7590 : *out = NULL;
149 7590 : if (normalize && grpc_sockaddr_is_v4mapped(addr, &addr_normalized)) {
150 1 : addr = (const struct sockaddr *)&addr_normalized;
151 : }
152 7590 : if (addr->sa_family == AF_INET) {
153 5724 : const struct sockaddr_in *addr4 = (const struct sockaddr_in *)addr;
154 5724 : ip = &addr4->sin_addr;
155 5724 : port = ntohs(addr4->sin_port);
156 1866 : } else if (addr->sa_family == AF_INET6) {
157 64 : const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr;
158 64 : ip = &addr6->sin6_addr;
159 64 : port = ntohs(addr6->sin6_port);
160 : }
161 : /* Windows inet_ntop wants a mutable ip pointer */
162 13378 : if (ip != NULL &&
163 5788 : inet_ntop(addr->sa_family, (void *)ip, ntop_buf, sizeof(ntop_buf)) !=
164 : NULL) {
165 5788 : ret = gpr_join_host_port(out, ntop_buf, port);
166 : } else {
167 1802 : ret = gpr_asprintf(out, "(sockaddr family=%d)", addr->sa_family);
168 : }
169 : /* This is probably redundant, but we wouldn't want to log the wrong error. */
170 7590 : errno = save_errno;
171 7590 : return ret;
172 : }
173 :
174 6389 : char *grpc_sockaddr_to_uri(const struct sockaddr *addr) {
175 : char *temp;
176 : char *result;
177 : struct sockaddr_in addr_normalized;
178 :
179 6389 : if (grpc_sockaddr_is_v4mapped(addr, &addr_normalized)) {
180 5597 : addr = (const struct sockaddr *)&addr_normalized;
181 : }
182 :
183 6389 : switch (addr->sa_family) {
184 : case AF_INET:
185 5721 : grpc_sockaddr_to_string(&temp, addr, 0);
186 5721 : gpr_asprintf(&result, "ipv4:%s", temp);
187 5721 : gpr_free(temp);
188 5721 : return result;
189 : case AF_INET6:
190 59 : grpc_sockaddr_to_string(&temp, addr, 0);
191 59 : gpr_asprintf(&result, "ipv6:%s", temp);
192 59 : gpr_free(temp);
193 59 : return result;
194 : #ifdef GPR_POSIX_SOCKET
195 : case AF_UNIX:
196 608 : gpr_asprintf(&result, "unix:%s", ((struct sockaddr_un *)addr)->sun_path);
197 608 : return result;
198 : #endif
199 : }
200 :
201 1 : return NULL;
202 : }
203 :
204 3585 : int grpc_sockaddr_get_port(const struct sockaddr *addr) {
205 3585 : switch (addr->sa_family) {
206 : case AF_INET:
207 1439 : return ntohs(((struct sockaddr_in *)addr)->sin_port);
208 : case AF_INET6:
209 1506 : return ntohs(((struct sockaddr_in6 *)addr)->sin6_port);
210 : case AF_UNIX:
211 640 : return 1;
212 : default:
213 0 : gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_get_port",
214 0 : addr->sa_family);
215 0 : return 0;
216 : }
217 : }
218 :
219 0 : int grpc_sockaddr_set_port(const struct sockaddr *addr, int port) {
220 0 : switch (addr->sa_family) {
221 : case AF_INET:
222 0 : GPR_ASSERT(port >= 0 && port < 65536);
223 0 : ((struct sockaddr_in *)addr)->sin_port = htons((gpr_uint16)port);
224 0 : return 1;
225 : case AF_INET6:
226 0 : GPR_ASSERT(port >= 0 && port < 65536);
227 0 : ((struct sockaddr_in6 *)addr)->sin6_port = htons((gpr_uint16)port);
228 0 : return 1;
229 : default:
230 0 : gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",
231 0 : addr->sa_family);
232 0 : return 0;
233 : }
234 : }
|
