X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fcommon%2Funix.c;h=df92b7a0698ef699ed31a5bbc82b6741362cedfb;hb=44c180cac90d0c2a0486d6bc1aeaf0f1538c1075;hp=2f4df68e627bd37a0f6fc84fdfb868cc02de6bc1;hpb=c72435ad89dc397f89a30faea35274074fbb3047;p=lttng-tools.git diff --git a/src/common/unix.c b/src/common/unix.c index 2f4df68e6..df92b7a06 100644 --- a/src/common/unix.c +++ b/src/common/unix.c @@ -1,19 +1,9 @@ /* - * Copyright (C) 2011 - David Goulet - * Mathieu Desnoyers + * Copyright (C) 2011 David Goulet + * Copyright (C) 2011 Mathieu Desnoyers * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License, version 2 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define _LGPL_SOURCE @@ -220,6 +210,9 @@ ssize_t lttcomm_recv_unix_sock(int sock, void *buf, size_t len) * Receive data of size len in put that data into the buf param. Using recvmsg * API. Only use with sockets set in non-blocking mode. * + * NOTE: EPIPE errors are NOT reported. This call expects the socket to be in a + * poll set. The poll loop will handle the EPIPE original cause. + * * Return the size of received data. */ LTTNG_HIDDEN @@ -243,13 +236,20 @@ retry: goto retry; } else { /* - * Only warn about EPIPE when quiet mode is - * deactivated. - * We consider EPIPE as expected. + * We consider EPIPE and EAGAIN/EWOULDBLOCK as expected. */ - if (errno != EPIPE || !lttng_opt_quiet) { - PERROR("recvmsg"); + if (errno == EAGAIN || errno == EWOULDBLOCK || + errno == EPIPE) { + /* + * Nothing was recv. + */ + ret = 0; + goto end; } + + /* Unexpected error */ + PERROR("recvmsg"); + ret = -1; goto end; } } @@ -308,6 +308,9 @@ end: * of the function is that this one does not retry to send on partial sends, * except if the interruption was caused by a signal (EINTR). * + * NOTE: EPIPE errors are NOT reported. This call expects the socket to be in a + * poll set. The poll loop will handle the EPIPE original cause. + * * Return the size of sent data. */ LTTNG_HIDDEN @@ -331,13 +334,21 @@ retry: goto retry; } else { /* - * Only warn about EPIPE when quiet mode is - * deactivated. - * We consider EPIPE as expected. + * We consider EPIPE and EAGAIN/EWOULDBLOCK as expected. */ - if (errno != EPIPE || !lttng_opt_quiet) { - PERROR("sendmsg"); + if (errno == EAGAIN || errno == EWOULDBLOCK || + errno == EPIPE) { + /* + * This can happen in non blocking mode. + * Nothing was sent. + */ + ret = 0; + goto end; } + + /* Unexpected error */ + PERROR("sendmsg"); + ret = -1; goto end; } } @@ -374,7 +385,7 @@ int lttcomm_close_unix_sock(int sock) * Returns the size of data sent, or negative error value. */ LTTNG_HIDDEN -ssize_t lttcomm_send_fds_unix_sock(int sock, int *fds, size_t nb_fd) +ssize_t lttcomm_send_fds_unix_sock(int sock, const int *fds, size_t nb_fd) { struct msghdr msg; struct cmsghdr *cmptr; @@ -385,7 +396,7 @@ ssize_t lttcomm_send_fds_unix_sock(int sock, int *fds, size_t nb_fd) char dummy = 0; memset(&msg, 0, sizeof(msg)); - memset(tmp, 0, CMSG_SPACE(sizeof_fds) * sizeof(char)); + memset(tmp, 0, sizeof(tmp)); if (nb_fd > LTTCOMM_MAX_SEND_FDS) return -EINVAL; @@ -397,6 +408,7 @@ ssize_t lttcomm_send_fds_unix_sock(int sock, int *fds, size_t nb_fd) if (!cmptr) { return -1; } + cmptr->cmsg_level = SOL_SOCKET; cmptr->cmsg_type = SCM_RIGHTS; cmptr->cmsg_len = CMSG_LEN(sizeof_fds); @@ -439,7 +451,15 @@ ssize_t lttcomm_recv_fds_unix_sock(int sock, int *fds, size_t nb_fd) ssize_t ret = 0; struct cmsghdr *cmsg; size_t sizeof_fds = nb_fd * sizeof(int); - char recv_fd[CMSG_SPACE(sizeof_fds)]; + +#ifdef __linux__ +/* Account for the struct ucred cmsg in the buffer size */ +#define LTTNG_SOCK_RECV_FDS_BUF_SIZE CMSG_SPACE(sizeof_fds) + CMSG_SPACE(sizeof(struct ucred)) +#else +#define LTTNG_SOCK_RECV_FDS_BUF_SIZE CMSG_SPACE(sizeof_fds) +#endif /* __linux__ */ + + char recv_buf[LTTNG_SOCK_RECV_FDS_BUF_SIZE]; struct msghdr msg; char dummy; @@ -450,8 +470,15 @@ ssize_t lttcomm_recv_fds_unix_sock(int sock, int *fds, size_t nb_fd) iov[0].iov_len = 1; msg.msg_iov = iov; msg.msg_iovlen = 1; - msg.msg_control = recv_fd; - msg.msg_controllen = sizeof(recv_fd); + + cmsg = (struct cmsghdr *) recv_buf; + cmsg->cmsg_len = CMSG_LEN(sizeof_fds); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + + msg.msg_control = cmsg; + msg.msg_controllen = CMSG_LEN(sizeof(recv_buf)); + msg.msg_flags = 0; do { ret = recvmsg(sock, &msg, 0); @@ -460,35 +487,59 @@ ssize_t lttcomm_recv_fds_unix_sock(int sock, int *fds, size_t nb_fd) PERROR("recvmsg fds"); goto end; } + if (ret != 1) { fprintf(stderr, "Error: Received %zd bytes, expected %d\n", ret, 1); goto end; } + if (msg.msg_flags & MSG_CTRUNC) { fprintf(stderr, "Error: Control message truncated.\n"); ret = -1; goto end; } - cmsg = CMSG_FIRSTHDR(&msg); - if (!cmsg) { - fprintf(stderr, "Error: Invalid control message header\n"); - ret = -1; - goto end; - } - if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) { - fprintf(stderr, "Didn't received any fd\n"); - ret = -1; - goto end; - } - if (cmsg->cmsg_len != CMSG_LEN(sizeof_fds)) { - fprintf(stderr, "Error: Received %zu bytes of ancillary data, expected %zu\n", - (size_t) cmsg->cmsg_len, (size_t) CMSG_LEN(sizeof_fds)); - ret = -1; - goto end; + + /* + * If the socket was configured with SO_PASSCRED, the kernel will add a + * control message (cmsg) to the ancillary data of the unix socket. We + * need to expect a cmsg of the SCM_CREDENTIALS as the first control + * message. + */ + for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) { + if (cmsg->cmsg_level != SOL_SOCKET) { + fprintf(stderr, "Error: The socket needs to be of type SOL_SOCKET\n"); + ret = -1; + goto end; + } + if (cmsg->cmsg_type == SCM_RIGHTS) { + /* + * We found the controle message for file descriptors, + * now copy the fds to the fds ptr and return success. + */ + if (cmsg->cmsg_len != CMSG_LEN(sizeof_fds)) { + fprintf(stderr, "Error: Received %zu bytes of" + "ancillary data for FDs, expected %zu\n", + (size_t) cmsg->cmsg_len, + (size_t) CMSG_LEN(sizeof_fds)); + ret = -1; + goto end; + } + memcpy(fds, CMSG_DATA(cmsg), sizeof_fds); + ret = sizeof_fds; + goto end; + } +#ifdef __linux__ + if (cmsg->cmsg_type == SCM_CREDENTIALS) { + /* + * Expect credentials to be sent when expecting fds even + * if no credential were include in the send(). The + * kernel adds them... + */ + ret = -1; + } +#endif /* __linux__ */ } - memcpy(fds, CMSG_DATA(cmsg), sizeof_fds); - ret = sizeof_fds; end: return ret; }