1 /*
2 *
3 * Copyright 2016 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 #include <grpc/support/port_platform.h>
19
20 #include "src/core/lib/iomgr/port.h"
21
22 #ifdef GRPC_HAVE_UNIX_SOCKET
23
24 #include "src/core/lib/iomgr/sockaddr.h"
25
26 #include <cstdio>
27 #include <string.h>
28 #include <sys/stat.h>
29 #include <sys/types.h>
30 #include <sys/un.h>
31
32 #include "src/core/lib/iomgr/unix_sockets_posix.h"
33
34 #include <grpc/support/alloc.h>
35 #include <grpc/support/log.h>
36
37 #include "src/core/lib/gpr/useful.h"
38
grpc_create_socketpair_if_unix(int sv[2])39 void grpc_create_socketpair_if_unix(int sv[2]) {
40 GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
41 }
42
grpc_resolve_unix_domain_address(const char * name,grpc_resolved_addresses ** addrs)43 grpc_error* grpc_resolve_unix_domain_address(const char* name,
44 grpc_resolved_addresses** addrs) {
45 struct sockaddr_un* un;
46 if (strlen(name) >
47 GPR_ARRAY_SIZE(((struct sockaddr_un*)nullptr)->sun_path) - 1) {
48 char* err_msg;
49 grpc_error* err;
50 gpr_asprintf(&err_msg,
51 "Path name should not have more than %" PRIuPTR " characters.",
52 GPR_ARRAY_SIZE(un->sun_path) - 1);
53 err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(err_msg);
54 gpr_free(err_msg);
55 return err;
56 }
57 *addrs = static_cast<grpc_resolved_addresses*>(
58 gpr_malloc(sizeof(grpc_resolved_addresses)));
59 (*addrs)->naddrs = 1;
60 (*addrs)->addrs = static_cast<grpc_resolved_address*>(
61 gpr_malloc(sizeof(grpc_resolved_address)));
62 un = reinterpret_cast<struct sockaddr_un*>((*addrs)->addrs->addr);
63 un->sun_family = AF_UNIX;
64 strncpy(un->sun_path, name, sizeof(un->sun_path));
65 (*addrs)->addrs->len =
66 static_cast<socklen_t>(strlen(un->sun_path) + sizeof(un->sun_family) + 1);
67 return GRPC_ERROR_NONE;
68 }
69
grpc_resolve_vsock_address(const char * name,grpc_resolved_addresses ** addrs)70 grpc_error* grpc_resolve_vsock_address(const char* name,
71 grpc_resolved_addresses** addrs) {
72 #ifdef GRPC_HAVE_LINUX_VSOCK
73 struct sockaddr_vm *vm;
74 unsigned int cid;
75 unsigned int port;
76
77 if (sscanf(name, "%u:%u", &cid, &port) != 2) {
78 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to parse cid:port pair");
79 }
80
81 *addrs = static_cast<grpc_resolved_addresses*>(
82 gpr_malloc(sizeof(grpc_resolved_addresses)));
83 (*addrs)->naddrs = 1;
84 (*addrs)->addrs = static_cast<grpc_resolved_address*>(
85 gpr_zalloc(sizeof(grpc_resolved_address)));
86 vm = (struct sockaddr_vm *)(*addrs)->addrs->addr;
87 vm->svm_family = AF_VSOCK;
88 vm->svm_cid = cid;
89 vm->svm_port = port;
90 (*addrs)->addrs->len = sizeof(struct sockaddr_vm);
91 return GRPC_ERROR_NONE;
92 #else /* GRPC_HAVE_LINUX_VSOCK */
93 return GRPC_ERROR_CREATE_FROM_STATIC_STRING("vsock not supported");
94 #endif /* GRPC_HAVE_LINUX_VSOCK */
95 }
96
grpc_is_unix_socket(const grpc_resolved_address * resolved_addr)97 int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr) {
98 const grpc_sockaddr* addr =
99 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
100 return addr->sa_family == AF_UNIX;
101 }
102
grpc_is_vsock(const grpc_resolved_address * resolved_addr)103 int grpc_is_vsock(const grpc_resolved_address* resolved_addr) {
104 #ifdef GRPC_HAVE_LINUX_VSOCK
105 const grpc_sockaddr* addr =
106 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
107 return addr->sa_family == AF_VSOCK;
108 #else /* GRPC_HAVE_LINUX_VSOCK */
109 return 0;
110 #endif /* GRPC_HAVE_LINUX_VSOCK */
111 }
112
grpc_unlink_if_unix_domain_socket(const grpc_resolved_address * resolved_addr)113 void grpc_unlink_if_unix_domain_socket(
114 const grpc_resolved_address* resolved_addr) {
115 const grpc_sockaddr* addr =
116 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
117 if (addr->sa_family != AF_UNIX) {
118 return;
119 }
120 struct sockaddr_un* un = reinterpret_cast<struct sockaddr_un*>(
121 const_cast<char*>(resolved_addr->addr));
122 struct stat st;
123
124 if (stat(un->sun_path, &st) == 0 && (st.st_mode & S_IFMT) == S_IFSOCK) {
125 unlink(un->sun_path);
126 }
127 }
128
grpc_sockaddr_to_uri_unix_if_possible(const grpc_resolved_address * resolved_addr)129 char* grpc_sockaddr_to_uri_unix_if_possible(
130 const grpc_resolved_address* resolved_addr) {
131 const grpc_sockaddr* addr =
132 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
133 if (addr->sa_family != AF_UNIX) {
134 return nullptr;
135 }
136
137 char* result;
138 gpr_asprintf(&result, "unix:%s", ((struct sockaddr_un*)addr)->sun_path);
139 return result;
140 }
141
grpc_sockaddr_to_uri_vsock_if_possible(const grpc_resolved_address * resolved_addr)142 char* grpc_sockaddr_to_uri_vsock_if_possible(
143 const grpc_resolved_address* resolved_addr) {
144 #ifdef GRPC_HAVE_LINUX_VSOCK
145 const grpc_sockaddr* addr =
146 reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
147
148 if (addr->sa_family != AF_VSOCK) {
149 return nullptr;
150 }
151
152 char *result;
153 struct sockaddr_vm *vm = (struct sockaddr_vm*)addr;
154 gpr_asprintf(&result, "vsock:%u:%u", vm->svm_cid, vm->svm_port);
155 return result;
156 #else /* GRPC_HAVE_LINUX_VSOCK */
157 return nullptr;
158 #endif /* GRPC_HAVE_LINUX_VSOCK */
159 }
160
161 #endif
162