Fix: don't report error if UST app dies
[lttng-tools.git] / src / common / sessiond-comm / inet.c
CommitLineData
6364a07a
DG
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>
a655f4cf
MD
28#include <fcntl.h>
29#include <time.h>
30#include <poll.h>
6364a07a 31
90e535ef 32#include <common/common.h>
6364a07a
DG
33
34#include "inet.h"
35
a655f4cf
MD
36#define MSEC_PER_SEC 1000
37#define NSEC_PER_MSEC 1000000
38#define RECONNECT_DELAY 200 /* ms */
39
6364a07a
DG
40/*
41 * INET protocol operations.
42 */
43static const struct lttcomm_proto_ops inet_ops = {
44 .bind = lttcomm_bind_inet_sock,
45 .close = lttcomm_close_inet_sock,
46 .connect = lttcomm_connect_inet_sock,
47 .accept = lttcomm_accept_inet_sock,
48 .listen = lttcomm_listen_inet_sock,
49 .recvmsg = lttcomm_recvmsg_inet_sock,
50 .sendmsg = lttcomm_sendmsg_inet_sock,
51};
52
53/*
54 * Creates an PF_INET socket.
55 */
90e535ef 56LTTNG_HIDDEN
6364a07a
DG
57int lttcomm_create_inet_sock(struct lttcomm_sock *sock, int type, int proto)
58{
de5e9086 59 int val = 1, ret;
783a3b9a 60 unsigned long timeout;
6364a07a
DG
61
62 /* Create server socket */
63 if ((sock->fd = socket(PF_INET, type, proto)) < 0) {
64 PERROR("socket inet");
65 goto error;
66 }
67
68 sock->ops = &inet_ops;
69
70 /*
71 * Set socket option to reuse the address.
72 */
73 ret = setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
74 if (ret < 0) {
75 PERROR("setsockopt inet");
76 goto error;
77 }
783a3b9a
MD
78 timeout = lttcomm_get_network_timeout();
79 if (timeout) {
80 ret = lttcomm_setsockopt_rcv_timeout(sock->fd, timeout);
81 if (ret) {
82 goto error;
83 }
84 ret = lttcomm_setsockopt_snd_timeout(sock->fd, timeout);
85 if (ret) {
86 goto error;
87 }
88 }
6364a07a
DG
89
90 return 0;
91
92error:
93 return -1;
94}
95
96/*
97 * Bind socket and return.
98 */
90e535ef 99LTTNG_HIDDEN
6364a07a
DG
100int lttcomm_bind_inet_sock(struct lttcomm_sock *sock)
101{
102 int ret;
103
104 ret = bind(sock->fd, &sock->sockaddr.addr.sin,
105 sizeof(sock->sockaddr.addr.sin));
106 if (ret < 0) {
107 PERROR("bind inet");
108 }
109
110 return ret;
111}
112
a655f4cf
MD
113static
114int connect_no_timeout(struct lttcomm_sock *sock)
115{
116 return connect(sock->fd, (struct sockaddr *) &sock->sockaddr.addr.sin,
117 sizeof(sock->sockaddr.addr.sin));
118}
119
120/*
121 * Return time_a - time_b in milliseconds.
122 */
123static
124unsigned long time_diff_ms(struct timespec *time_a,
125 struct timespec *time_b)
126{
127 time_t sec_diff;
128 long nsec_diff;
129 unsigned long result_ms;
130
131 sec_diff = time_a->tv_sec - time_b->tv_sec;
132 nsec_diff = time_a->tv_nsec - time_b->tv_nsec;
133
134 result_ms = sec_diff * MSEC_PER_SEC;
135 result_ms += nsec_diff / NSEC_PER_MSEC;
136 return result_ms;
137}
138
139static
140int connect_with_timeout(struct lttcomm_sock *sock)
141{
142 unsigned long timeout = lttcomm_get_network_timeout();
143 int ret, flags, connect_ret;
144 struct timespec orig_time, cur_time;
145
146 ret = fcntl(sock->fd, F_GETFL, 0);
147 if (ret == -1) {
148 PERROR("fcntl");
149 return -1;
150 }
151 flags = ret;
152
153 /* Set socket to nonblock */
154 ret = fcntl(sock->fd, F_SETFL, flags | O_NONBLOCK);
155 if (ret == -1) {
156 PERROR("fcntl");
157 return -1;
158 }
159
160 ret = clock_gettime(CLOCK_MONOTONIC, &orig_time);
161 if (ret == -1) {
162 PERROR("clock_gettime");
163 return -1;
164 }
165
166 connect_ret = connect(sock->fd,
167 (struct sockaddr *) &sock->sockaddr.addr.sin,
168 sizeof(sock->sockaddr.addr.sin));
169 if (connect_ret == -1 && errno != EAGAIN
170 && errno != EWOULDBLOCK
171 && errno != EINPROGRESS) {
172 goto error;
173 } else if (!connect_ret) {
174 /* Connect succeeded */
175 goto success;
176 }
177
178 /*
179 * Perform poll loop following EINPROGRESS recommendation from
180 * connect(2) man page.
181 */
182 do {
183 struct pollfd fds;
184
185 fds.fd = sock->fd;
186 fds.events = POLLOUT;
187 fds.revents = 0;
188 ret = poll(&fds, 1, RECONNECT_DELAY);
189 if (ret < 0) {
190 goto error;
191 } else if (ret > 0) {
192 int optval;
193 socklen_t optval_len = sizeof(optval);
194
195 if (!(fds.revents & POLLOUT)) {
196 /* Either hup or error */
197 errno = EPIPE;
198 goto error;
199 }
200 /* got something */
201 ret = getsockopt(sock->fd, SOL_SOCKET,
202 SO_ERROR, &optval, &optval_len);
203 if (ret) {
204 goto error;
205 }
206 if (!optval) {
207 connect_ret = 0;
208 goto success;
209 } else {
210 goto error;
211 }
212 }
213 /* ret == 0: timeout */
214 ret = clock_gettime(CLOCK_MONOTONIC, &cur_time);
215 if (ret == -1) {
216 PERROR("clock_gettime");
217 connect_ret = ret;
218 goto error;
219 }
220 } while (time_diff_ms(&cur_time, &orig_time) < timeout);
221
222 /* Timeout */
223 errno = ETIMEDOUT;
224 connect_ret = -1;
225
226success:
227 /* Restore initial flags */
228 ret = fcntl(sock->fd, F_SETFL, flags);
229 if (ret == -1) {
230 PERROR("fcntl");
231 /* Continue anyway */
232 }
233error:
234 return connect_ret;
235}
236
6364a07a
DG
237/*
238 * Connect PF_INET socket.
239 */
90e535ef 240LTTNG_HIDDEN
6364a07a
DG
241int lttcomm_connect_inet_sock(struct lttcomm_sock *sock)
242{
243 int ret, closeret;
244
a655f4cf
MD
245 if (lttcomm_get_network_timeout()) {
246 ret = connect_with_timeout(sock);
247 } else {
248 ret = connect_no_timeout(sock);
249 }
6364a07a 250 if (ret < 0) {
82c05d47 251 PERROR("connect");
6364a07a
DG
252 goto error_connect;
253 }
254
255 return ret;
256
257error_connect:
258 closeret = close(sock->fd);
259 if (closeret) {
260 PERROR("close inet");
261 }
262
263 return ret;
264}
265
266/*
267 * Do an accept(2) on the sock and return the new lttcomm socket. The socket
268 * MUST be bind(2) before.
269 */
90e535ef 270LTTNG_HIDDEN
6364a07a
DG
271struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock)
272{
273 int new_fd;
88a5db70 274 socklen_t len;
6364a07a
DG
275 struct lttcomm_sock *new_sock;
276
277 if (sock->proto == LTTCOMM_SOCK_UDP) {
278 /*
279 * accept(2) does not exist for UDP so simply return the passed socket.
280 */
281 new_sock = sock;
282 goto end;
283 }
284
de5e9086 285 new_sock = lttcomm_alloc_sock(sock->proto);
6364a07a
DG
286 if (new_sock == NULL) {
287 goto error;
288 }
289
88a5db70
DG
290 len = sizeof(new_sock->sockaddr.addr.sin);
291
6364a07a
DG
292 /* Blocking call */
293 new_fd = accept(sock->fd, (struct sockaddr *) &new_sock->sockaddr.addr.sin,
294 &len);
295 if (new_fd < 0) {
296 PERROR("accept inet");
297 goto error;
298 }
299
300 new_sock->fd = new_fd;
de5e9086 301 new_sock->ops = &inet_ops;
6364a07a
DG
302
303end:
304 return new_sock;
305
306error:
307 free(new_sock);
308 return NULL;
309}
310
311/*
312 * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN.
313 */
90e535ef 314LTTNG_HIDDEN
6364a07a
DG
315int lttcomm_listen_inet_sock(struct lttcomm_sock *sock, int backlog)
316{
317 int ret;
318
319 if (sock->proto == LTTCOMM_SOCK_UDP) {
320 /* listen(2) does not exist for UDP so simply return success. */
321 ret = 0;
322 goto end;
323 }
324
325 /* Default listen backlog */
326 if (backlog <= 0) {
327 backlog = LTTNG_SESSIOND_COMM_MAX_LISTEN;
328 }
329
330 ret = listen(sock->fd, backlog);
331 if (ret < 0) {
332 PERROR("listen inet");
333 }
334
335end:
336 return ret;
337}
338
339/*
340 * Receive data of size len in put that data into the buf param. Using recvmsg
341 * API.
342 *
343 * Return the size of received data.
344 */
90e535ef 345LTTNG_HIDDEN
6364a07a
DG
346ssize_t lttcomm_recvmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
347 size_t len, int flags)
348{
349 struct msghdr msg;
350 struct iovec iov[1];
351 ssize_t ret = -1;
7c5aef62 352 size_t len_last;
6364a07a
DG
353
354 memset(&msg, 0, sizeof(msg));
355
356 iov[0].iov_base = buf;
357 iov[0].iov_len = len;
358 msg.msg_iov = iov;
359 msg.msg_iovlen = 1;
360
361 msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
362 msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
363
6364a07a 364 do {
7c5aef62 365 len_last = iov[0].iov_len;
6364a07a 366 ret = recvmsg(sock->fd, &msg, flags);
7c5aef62
DG
367 if (ret > 0) {
368 iov[0].iov_base += ret;
369 iov[0].iov_len -= ret;
370 assert(ret <= len_last);
371 }
372 } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR));
6364a07a
DG
373 if (ret < 0) {
374 PERROR("recvmsg inet");
7c5aef62
DG
375 } else if (ret > 0) {
376 ret = len;
6364a07a 377 }
7c5aef62 378 /* Else ret = 0 meaning an orderly shutdown. */
6364a07a
DG
379
380 return ret;
381}
382
383/*
384 * Send buf data of size len. Using sendmsg API.
385 *
386 * Return the size of sent data.
387 */
90e535ef 388LTTNG_HIDDEN
6364a07a
DG
389ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
390 size_t len, int flags)
391{
392 struct msghdr msg;
393 struct iovec iov[1];
394 ssize_t ret = -1;
395
396 memset(&msg, 0, sizeof(msg));
397
398 iov[0].iov_base = buf;
399 iov[0].iov_len = len;
400 msg.msg_iov = iov;
401 msg.msg_iovlen = 1;
402
403 switch (sock->proto) {
404 case LTTCOMM_SOCK_UDP:
405 msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
406 msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
407 break;
408 default:
409 break;
410 }
411
412 do {
413 ret = sendmsg(sock->fd, &msg, flags);
414 } while (ret < 0 && errno == EINTR);
415 if (ret < 0) {
416 /*
417 * Only warn about EPIPE when quiet mode is deactivated.
418 * We consider EPIPE as expected.
419 */
420 if (errno != EPIPE || !lttng_opt_quiet) {
421 PERROR("sendmsg inet");
422 }
423 }
424
425 return ret;
426}
427
428/*
429 * Shutdown cleanly and close.
430 */
90e535ef 431LTTNG_HIDDEN
6364a07a
DG
432int lttcomm_close_inet_sock(struct lttcomm_sock *sock)
433{
6e742359 434 int ret;
6364a07a 435
de5e9086 436 /* Don't try to close an invalid marked socket */
6364a07a
DG
437 if (sock->fd == -1) {
438 return 0;
439 }
440
6e742359
DG
441 ret = close(sock->fd);
442 if (ret) {
6364a07a
DG
443 PERROR("close inet");
444 }
445
446 /* Mark socket */
447 sock->fd = -1;
448
449 return ret;
450}
This page took 0.071126 seconds and 4 git commands to generate.