Fix: possible out of bounds write in enable-event
[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/common.h>
30
31 #include "inet.h"
32
33 /*
34 * INET protocol operations.
35 */
36 static const struct lttcomm_proto_ops inet_ops = {
37 .bind = lttcomm_bind_inet_sock,
38 .close = lttcomm_close_inet_sock,
39 .connect = lttcomm_connect_inet_sock,
40 .accept = lttcomm_accept_inet_sock,
41 .listen = lttcomm_listen_inet_sock,
42 .recvmsg = lttcomm_recvmsg_inet_sock,
43 .sendmsg = lttcomm_sendmsg_inet_sock,
44 };
45
46 /*
47 * Creates an PF_INET socket.
48 */
49 LTTNG_HIDDEN
50 int lttcomm_create_inet_sock(struct lttcomm_sock *sock, int type, int proto)
51 {
52 int val = 1, ret;
53
54 /* Create server socket */
55 if ((sock->fd = socket(PF_INET, type, proto)) < 0) {
56 PERROR("socket inet");
57 goto error;
58 }
59
60 sock->ops = &inet_ops;
61
62 /*
63 * Set socket option to reuse the address.
64 */
65 ret = setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
66 if (ret < 0) {
67 PERROR("setsockopt inet");
68 goto error;
69 }
70
71 return 0;
72
73 error:
74 return -1;
75 }
76
77 /*
78 * Bind socket and return.
79 */
80 LTTNG_HIDDEN
81 int lttcomm_bind_inet_sock(struct lttcomm_sock *sock)
82 {
83 int ret;
84
85 ret = bind(sock->fd, &sock->sockaddr.addr.sin,
86 sizeof(sock->sockaddr.addr.sin));
87 if (ret < 0) {
88 PERROR("bind inet");
89 }
90
91 return ret;
92 }
93
94 /*
95 * Connect PF_INET socket.
96 */
97 LTTNG_HIDDEN
98 int lttcomm_connect_inet_sock(struct lttcomm_sock *sock)
99 {
100 int ret, closeret;
101
102 ret = connect(sock->fd, (struct sockaddr *) &sock->sockaddr.addr.sin,
103 sizeof(sock->sockaddr.addr.sin));
104 if (ret < 0) {
105 /*
106 * Don't print message on connect error, because connect is used in
107 * normal execution to detect if sessiond is alive.
108 */
109 goto error_connect;
110 }
111
112 return ret;
113
114 error_connect:
115 closeret = close(sock->fd);
116 if (closeret) {
117 PERROR("close inet");
118 }
119
120 return ret;
121 }
122
123 /*
124 * Do an accept(2) on the sock and return the new lttcomm socket. The socket
125 * MUST be bind(2) before.
126 */
127 LTTNG_HIDDEN
128 struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock)
129 {
130 int new_fd;
131 socklen_t len;
132 struct lttcomm_sock *new_sock;
133
134 if (sock->proto == LTTCOMM_SOCK_UDP) {
135 /*
136 * accept(2) does not exist for UDP so simply return the passed socket.
137 */
138 new_sock = sock;
139 goto end;
140 }
141
142 new_sock = lttcomm_alloc_sock(sock->proto);
143 if (new_sock == NULL) {
144 goto error;
145 }
146
147 len = sizeof(new_sock->sockaddr.addr.sin);
148
149 /* Blocking call */
150 new_fd = accept(sock->fd, (struct sockaddr *) &new_sock->sockaddr.addr.sin,
151 &len);
152 if (new_fd < 0) {
153 PERROR("accept inet");
154 goto error;
155 }
156
157 new_sock->fd = new_fd;
158 new_sock->ops = &inet_ops;
159
160 end:
161 return new_sock;
162
163 error:
164 free(new_sock);
165 return NULL;
166 }
167
168 /*
169 * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN.
170 */
171 LTTNG_HIDDEN
172 int lttcomm_listen_inet_sock(struct lttcomm_sock *sock, int backlog)
173 {
174 int ret;
175
176 if (sock->proto == LTTCOMM_SOCK_UDP) {
177 /* listen(2) does not exist for UDP so simply return success. */
178 ret = 0;
179 goto end;
180 }
181
182 /* Default listen backlog */
183 if (backlog <= 0) {
184 backlog = LTTNG_SESSIOND_COMM_MAX_LISTEN;
185 }
186
187 ret = listen(sock->fd, backlog);
188 if (ret < 0) {
189 PERROR("listen inet");
190 }
191
192 end:
193 return ret;
194 }
195
196 /*
197 * Receive data of size len in put that data into the buf param. Using recvmsg
198 * API.
199 *
200 * Return the size of received data.
201 */
202 LTTNG_HIDDEN
203 ssize_t lttcomm_recvmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
204 size_t len, int flags)
205 {
206 struct msghdr msg;
207 struct iovec iov[1];
208 ssize_t ret = -1;
209 size_t len_last;
210
211 memset(&msg, 0, sizeof(msg));
212
213 iov[0].iov_base = buf;
214 iov[0].iov_len = len;
215 msg.msg_iov = iov;
216 msg.msg_iovlen = 1;
217
218 msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
219 msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
220
221 do {
222 len_last = iov[0].iov_len;
223 ret = recvmsg(sock->fd, &msg, flags);
224 if (ret > 0) {
225 iov[0].iov_base += ret;
226 iov[0].iov_len -= ret;
227 assert(ret <= len_last);
228 }
229 } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR));
230 if (ret < 0) {
231 PERROR("recvmsg inet");
232 } else if (ret > 0) {
233 ret = len;
234 }
235 /* Else ret = 0 meaning an orderly shutdown. */
236
237 return ret;
238 }
239
240 /*
241 * Send buf data of size len. Using sendmsg API.
242 *
243 * Return the size of sent data.
244 */
245 LTTNG_HIDDEN
246 ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
247 size_t len, int flags)
248 {
249 struct msghdr msg;
250 struct iovec iov[1];
251 ssize_t ret = -1;
252
253 memset(&msg, 0, sizeof(msg));
254
255 iov[0].iov_base = buf;
256 iov[0].iov_len = len;
257 msg.msg_iov = iov;
258 msg.msg_iovlen = 1;
259
260 switch (sock->proto) {
261 case LTTCOMM_SOCK_UDP:
262 msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
263 msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
264 break;
265 default:
266 break;
267 }
268
269 do {
270 ret = sendmsg(sock->fd, &msg, flags);
271 } while (ret < 0 && errno == EINTR);
272 if (ret < 0) {
273 /*
274 * Only warn about EPIPE when quiet mode is deactivated.
275 * We consider EPIPE as expected.
276 */
277 if (errno != EPIPE || !lttng_opt_quiet) {
278 PERROR("sendmsg inet");
279 }
280 }
281
282 return ret;
283 }
284
285 /*
286 * Shutdown cleanly and close.
287 */
288 LTTNG_HIDDEN
289 int lttcomm_close_inet_sock(struct lttcomm_sock *sock)
290 {
291 int ret;
292
293 /* Don't try to close an invalid marked socket */
294 if (sock->fd == -1) {
295 return 0;
296 }
297
298 ret = close(sock->fd);
299 if (ret) {
300 PERROR("close inet");
301 }
302
303 /* Mark socket */
304 sock->fd = -1;
305
306 return ret;
307 }
This page took 0.035533 seconds and 5 git commands to generate.