Fix: Silence warning by casting *sin_addr to *sockaddr
[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
6c1c0768 18#define _LGPL_SOURCE
6364a07a
DG
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
d831c249
DG
53unsigned long lttcomm_inet_tcp_timeout;
54
6364a07a
DG
55/*
56 * Creates an PF_INET socket.
57 */
90e535ef 58LTTNG_HIDDEN
6364a07a
DG
59int lttcomm_create_inet_sock(struct lttcomm_sock *sock, int type, int proto)
60{
de5e9086 61 int val = 1, ret;
783a3b9a 62 unsigned long timeout;
6364a07a
DG
63
64 /* Create server socket */
65 if ((sock->fd = socket(PF_INET, type, proto)) < 0) {
66 PERROR("socket inet");
67 goto error;
68 }
69
70 sock->ops = &inet_ops;
71
72 /*
73 * Set socket option to reuse the address.
74 */
75 ret = setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
76 if (ret < 0) {
77 PERROR("setsockopt inet");
78 goto error;
79 }
783a3b9a
MD
80 timeout = lttcomm_get_network_timeout();
81 if (timeout) {
82 ret = lttcomm_setsockopt_rcv_timeout(sock->fd, timeout);
83 if (ret) {
84 goto error;
85 }
86 ret = lttcomm_setsockopt_snd_timeout(sock->fd, timeout);
87 if (ret) {
88 goto error;
89 }
90 }
6364a07a
DG
91
92 return 0;
93
94error:
95 return -1;
96}
97
98/*
99 * Bind socket and return.
100 */
90e535ef 101LTTNG_HIDDEN
6364a07a
DG
102int lttcomm_bind_inet_sock(struct lttcomm_sock *sock)
103{
104 int ret;
105
14b88ccf 106 ret = bind(sock->fd, (const struct sockaddr *) &sock->sockaddr.addr.sin,
6364a07a
DG
107 sizeof(sock->sockaddr.addr.sin));
108 if (ret < 0) {
109 PERROR("bind inet");
110 }
111
112 return ret;
113}
114
a655f4cf
MD
115static
116int connect_no_timeout(struct lttcomm_sock *sock)
117{
118 return connect(sock->fd, (struct sockaddr *) &sock->sockaddr.addr.sin,
119 sizeof(sock->sockaddr.addr.sin));
120}
121
122/*
123 * Return time_a - time_b in milliseconds.
124 */
125static
126unsigned long time_diff_ms(struct timespec *time_a,
127 struct timespec *time_b)
128{
129 time_t sec_diff;
130 long nsec_diff;
131 unsigned long result_ms;
132
133 sec_diff = time_a->tv_sec - time_b->tv_sec;
134 nsec_diff = time_a->tv_nsec - time_b->tv_nsec;
135
136 result_ms = sec_diff * MSEC_PER_SEC;
137 result_ms += nsec_diff / NSEC_PER_MSEC;
138 return result_ms;
139}
140
141static
142int connect_with_timeout(struct lttcomm_sock *sock)
143{
144 unsigned long timeout = lttcomm_get_network_timeout();
145 int ret, flags, connect_ret;
146 struct timespec orig_time, cur_time;
147
148 ret = fcntl(sock->fd, F_GETFL, 0);
149 if (ret == -1) {
150 PERROR("fcntl");
151 return -1;
152 }
153 flags = ret;
154
155 /* Set socket to nonblock */
156 ret = fcntl(sock->fd, F_SETFL, flags | O_NONBLOCK);
157 if (ret == -1) {
158 PERROR("fcntl");
159 return -1;
160 }
161
162 ret = clock_gettime(CLOCK_MONOTONIC, &orig_time);
163 if (ret == -1) {
164 PERROR("clock_gettime");
165 return -1;
166 }
167
168 connect_ret = connect(sock->fd,
169 (struct sockaddr *) &sock->sockaddr.addr.sin,
170 sizeof(sock->sockaddr.addr.sin));
171 if (connect_ret == -1 && errno != EAGAIN
172 && errno != EWOULDBLOCK
173 && errno != EINPROGRESS) {
174 goto error;
175 } else if (!connect_ret) {
176 /* Connect succeeded */
177 goto success;
178 }
179
180 /*
181 * Perform poll loop following EINPROGRESS recommendation from
182 * connect(2) man page.
183 */
184 do {
185 struct pollfd fds;
186
187 fds.fd = sock->fd;
188 fds.events = POLLOUT;
189 fds.revents = 0;
190 ret = poll(&fds, 1, RECONNECT_DELAY);
191 if (ret < 0) {
192 goto error;
193 } else if (ret > 0) {
194 int optval;
195 socklen_t optval_len = sizeof(optval);
196
197 if (!(fds.revents & POLLOUT)) {
198 /* Either hup or error */
199 errno = EPIPE;
200 goto error;
201 }
202 /* got something */
203 ret = getsockopt(sock->fd, SOL_SOCKET,
204 SO_ERROR, &optval, &optval_len);
205 if (ret) {
206 goto error;
207 }
208 if (!optval) {
209 connect_ret = 0;
210 goto success;
211 } else {
212 goto error;
213 }
214 }
215 /* ret == 0: timeout */
216 ret = clock_gettime(CLOCK_MONOTONIC, &cur_time);
217 if (ret == -1) {
218 PERROR("clock_gettime");
219 connect_ret = ret;
220 goto error;
221 }
222 } while (time_diff_ms(&cur_time, &orig_time) < timeout);
223
224 /* Timeout */
225 errno = ETIMEDOUT;
226 connect_ret = -1;
227
228success:
229 /* Restore initial flags */
230 ret = fcntl(sock->fd, F_SETFL, flags);
231 if (ret == -1) {
232 PERROR("fcntl");
233 /* Continue anyway */
234 }
235error:
236 return connect_ret;
237}
238
6364a07a
DG
239/*
240 * Connect PF_INET socket.
241 */
90e535ef 242LTTNG_HIDDEN
6364a07a
DG
243int lttcomm_connect_inet_sock(struct lttcomm_sock *sock)
244{
245 int ret, closeret;
246
a655f4cf
MD
247 if (lttcomm_get_network_timeout()) {
248 ret = connect_with_timeout(sock);
249 } else {
250 ret = connect_no_timeout(sock);
251 }
6364a07a 252 if (ret < 0) {
82c05d47 253 PERROR("connect");
6364a07a
DG
254 goto error_connect;
255 }
256
257 return ret;
258
259error_connect:
260 closeret = close(sock->fd);
261 if (closeret) {
262 PERROR("close inet");
263 }
264
265 return ret;
266}
267
268/*
269 * Do an accept(2) on the sock and return the new lttcomm socket. The socket
270 * MUST be bind(2) before.
271 */
90e535ef 272LTTNG_HIDDEN
6364a07a
DG
273struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock)
274{
275 int new_fd;
88a5db70 276 socklen_t len;
6364a07a 277 struct lttcomm_sock *new_sock;
71c648d8 278 unsigned long timeout;
6364a07a
DG
279
280 if (sock->proto == LTTCOMM_SOCK_UDP) {
281 /*
282 * accept(2) does not exist for UDP so simply return the passed socket.
283 */
284 new_sock = sock;
285 goto end;
286 }
287
de5e9086 288 new_sock = lttcomm_alloc_sock(sock->proto);
6364a07a
DG
289 if (new_sock == NULL) {
290 goto error;
291 }
292
88a5db70
DG
293 len = sizeof(new_sock->sockaddr.addr.sin);
294
6364a07a
DG
295 /* Blocking call */
296 new_fd = accept(sock->fd, (struct sockaddr *) &new_sock->sockaddr.addr.sin,
297 &len);
298 if (new_fd < 0) {
299 PERROR("accept inet");
300 goto error;
301 }
71c648d8
JG
302 timeout = lttcomm_get_network_timeout();
303 if (timeout) {
304 int ret;
305
306 ret = lttcomm_setsockopt_rcv_timeout(new_fd, timeout);
307 if (ret) {
475cd9fa 308 goto error_close;
71c648d8
JG
309 }
310 ret = lttcomm_setsockopt_snd_timeout(new_fd, timeout);
311 if (ret) {
475cd9fa 312 goto error_close;
71c648d8
JG
313 }
314 }
6364a07a
DG
315
316 new_sock->fd = new_fd;
de5e9086 317 new_sock->ops = &inet_ops;
6364a07a
DG
318
319end:
320 return new_sock;
321
475cd9fa
DG
322error_close:
323 if (close(new_fd) < 0) {
324 PERROR("accept inet close fd");
325 }
326
6364a07a
DG
327error:
328 free(new_sock);
329 return NULL;
330}
331
332/*
333 * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN.
334 */
90e535ef 335LTTNG_HIDDEN
6364a07a
DG
336int lttcomm_listen_inet_sock(struct lttcomm_sock *sock, int backlog)
337{
338 int ret;
339
340 if (sock->proto == LTTCOMM_SOCK_UDP) {
341 /* listen(2) does not exist for UDP so simply return success. */
342 ret = 0;
343 goto end;
344 }
345
346 /* Default listen backlog */
347 if (backlog <= 0) {
348 backlog = LTTNG_SESSIOND_COMM_MAX_LISTEN;
349 }
350
351 ret = listen(sock->fd, backlog);
352 if (ret < 0) {
353 PERROR("listen inet");
354 }
355
356end:
357 return ret;
358}
359
360/*
361 * Receive data of size len in put that data into the buf param. Using recvmsg
362 * API.
363 *
364 * Return the size of received data.
365 */
90e535ef 366LTTNG_HIDDEN
6364a07a
DG
367ssize_t lttcomm_recvmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
368 size_t len, int flags)
369{
370 struct msghdr msg;
371 struct iovec iov[1];
372 ssize_t ret = -1;
7c5aef62 373 size_t len_last;
6364a07a
DG
374
375 memset(&msg, 0, sizeof(msg));
376
377 iov[0].iov_base = buf;
378 iov[0].iov_len = len;
379 msg.msg_iov = iov;
380 msg.msg_iovlen = 1;
381
382 msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
383 msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
384
6364a07a 385 do {
7c5aef62 386 len_last = iov[0].iov_len;
6364a07a 387 ret = recvmsg(sock->fd, &msg, flags);
7c5aef62
DG
388 if (ret > 0) {
389 iov[0].iov_base += ret;
390 iov[0].iov_len -= ret;
391 assert(ret <= len_last);
392 }
393 } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR));
6364a07a
DG
394 if (ret < 0) {
395 PERROR("recvmsg inet");
7c5aef62
DG
396 } else if (ret > 0) {
397 ret = len;
6364a07a 398 }
7c5aef62 399 /* Else ret = 0 meaning an orderly shutdown. */
6364a07a
DG
400
401 return ret;
402}
403
404/*
405 * Send buf data of size len. Using sendmsg API.
406 *
407 * Return the size of sent data.
408 */
90e535ef 409LTTNG_HIDDEN
6364a07a
DG
410ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
411 size_t len, int flags)
412{
413 struct msghdr msg;
414 struct iovec iov[1];
415 ssize_t ret = -1;
416
417 memset(&msg, 0, sizeof(msg));
418
419 iov[0].iov_base = buf;
420 iov[0].iov_len = len;
421 msg.msg_iov = iov;
422 msg.msg_iovlen = 1;
423
424 switch (sock->proto) {
425 case LTTCOMM_SOCK_UDP:
426 msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
427 msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
428 break;
429 default:
430 break;
431 }
432
433 do {
434 ret = sendmsg(sock->fd, &msg, flags);
435 } while (ret < 0 && errno == EINTR);
436 if (ret < 0) {
437 /*
438 * Only warn about EPIPE when quiet mode is deactivated.
439 * We consider EPIPE as expected.
440 */
441 if (errno != EPIPE || !lttng_opt_quiet) {
442 PERROR("sendmsg inet");
443 }
444 }
445
446 return ret;
447}
448
449/*
450 * Shutdown cleanly and close.
451 */
90e535ef 452LTTNG_HIDDEN
6364a07a
DG
453int lttcomm_close_inet_sock(struct lttcomm_sock *sock)
454{
6e742359 455 int ret;
6364a07a 456
de5e9086 457 /* Don't try to close an invalid marked socket */
6364a07a
DG
458 if (sock->fd == -1) {
459 return 0;
460 }
461
6e742359
DG
462 ret = close(sock->fd);
463 if (ret) {
6364a07a
DG
464 PERROR("close inet");
465 }
466
467 /* Mark socket */
468 sock->fd = -1;
469
470 return ret;
471}
d831c249
DG
472
473/*
474 * Return value read from /proc or else 0 if value is not found.
475 */
476static unsigned long read_proc_value(const char *path)
477{
478 int ret, fd;
6cd525e8 479 ssize_t size_ret;
d831c249
DG
480 long r_val;
481 unsigned long val = 0;
482 char buf[64];
483
484 fd = open(path, O_RDONLY);
485 if (fd < 0) {
486 goto error;
487 }
488
6cd525e8
MD
489 size_ret = lttng_read(fd, buf, sizeof(buf));
490 /*
491 * Allow reading a file smaller than buf, but keep space for
492 * final \0.
493 */
494 if (size_ret < 0 || size_ret >= sizeof(buf)) {
d831c249
DG
495 PERROR("read proc failed");
496 goto error_close;
497 }
6cd525e8 498 buf[size_ret] = '\0';
d831c249
DG
499
500 errno = 0;
501 r_val = strtol(buf, NULL, 10);
502 if (errno != 0 || r_val < -1L) {
503 val = 0;
504 goto error_close;
505 } else {
506 if (r_val > 0) {
507 val = r_val;
508 }
509 }
510
511error_close:
512 ret = close(fd);
513 if (ret) {
514 PERROR("close /proc value");
515 }
516error:
517 return val;
518}
519
520LTTNG_HIDDEN
521void lttcomm_inet_init(void)
522{
18eed43f
DG
523 unsigned long syn_retries, fin_timeout, syn_timeout, env;
524
525 env = lttcomm_get_network_timeout();
526 if (env) {
527 lttcomm_inet_tcp_timeout = env;
528 goto end;
529 }
d831c249
DG
530
531 /* Assign default value and see if we can change it. */
532 lttcomm_inet_tcp_timeout = DEFAULT_INET_TCP_TIMEOUT;
533
534 syn_retries = read_proc_value(LTTCOMM_INET_PROC_SYN_RETRIES_PATH);
535 fin_timeout = read_proc_value(LTTCOMM_INET_PROC_FIN_TIMEOUT_PATH);
536
537 syn_timeout = syn_retries * LTTCOMM_INET_SYN_TIMEOUT_FACTOR;
538
539 /*
540 * Get the maximum between the two possible timeout value and use that to
541 * get the maximum with the default timeout.
542 */
543 lttcomm_inet_tcp_timeout = max_t(unsigned long,
544 max_t(unsigned long, syn_timeout, fin_timeout),
545 lttcomm_inet_tcp_timeout);
546
18eed43f 547end:
d831c249
DG
548 DBG("TCP inet operation timeout set to %lu sec", lttcomm_inet_tcp_timeout);
549}
This page took 0.09057 seconds and 4 git commands to generate.