Set hidden visibility for calls used in lttng-ctl
[lttng-tools.git] / src / common / sessiond-comm / inet.c
1 /*
2 * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #define _GNU_SOURCE
19 #include <assert.h>
20 #include <limits.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26 #include <unistd.h>
27 #include <errno.h>
28
29 #include <common/defaults.h>
30 #include <common/error.h>
31
32 #include "inet.h"
33
34 /*
35 * INET protocol operations.
36 */
37 static const struct lttcomm_proto_ops inet_ops = {
38 .bind = lttcomm_bind_inet_sock,
39 .close = lttcomm_close_inet_sock,
40 .connect = lttcomm_connect_inet_sock,
41 .accept = lttcomm_accept_inet_sock,
42 .listen = lttcomm_listen_inet_sock,
43 .recvmsg = lttcomm_recvmsg_inet_sock,
44 .sendmsg = lttcomm_sendmsg_inet_sock,
45 };
46
47 /*
48 * Creates an PF_INET socket.
49 */
50 __attribute__((visibility("hidden")))
51 int lttcomm_create_inet_sock(struct lttcomm_sock *sock, int type, int proto)
52 {
53 int val = 1, ret;
54
55 /* Create server socket */
56 if ((sock->fd = socket(PF_INET, type, proto)) < 0) {
57 PERROR("socket inet");
58 goto error;
59 }
60
61 sock->ops = &inet_ops;
62
63 /*
64 * Set socket option to reuse the address.
65 */
66 ret = setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
67 if (ret < 0) {
68 PERROR("setsockopt inet");
69 goto error;
70 }
71
72 return 0;
73
74 error:
75 return -1;
76 }
77
78 /*
79 * Bind socket and return.
80 */
81 __attribute__((visibility("hidden")))
82 int lttcomm_bind_inet_sock(struct lttcomm_sock *sock)
83 {
84 int ret;
85
86 ret = bind(sock->fd, &sock->sockaddr.addr.sin,
87 sizeof(sock->sockaddr.addr.sin));
88 if (ret < 0) {
89 PERROR("bind inet");
90 }
91
92 return ret;
93 }
94
95 /*
96 * Connect PF_INET socket.
97 */
98 __attribute__((visibility("hidden")))
99 int lttcomm_connect_inet_sock(struct lttcomm_sock *sock)
100 {
101 int ret, closeret;
102
103 ret = connect(sock->fd, (struct sockaddr *) &sock->sockaddr.addr.sin,
104 sizeof(sock->sockaddr.addr.sin));
105 if (ret < 0) {
106 /*
107 * Don't print message on connect error, because connect is used in
108 * normal execution to detect if sessiond is alive.
109 */
110 goto error_connect;
111 }
112
113 return ret;
114
115 error_connect:
116 closeret = close(sock->fd);
117 if (closeret) {
118 PERROR("close inet");
119 }
120
121 return ret;
122 }
123
124 /*
125 * Do an accept(2) on the sock and return the new lttcomm socket. The socket
126 * MUST be bind(2) before.
127 */
128 __attribute__((visibility("hidden")))
129 struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock)
130 {
131 int new_fd;
132 socklen_t len = 0;
133 struct lttcomm_sock *new_sock;
134
135 if (sock->proto == LTTCOMM_SOCK_UDP) {
136 /*
137 * accept(2) does not exist for UDP so simply return the passed socket.
138 */
139 new_sock = sock;
140 goto end;
141 }
142
143 new_sock = lttcomm_alloc_sock(sock->proto);
144 if (new_sock == NULL) {
145 goto error;
146 }
147
148 /* Blocking call */
149 new_fd = accept(sock->fd, (struct sockaddr *) &new_sock->sockaddr.addr.sin,
150 &len);
151 if (new_fd < 0) {
152 PERROR("accept inet");
153 goto error;
154 }
155
156 new_sock->fd = new_fd;
157 new_sock->ops = &inet_ops;
158
159 end:
160 return new_sock;
161
162 error:
163 free(new_sock);
164 return NULL;
165 }
166
167 /*
168 * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN.
169 */
170 __attribute__((visibility("hidden")))
171 int lttcomm_listen_inet_sock(struct lttcomm_sock *sock, int backlog)
172 {
173 int ret;
174
175 if (sock->proto == LTTCOMM_SOCK_UDP) {
176 /* listen(2) does not exist for UDP so simply return success. */
177 ret = 0;
178 goto end;
179 }
180
181 /* Default listen backlog */
182 if (backlog <= 0) {
183 backlog = LTTNG_SESSIOND_COMM_MAX_LISTEN;
184 }
185
186 ret = listen(sock->fd, backlog);
187 if (ret < 0) {
188 PERROR("listen inet");
189 }
190
191 end:
192 return ret;
193 }
194
195 /*
196 * Receive data of size len in put that data into the buf param. Using recvmsg
197 * API.
198 *
199 * Return the size of received data.
200 */
201 __attribute__((visibility("hidden")))
202 ssize_t lttcomm_recvmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
203 size_t len, int flags)
204 {
205 struct msghdr msg;
206 struct iovec iov[1];
207 ssize_t ret = -1;
208
209 memset(&msg, 0, sizeof(msg));
210
211 iov[0].iov_base = buf;
212 iov[0].iov_len = len;
213 msg.msg_iov = iov;
214 msg.msg_iovlen = 1;
215
216 msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
217 msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
218
219 if (flags == 0) {
220 flags = MSG_WAITALL;
221 }
222
223 do {
224 ret = recvmsg(sock->fd, &msg, flags);
225 } while (ret < 0 && errno == EINTR);
226 if (ret < 0) {
227 PERROR("recvmsg inet");
228 }
229
230 return ret;
231 }
232
233 /*
234 * Send buf data of size len. Using sendmsg API.
235 *
236 * Return the size of sent data.
237 */
238 __attribute__((visibility("hidden")))
239 ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
240 size_t len, int flags)
241 {
242 struct msghdr msg;
243 struct iovec iov[1];
244 ssize_t ret = -1;
245
246 memset(&msg, 0, sizeof(msg));
247
248 iov[0].iov_base = buf;
249 iov[0].iov_len = len;
250 msg.msg_iov = iov;
251 msg.msg_iovlen = 1;
252
253 switch (sock->proto) {
254 case LTTCOMM_SOCK_UDP:
255 msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
256 msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
257 break;
258 default:
259 break;
260 }
261
262 do {
263 ret = sendmsg(sock->fd, &msg, flags);
264 } while (ret < 0 && errno == EINTR);
265 if (ret < 0) {
266 /*
267 * Only warn about EPIPE when quiet mode is deactivated.
268 * We consider EPIPE as expected.
269 */
270 if (errno != EPIPE || !lttng_opt_quiet) {
271 PERROR("sendmsg inet");
272 }
273 }
274
275 return ret;
276 }
277
278 /*
279 * Shutdown cleanly and close.
280 */
281 __attribute__((visibility("hidden")))
282 int lttcomm_close_inet_sock(struct lttcomm_sock *sock)
283 {
284 int ret;
285
286 /* Don't try to close an invalid marked socket */
287 if (sock->fd == -1) {
288 return 0;
289 }
290
291 ret = close(sock->fd);
292 if (ret) {
293 PERROR("close inet");
294 }
295
296 /* Mark socket */
297 sock->fd = -1;
298
299 return ret;
300 }
This page took 0.053669 seconds and 4 git commands to generate.