Commit | Line | Data |
---|---|---|
c39c72ee PMF |
1 | /* Copyright (C) 2009 Pierre-Marc Fournier |
2 | * | |
3 | * This library is free software; you can redistribute it and/or | |
4 | * modify it under the terms of the GNU Lesser General Public | |
5 | * License as published by the Free Software Foundation; either | |
6 | * version 2.1 of the License, or (at your option) any later version. | |
7 | * | |
8 | * This library is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
11 | * Lesser General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU Lesser General Public | |
14 | * License along with this library; if not, write to the Free Software | |
15 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
16 | */ | |
17 | ||
93e5ce29 PMF |
18 | /* API used by UST components to communicate with each other via sockets. */ |
19 | ||
d0b5f2b9 | 20 | #define _GNU_SOURCE |
f446d1cb | 21 | #include <dirent.h> |
f9e5ce61 PMF |
22 | #include <sys/types.h> |
23 | #include <signal.h> | |
24 | #include <errno.h> | |
25 | #include <sys/socket.h> | |
26 | #include <sys/un.h> | |
d0b5f2b9 | 27 | #include <unistd.h> |
aca1ad90 | 28 | #include <poll.h> |
4723ca09 | 29 | #include <sys/epoll.h> |
803a4f58 | 30 | #include <sys/stat.h> |
f9e5ce61 PMF |
31 | |
32 | #include <stdio.h> | |
33 | #include <stdlib.h> | |
d0b5f2b9 | 34 | #include <string.h> |
b0540e11 | 35 | #include <execinfo.h> |
d0b5f2b9 PMF |
36 | |
37 | #include "ustcomm.h" | |
6af64c43 | 38 | #include "usterr.h" |
2dae156b | 39 | #include "share.h" |
f9e5ce61 | 40 | |
d6d27063 PMF |
41 | static int mkdir_p(const char *path, mode_t mode) |
42 | { | |
c555b133 | 43 | const char *path_p; |
d6d27063 PMF |
44 | char *tmp; |
45 | ||
46 | int retval = 0; | |
47 | int result; | |
18baca84 | 48 | mode_t old_umask; |
d6d27063 | 49 | |
7032c7d3 | 50 | tmp = zmalloc(strlen(path) + 1); |
d6d27063 PMF |
51 | if (tmp == NULL) |
52 | return -1; | |
53 | ||
54 | /* skip first / */ | |
55 | path_p = path+1; | |
56 | ||
18baca84 | 57 | old_umask = umask(0); |
d6d27063 PMF |
58 | for(;;) { |
59 | while (*path_p != '/') { | |
60 | if(*path_p == 0) | |
61 | break; | |
62 | ++path_p; | |
63 | } | |
64 | if (*path_p == '/') { | |
65 | strncpy(tmp, path, path_p - path); | |
66 | tmp[path_p-path] = '\0'; | |
67 | if (tmp[path_p - path - 1] != '/') { | |
68 | result = mkdir(tmp, mode); | |
69 | if(result == -1) { | |
70 | if (!(errno == EEXIST || errno == EACCES || errno == EROFS)) { | |
71 | /* Then this is a real error */ | |
72 | retval = -1; | |
73 | break; | |
74 | } | |
75 | } | |
76 | } | |
77 | /* pass / */ | |
78 | path_p++; | |
79 | } else { | |
80 | /* last component */ | |
81 | result = mkdir(path, mode); | |
82 | if (result == -1) | |
83 | retval = -1; | |
84 | break; | |
85 | } | |
86 | } | |
87 | ||
88 | free(tmp); | |
18baca84 | 89 | umask(old_umask); |
d6d27063 PMF |
90 | return retval; |
91 | } | |
92 | ||
4723ca09 NC |
93 | static struct sockaddr_un * create_sock_addr(const char *name, |
94 | size_t *sock_addr_size) | |
f9e5ce61 | 95 | { |
4723ca09 NC |
96 | struct sockaddr_un * addr; |
97 | size_t alloc_size; | |
f9e5ce61 | 98 | |
4723ca09 NC |
99 | alloc_size = (size_t) (((struct sockaddr_un *) 0)->sun_path) + |
100 | strlen(name) + 1; | |
5932431b | 101 | |
4723ca09 NC |
102 | addr = malloc(alloc_size); |
103 | if (addr < 0) { | |
104 | ERR("allocating addr failed"); | |
105 | return NULL; | |
106 | } | |
ab33e65c | 107 | |
4723ca09 NC |
108 | addr->sun_family = AF_UNIX; |
109 | strcpy(addr->sun_path, name); | |
110 | ||
111 | *sock_addr_size = alloc_size; | |
112 | ||
113 | return addr; | |
114 | } | |
2dae156b | 115 | |
4723ca09 | 116 | struct ustcomm_sock * ustcomm_init_sock(int fd, int epoll_fd, |
0222e121 | 117 | struct cds_list_head *list) |
811e4b93 | 118 | { |
4723ca09 NC |
119 | struct epoll_event ev; |
120 | struct ustcomm_sock *sock; | |
811e4b93 | 121 | |
4723ca09 NC |
122 | sock = malloc(sizeof(struct ustcomm_sock)); |
123 | if (!sock) { | |
124 | perror("malloc: couldn't allocate ustcomm_sock"); | |
125 | return NULL; | |
811e4b93 | 126 | } |
4723ca09 NC |
127 | |
128 | ev.events = EPOLLIN; | |
129 | ev.data.ptr = sock; | |
130 | sock->fd = fd; | |
131 | ||
132 | if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock->fd, &ev) == -1) { | |
133 | perror("epoll_ctl: failed to add socket\n"); | |
134 | free(sock); | |
135 | return NULL; | |
688760ef | 136 | } |
811e4b93 | 137 | |
4723ca09 NC |
138 | sock->epoll_fd = epoll_fd; |
139 | if (list) { | |
0222e121 | 140 | cds_list_add(&sock->list, list); |
4723ca09 | 141 | } else { |
0222e121 | 142 | CDS_INIT_LIST_HEAD(&sock->list); |
4723ca09 NC |
143 | } |
144 | ||
145 | return sock; | |
811e4b93 PMF |
146 | } |
147 | ||
4723ca09 NC |
148 | void ustcomm_del_sock(struct ustcomm_sock *sock, int keep_in_epoll) |
149 | { | |
0222e121 | 150 | cds_list_del(&sock->list); |
4723ca09 NC |
151 | if (!keep_in_epoll) { |
152 | if (epoll_ctl(sock->epoll_fd, EPOLL_CTL_DEL, sock->fd, NULL) == -1) { | |
153 | PERROR("epoll_ctl: failed to delete socket"); | |
154 | } | |
155 | } | |
156 | close(sock->fd); | |
157 | free(sock); | |
158 | } | |
b0540e11 | 159 | |
4723ca09 NC |
160 | struct ustcomm_sock * ustcomm_init_named_socket(const char *name, |
161 | int epoll_fd) | |
b0540e11 | 162 | { |
b0540e11 | 163 | int result; |
4723ca09 NC |
164 | int fd; |
165 | size_t sock_addr_size; | |
166 | struct sockaddr_un * addr; | |
167 | struct ustcomm_sock *sock; | |
c97d4437 | 168 | |
4723ca09 NC |
169 | fd = socket(PF_UNIX, SOCK_STREAM, 0); |
170 | if(fd == -1) { | |
171 | PERROR("socket"); | |
172 | return NULL; | |
c97d4437 | 173 | } |
b0540e11 | 174 | |
4723ca09 NC |
175 | addr = create_sock_addr(name, &sock_addr_size); |
176 | if (addr == NULL) { | |
177 | ERR("allocating addr, UST thread bailing"); | |
178 | goto close_sock; | |
b0540e11 PMF |
179 | } |
180 | ||
4723ca09 NC |
181 | result = access(name, F_OK); |
182 | if(result == 0) { | |
183 | /* file exists */ | |
184 | result = unlink(name); | |
185 | if(result == -1) { | |
186 | PERROR("unlink of socket file"); | |
187 | goto free_addr; | |
188 | } | |
189 | DBG("socket already exists; overwriting"); | |
08b8805e | 190 | } |
b0540e11 | 191 | |
4723ca09 | 192 | result = bind(fd, (struct sockaddr *)addr, sock_addr_size); |
08230db7 | 193 | if(result == -1) { |
4723ca09 NC |
194 | PERROR("bind"); |
195 | goto free_addr; | |
08230db7 PMF |
196 | } |
197 | ||
4723ca09 | 198 | result = listen(fd, 1); |
08230db7 | 199 | if(result == -1) { |
4723ca09 NC |
200 | PERROR("listen"); |
201 | goto free_addr; | |
08230db7 PMF |
202 | } |
203 | ||
4723ca09 NC |
204 | sock = ustcomm_init_sock(fd, epoll_fd, |
205 | NULL); | |
206 | if (!sock) { | |
207 | ERR("failed to create ustcomm_sock"); | |
208 | goto free_addr; | |
209 | } | |
b0540e11 | 210 | |
4723ca09 | 211 | free(addr); |
b0540e11 | 212 | |
4723ca09 | 213 | return sock; |
811e4b93 | 214 | |
4723ca09 NC |
215 | free_addr: |
216 | free(addr); | |
217 | close_sock: | |
218 | close(fd); | |
2dae156b | 219 | |
4723ca09 NC |
220 | return NULL; |
221 | } | |
222 | ||
223 | void ustcomm_del_named_sock(struct ustcomm_sock *sock, | |
224 | int keep_socket_file) | |
d0b5f2b9 | 225 | { |
4723ca09 NC |
226 | int result, fd; |
227 | struct stat st; | |
228 | struct sockaddr dummy; | |
229 | struct sockaddr_un *sockaddr = NULL; | |
230 | int alloc_size; | |
d0b5f2b9 | 231 | |
4723ca09 | 232 | fd = sock->fd; |
b02e31e5 | 233 | |
4723ca09 | 234 | if(!keep_socket_file) { |
5932431b | 235 | |
4723ca09 NC |
236 | /* Get the socket name */ |
237 | alloc_size = sizeof(dummy); | |
238 | if (getsockname(fd, &dummy, (socklen_t *)&alloc_size) < 0) { | |
239 | PERROR("getsockname failed"); | |
240 | goto del_sock; | |
2dae156b | 241 | } |
b0540e11 | 242 | |
4723ca09 NC |
243 | sockaddr = zmalloc(alloc_size); |
244 | if (!sockaddr) { | |
245 | ERR("failed to allocate sockaddr"); | |
246 | goto del_sock; | |
5932431b PMF |
247 | } |
248 | ||
4723ca09 NC |
249 | if (getsockname(fd, sockaddr, (socklen_t *)&alloc_size) < 0) { |
250 | PERROR("getsockname failed"); | |
251 | goto free_sockaddr; | |
5932431b PMF |
252 | } |
253 | ||
4723ca09 NC |
254 | /* Destroy socket */ |
255 | result = stat(sockaddr->sun_path, &st); | |
256 | if(result < 0) { | |
257 | PERROR("stat (%s)", sockaddr->sun_path); | |
258 | goto free_sockaddr; | |
2dae156b | 259 | } |
4723ca09 NC |
260 | |
261 | /* Paranoid check before deleting. */ | |
262 | result = S_ISSOCK(st.st_mode); | |
263 | if(!result) { | |
264 | ERR("The socket we are about to delete is not a socket."); | |
265 | goto free_sockaddr; | |
2dae156b PMF |
266 | } |
267 | ||
4723ca09 NC |
268 | result = unlink(sockaddr->sun_path); |
269 | if(result < 0) { | |
270 | PERROR("unlink"); | |
271 | } | |
2dae156b | 272 | } |
b0540e11 | 273 | |
4723ca09 NC |
274 | free_sockaddr: |
275 | free(sockaddr); | |
2dae156b | 276 | |
4723ca09 NC |
277 | del_sock: |
278 | ustcomm_del_sock(sock, keep_socket_file); | |
d0b5f2b9 PMF |
279 | } |
280 | ||
72098143 NC |
281 | int ustcomm_recv_alloc(int sock, |
282 | struct ustcomm_header *header, | |
283 | char **data) { | |
284 | int result; | |
285 | struct ustcomm_header peek_header; | |
286 | struct iovec iov[2]; | |
287 | struct msghdr msg; | |
5932431b | 288 | |
72098143 NC |
289 | /* Just to make the caller fail hard */ |
290 | *data = NULL; | |
811e4b93 | 291 | |
72098143 NC |
292 | result = recv(sock, &peek_header, sizeof(peek_header), |
293 | MSG_PEEK | MSG_WAITALL); | |
294 | if (result <= 0) { | |
295 | if(errno == ECONNRESET) { | |
296 | return 0; | |
297 | } else if (errno == EINTR) { | |
298 | return -1; | |
299 | } else if (result < 0) { | |
300 | PERROR("recv"); | |
301 | return -1; | |
302 | } | |
303 | return 0; | |
811e4b93 PMF |
304 | } |
305 | ||
72098143 | 306 | memset(&msg, 0, sizeof(msg)); |
99b72dc0 | 307 | |
72098143 NC |
308 | iov[0].iov_base = (char *)header; |
309 | iov[0].iov_len = sizeof(struct ustcomm_header); | |
310 | ||
311 | msg.msg_iov = iov; | |
312 | msg.msg_iovlen = 1; | |
313 | ||
314 | if (peek_header.size) { | |
315 | *data = zmalloc(peek_header.size); | |
316 | if (!*data) { | |
317 | return -ENOMEM; | |
318 | } | |
319 | ||
320 | iov[1].iov_base = *data; | |
321 | iov[1].iov_len = peek_header.size; | |
322 | ||
323 | msg.msg_iovlen++; | |
4723ca09 | 324 | } |
99b72dc0 | 325 | |
72098143 | 326 | result = recvmsg(sock, &msg, MSG_WAITALL); |
4723ca09 | 327 | if (result < 0) { |
72098143 NC |
328 | free(*data); |
329 | PERROR("recvmsg failed"); | |
99b72dc0 PMF |
330 | } |
331 | ||
72098143 | 332 | return result; |
99b72dc0 PMF |
333 | } |
334 | ||
4723ca09 NC |
335 | /* returns 1 to indicate a message was received |
336 | * returns 0 to indicate no message was received (end of stream) | |
688760ef PMF |
337 | * returns -1 to indicate an error |
338 | */ | |
4723ca09 NC |
339 | int ustcomm_recv_fd(int sock, |
340 | struct ustcomm_header *header, | |
72098143 | 341 | char *data, int *fd) |
b0540e11 | 342 | { |
aca1ad90 | 343 | int result; |
4723ca09 NC |
344 | struct ustcomm_header peek_header; |
345 | struct iovec iov[2]; | |
346 | struct msghdr msg; | |
347 | struct cmsghdr *cmsg; | |
348 | char buf[CMSG_SPACE(sizeof(int))]; | |
349 | ||
350 | result = recv(sock, &peek_header, sizeof(peek_header), | |
351 | MSG_PEEK | MSG_WAITALL); | |
352 | if (result <= 0) { | |
353 | if(errno == ECONNRESET) { | |
354 | return 0; | |
355 | } else if (errno == EINTR) { | |
356 | return -1; | |
357 | } else if (result < 0) { | |
358 | PERROR("recv"); | |
aca1ad90 PMF |
359 | return -1; |
360 | } | |
4723ca09 NC |
361 | return 0; |
362 | } | |
aca1ad90 | 363 | |
4723ca09 | 364 | memset(&msg, 0, sizeof(msg)); |
5932431b | 365 | |
4723ca09 NC |
366 | iov[0].iov_base = (char *)header; |
367 | iov[0].iov_len = sizeof(struct ustcomm_header); | |
aca1ad90 | 368 | |
4723ca09 NC |
369 | msg.msg_iov = iov; |
370 | msg.msg_iovlen = 1; | |
aca1ad90 | 371 | |
72098143 NC |
372 | if (peek_header.size && data) { |
373 | if (peek_header.size < 0 || | |
374 | peek_header.size > USTCOMM_DATA_SIZE) { | |
fbae86d6 | 375 | ERR("big peek header! %ld", peek_header.size); |
72098143 | 376 | return 0; |
2a79ceeb | 377 | } |
688760ef | 378 | |
72098143 | 379 | iov[1].iov_base = data; |
4723ca09 | 380 | iov[1].iov_len = peek_header.size; |
aca1ad90 | 381 | |
4723ca09 NC |
382 | msg.msg_iovlen++; |
383 | } | |
aca1ad90 | 384 | |
4723ca09 NC |
385 | if (fd && peek_header.fd_included) { |
386 | msg.msg_control = buf; | |
387 | msg.msg_controllen = sizeof(buf); | |
388 | } | |
aca1ad90 | 389 | |
72098143 | 390 | result = recvmsg(sock, &msg, MSG_WAITALL); |
4723ca09 | 391 | if (result <= 0) { |
72098143 NC |
392 | if (result < 0) { |
393 | PERROR("recvmsg failed"); | |
aca1ad90 | 394 | } |
72098143 | 395 | return result; |
4723ca09 NC |
396 | } |
397 | ||
398 | if (fd && peek_header.fd_included) { | |
399 | cmsg = CMSG_FIRSTHDR(&msg); | |
400 | result = 0; | |
401 | while (cmsg != NULL) { | |
402 | if (cmsg->cmsg_level == SOL_SOCKET | |
403 | && cmsg->cmsg_type == SCM_RIGHTS) { | |
404 | *fd = *(int *) CMSG_DATA(cmsg); | |
405 | result = 1; | |
406 | break; | |
aca1ad90 | 407 | } |
4723ca09 NC |
408 | cmsg = CMSG_NXTHDR(&msg, cmsg); |
409 | } | |
410 | if (!result) { | |
411 | ERR("Failed to receive file descriptor\n"); | |
aca1ad90 | 412 | } |
aca1ad90 PMF |
413 | } |
414 | ||
4723ca09 | 415 | return 1; |
b0540e11 PMF |
416 | } |
417 | ||
4723ca09 NC |
418 | int ustcomm_recv(int sock, |
419 | struct ustcomm_header *header, | |
72098143 | 420 | char *data) |
811e4b93 | 421 | { |
4723ca09 | 422 | return ustcomm_recv_fd(sock, header, data, NULL); |
811e4b93 PMF |
423 | } |
424 | ||
4723ca09 | 425 | |
4723ca09 NC |
426 | int ustcomm_send_fd(int sock, |
427 | const struct ustcomm_header *header, | |
428 | const char *data, | |
429 | int *fd) | |
46ef48cd | 430 | { |
4723ca09 NC |
431 | struct iovec iov[2]; |
432 | struct msghdr msg; | |
433 | int result; | |
434 | struct cmsghdr *cmsg; | |
435 | char buf[CMSG_SPACE(sizeof(int))]; | |
436 | ||
437 | memset(&msg, 0, sizeof(msg)); | |
438 | ||
439 | iov[0].iov_base = (char *)header; | |
440 | iov[0].iov_len = sizeof(struct ustcomm_header); | |
441 | ||
442 | msg.msg_iov = iov; | |
443 | msg.msg_iovlen = 1; | |
444 | ||
72098143 | 445 | if (header->size && data) { |
4723ca09 NC |
446 | iov[1].iov_base = (char *)data; |
447 | iov[1].iov_len = header->size; | |
448 | ||
449 | msg.msg_iovlen++; | |
46ef48cd | 450 | |
46ef48cd PMF |
451 | } |
452 | ||
4723ca09 NC |
453 | if (fd && header->fd_included) { |
454 | msg.msg_control = buf; | |
455 | msg.msg_controllen = sizeof(buf); | |
456 | cmsg = CMSG_FIRSTHDR(&msg); | |
457 | cmsg->cmsg_level = SOL_SOCKET; | |
458 | cmsg->cmsg_type = SCM_RIGHTS; | |
459 | cmsg->cmsg_len = CMSG_LEN(sizeof(int)); | |
460 | *(int *) CMSG_DATA(cmsg) = *fd; | |
461 | msg.msg_controllen = cmsg->cmsg_len; | |
462 | } | |
463 | ||
464 | result = sendmsg(sock, &msg, MSG_NOSIGNAL); | |
465 | if (result < 0 && errno != EPIPE) { | |
466 | PERROR("sendmsg failed"); | |
467 | } | |
468 | return result; | |
46ef48cd PMF |
469 | } |
470 | ||
4723ca09 NC |
471 | int ustcomm_send(int sock, |
472 | const struct ustcomm_header *header, | |
473 | const char *data) | |
d0b5f2b9 | 474 | { |
4723ca09 NC |
475 | return ustcomm_send_fd(sock, header, data, NULL); |
476 | } | |
d0b5f2b9 | 477 | |
72098143 NC |
478 | int ustcomm_req(int sock, |
479 | const struct ustcomm_header *req_header, | |
480 | const char *req_data, | |
481 | struct ustcomm_header *res_header, | |
482 | char *res_data) | |
4723ca09 NC |
483 | { |
484 | int result; | |
aca1ad90 | 485 | |
72098143 | 486 | result = ustcomm_send(sock, req_header, req_data); |
4723ca09 NC |
487 | if ( result <= 0) { |
488 | return result; | |
b0540e11 | 489 | } |
d0b5f2b9 | 490 | |
72098143 | 491 | return ustcomm_recv(sock, res_header, res_data); |
4e2a8808 PMF |
492 | } |
493 | ||
2a79ceeb PMF |
494 | /* Return value: |
495 | * 0: success | |
496 | * -1: error | |
497 | */ | |
498 | ||
4723ca09 | 499 | int ustcomm_connect_path(const char *name, int *connection_fd) |
4e2a8808 | 500 | { |
4723ca09 NC |
501 | int result, fd; |
502 | size_t sock_addr_size; | |
503 | struct sockaddr_un *addr; | |
4e2a8808 | 504 | |
4723ca09 NC |
505 | fd = socket(PF_UNIX, SOCK_STREAM, 0); |
506 | if(fd == -1) { | |
4e2a8808 PMF |
507 | PERROR("socket"); |
508 | return -1; | |
509 | } | |
510 | ||
4723ca09 NC |
511 | addr = create_sock_addr(name, &sock_addr_size); |
512 | if (addr == NULL) { | |
513 | ERR("allocating addr failed"); | |
514 | goto close_sock; | |
52c51a47 | 515 | } |
4e2a8808 | 516 | |
4723ca09 | 517 | result = connect(fd, (struct sockaddr *)addr, sock_addr_size); |
4e2a8808 | 518 | if(result == -1) { |
4723ca09 NC |
519 | PERROR("connect (path=%s)", name); |
520 | goto free_sock_addr; | |
4e2a8808 PMF |
521 | } |
522 | ||
4723ca09 NC |
523 | *connection_fd = fd; |
524 | ||
525 | free(addr); | |
4e2a8808 PMF |
526 | |
527 | return 0; | |
4e2a8808 | 528 | |
4723ca09 NC |
529 | free_sock_addr: |
530 | free(addr); | |
531 | close_sock: | |
532 | close(fd); | |
533 | ||
534 | return -1; | |
4e2a8808 PMF |
535 | } |
536 | ||
dbd75de7 NC |
537 | /* Returns the current users socket directory, must be freed */ |
538 | char *ustcomm_user_sock_dir(void) | |
539 | { | |
540 | int result; | |
541 | char *sock_dir = NULL; | |
542 | ||
543 | result = asprintf(&sock_dir, "%s%s", USER_SOCK_DIR, | |
544 | cuserid(NULL)); | |
545 | if (result < 0) { | |
546 | ERR("string overflow allocating directory name"); | |
547 | return NULL; | |
548 | } | |
549 | ||
550 | return sock_dir; | |
551 | } | |
4723ca09 | 552 | |
2a79ceeb PMF |
553 | /* Open a connection to a traceable app. |
554 | * | |
555 | * Return value: | |
556 | * 0: success | |
557 | * -1: error | |
558 | */ | |
559 | ||
f446d1cb | 560 | static int connect_app_non_root(pid_t pid, int *app_fd) |
4e2a8808 PMF |
561 | { |
562 | int result; | |
4723ca09 | 563 | int retval = 0; |
dbd75de7 NC |
564 | char *dir_name, *sock_name; |
565 | ||
566 | dir_name = ustcomm_user_sock_dir(); | |
567 | if (!dir_name) | |
568 | return -ENOMEM; | |
4e2a8808 | 569 | |
dbd75de7 | 570 | result = asprintf(&sock_name, "%s/%d", dir_name, pid); |
4723ca09 NC |
571 | if (result < 0) { |
572 | ERR("failed to allocate socket name"); | |
dbd75de7 NC |
573 | retval = -1; |
574 | goto free_dir_name; | |
4e2a8808 PMF |
575 | } |
576 | ||
dbd75de7 | 577 | result = ustcomm_connect_path(sock_name, app_fd); |
4723ca09 NC |
578 | if (result < 0) { |
579 | ERR("failed to connect to app"); | |
580 | retval = -1; | |
dbd75de7 | 581 | goto free_sock_name; |
4723ca09 | 582 | } |
2a79ceeb | 583 | |
dbd75de7 NC |
584 | free_sock_name: |
585 | free(sock_name); | |
586 | free_dir_name: | |
587 | free(dir_name); | |
2a79ceeb | 588 | |
4723ca09 | 589 | return retval; |
2a79ceeb PMF |
590 | } |
591 | ||
f446d1cb NC |
592 | |
593 | ||
594 | static int connect_app_root(pid_t pid, int *app_fd) | |
595 | { | |
596 | DIR *tmp_dir; | |
597 | struct dirent *dirent; | |
598 | char *sock_name; | |
599 | int result; | |
600 | ||
601 | tmp_dir = opendir(USER_TMP_DIR); | |
602 | if (!tmp_dir) { | |
603 | return -1; | |
604 | } | |
605 | ||
606 | while ((dirent = readdir(tmp_dir))) { | |
607 | if (!strncmp(dirent->d_name, USER_SOCK_DIR_BASE, | |
608 | strlen(USER_SOCK_DIR_BASE))) { | |
609 | ||
610 | if (asprintf(&sock_name, USER_TMP_DIR "/%s/%u", | |
611 | dirent->d_name, pid) < 0) { | |
612 | goto close_tmp_dir; | |
613 | } | |
614 | ||
615 | result = ustcomm_connect_path(sock_name, app_fd); | |
616 | ||
617 | free(sock_name); | |
618 | ||
619 | if (result == 0) { | |
620 | goto close_tmp_dir; | |
621 | } | |
622 | } | |
623 | } | |
624 | ||
625 | close_tmp_dir: | |
626 | closedir(tmp_dir); | |
627 | ||
628 | return result; | |
629 | } | |
630 | ||
631 | int ustcomm_connect_app(pid_t pid, int *app_fd) | |
632 | { | |
633 | *app_fd = 0; | |
634 | ||
635 | if (geteuid()) { | |
636 | return connect_app_non_root(pid, app_fd); | |
637 | } else { | |
638 | return connect_app_root(pid, app_fd); | |
639 | } | |
640 | ||
641 | } | |
642 | ||
304f67a5 | 643 | int ensure_dir_exists(const char *dir, mode_t mode) |
dce0b474 PMF |
644 | { |
645 | struct stat st; | |
646 | int result; | |
647 | ||
304f67a5 | 648 | if (!strcmp(dir, "")) |
dce0b474 PMF |
649 | return -1; |
650 | ||
651 | result = stat(dir, &st); | |
304f67a5 | 652 | if (result < 0 && errno != ENOENT) { |
dce0b474 | 653 | return -1; |
304f67a5 | 654 | } else if (result < 0) { |
dce0b474 | 655 | /* ENOENT */ |
dce0b474 PMF |
656 | int result; |
657 | ||
304f67a5 | 658 | result = mkdir_p(dir, mode); |
dce0b474 | 659 | if(result != 0) { |
d6d27063 | 660 | ERR("executing in recursive creation of directory %s", dir); |
dce0b474 PMF |
661 | return -1; |
662 | } | |
304f67a5 NC |
663 | } else { |
664 | if (st.st_mode != mode) { | |
665 | result = chmod(dir, mode); | |
666 | if (result < 0) { | |
667 | ERR("couldn't set directory mode on %s", dir); | |
668 | return -1; | |
669 | } | |
670 | } | |
dce0b474 PMF |
671 | } |
672 | ||
673 | return 0; | |
674 | } | |
675 | ||
72098143 NC |
676 | char * ustcomm_print_data(char *data_field, int field_size, |
677 | int *offset, const char *format, ...) | |
678 | { | |
679 | va_list args; | |
680 | int count, limit; | |
681 | char *ptr = USTCOMM_POISON_PTR; | |
682 | ||
683 | limit = field_size - *offset; | |
684 | va_start(args, format); | |
685 | count = vsnprintf(&data_field[*offset], limit, format, args); | |
686 | va_end(args); | |
687 | ||
688 | if (count < limit && count > -1) { | |
689 | ptr = NULL + *offset; | |
690 | *offset = *offset + count + 1; | |
691 | } | |
692 | ||
693 | return ptr; | |
694 | } | |
695 | ||
696 | char * ustcomm_restore_ptr(char *ptr, char *data_field, int data_field_size) | |
697 | { | |
698 | if ((unsigned long)ptr > data_field_size || | |
699 | ptr == USTCOMM_POISON_PTR) { | |
700 | return NULL; | |
701 | } | |
08230db7 | 702 | |
72098143 NC |
703 | return data_field + (long)ptr; |
704 | } | |
2a79ceeb | 705 | |
28c1bb40 NC |
706 | int ustcomm_pack_single_field(struct ustcomm_header *header, |
707 | struct ustcomm_single_field *single_field, | |
708 | const char *string) | |
10f2b724 NC |
709 | { |
710 | int offset = 0; | |
711 | ||
28c1bb40 NC |
712 | single_field->field = ustcomm_print_data(single_field->data, |
713 | sizeof(single_field->data), | |
714 | &offset, | |
715 | string); | |
10f2b724 | 716 | |
28c1bb40 | 717 | if (single_field->field == USTCOMM_POISON_PTR) { |
10f2b724 NC |
718 | return -ENOMEM; |
719 | } | |
720 | ||
28c1bb40 | 721 | header->size = COMPUTE_MSG_SIZE(single_field, offset); |
10f2b724 NC |
722 | |
723 | return 0; | |
724 | } | |
725 | ||
28c1bb40 | 726 | int ustcomm_unpack_single_field(struct ustcomm_single_field *single_field) |
10f2b724 | 727 | { |
28c1bb40 NC |
728 | single_field->field = ustcomm_restore_ptr(single_field->field, |
729 | single_field->data, | |
730 | sizeof(single_field->data)); | |
731 | if (!single_field->field) { | |
10f2b724 NC |
732 | return -EINVAL; |
733 | } | |
734 | ||
735 | return 0; | |
736 | } | |
72098143 NC |
737 | |
738 | int ustcomm_pack_channel_info(struct ustcomm_header *header, | |
739 | struct ustcomm_channel_info *ch_inf, | |
d89b8191 | 740 | const char *trace, |
72098143 | 741 | const char *channel) |
b02e31e5 | 742 | { |
72098143 NC |
743 | int offset = 0; |
744 | ||
d89b8191 NC |
745 | ch_inf->trace = ustcomm_print_data(ch_inf->data, |
746 | sizeof(ch_inf->data), | |
747 | &offset, | |
748 | trace); | |
749 | ||
750 | if (ch_inf->trace == USTCOMM_POISON_PTR) { | |
751 | return -ENOMEM; | |
752 | } | |
753 | ||
72098143 NC |
754 | ch_inf->channel = ustcomm_print_data(ch_inf->data, |
755 | sizeof(ch_inf->data), | |
756 | &offset, | |
757 | channel); | |
b02e31e5 | 758 | |
72098143 NC |
759 | if (ch_inf->channel == USTCOMM_POISON_PTR) { |
760 | return -ENOMEM; | |
b02e31e5 PMF |
761 | } |
762 | ||
72098143 NC |
763 | header->size = COMPUTE_MSG_SIZE(ch_inf, offset); |
764 | ||
765 | return 0; | |
b02e31e5 PMF |
766 | } |
767 | ||
72098143 NC |
768 | |
769 | int ustcomm_unpack_channel_info(struct ustcomm_channel_info *ch_inf) | |
b02e31e5 | 770 | { |
d89b8191 NC |
771 | ch_inf->trace = ustcomm_restore_ptr(ch_inf->trace, |
772 | ch_inf->data, | |
773 | sizeof(ch_inf->data)); | |
774 | if (!ch_inf->trace) { | |
775 | return -EINVAL; | |
776 | } | |
777 | ||
72098143 NC |
778 | ch_inf->channel = ustcomm_restore_ptr(ch_inf->channel, |
779 | ch_inf->data, | |
780 | sizeof(ch_inf->data)); | |
781 | if (!ch_inf->channel) { | |
782 | return -EINVAL; | |
783 | } | |
b02e31e5 | 784 | |
72098143 NC |
785 | return 0; |
786 | } | |
787 | ||
788 | int ustcomm_pack_buffer_info(struct ustcomm_header *header, | |
789 | struct ustcomm_buffer_info *buf_inf, | |
d89b8191 | 790 | const char *trace, |
72098143 NC |
791 | const char *channel, |
792 | int channel_cpu) | |
793 | { | |
794 | int offset = 0; | |
795 | ||
d89b8191 NC |
796 | buf_inf->trace = ustcomm_print_data(buf_inf->data, |
797 | sizeof(buf_inf->data), | |
798 | &offset, | |
799 | trace); | |
800 | ||
801 | if (buf_inf->trace == USTCOMM_POISON_PTR) { | |
802 | return -ENOMEM; | |
803 | } | |
804 | ||
72098143 NC |
805 | buf_inf->channel = ustcomm_print_data(buf_inf->data, |
806 | sizeof(buf_inf->data), | |
807 | &offset, | |
808 | channel); | |
809 | ||
810 | if (buf_inf->channel == USTCOMM_POISON_PTR) { | |
811 | return -ENOMEM; | |
b02e31e5 PMF |
812 | } |
813 | ||
72098143 NC |
814 | buf_inf->ch_cpu = channel_cpu; |
815 | ||
816 | header->size = COMPUTE_MSG_SIZE(buf_inf, offset); | |
817 | ||
818 | return 0; | |
b02e31e5 PMF |
819 | } |
820 | ||
72098143 NC |
821 | |
822 | int ustcomm_unpack_buffer_info(struct ustcomm_buffer_info *buf_inf) | |
b02e31e5 | 823 | { |
d89b8191 NC |
824 | buf_inf->trace = ustcomm_restore_ptr(buf_inf->trace, |
825 | buf_inf->data, | |
826 | sizeof(buf_inf->data)); | |
827 | if (!buf_inf->trace) { | |
828 | return -EINVAL; | |
829 | } | |
830 | ||
72098143 NC |
831 | buf_inf->channel = ustcomm_restore_ptr(buf_inf->channel, |
832 | buf_inf->data, | |
833 | sizeof(buf_inf->data)); | |
834 | if (!buf_inf->channel) { | |
835 | return -EINVAL; | |
836 | } | |
b02e31e5 | 837 | |
72098143 NC |
838 | return 0; |
839 | } | |
840 | ||
b521931e MD |
841 | int ustcomm_pack_ust_marker_info(struct ustcomm_header *header, |
842 | struct ustcomm_ust_marker_info *ust_marker_inf, | |
d89b8191 | 843 | const char *trace, |
72098143 | 844 | const char *channel, |
b521931e | 845 | const char *ust_marker) |
72098143 NC |
846 | { |
847 | int offset = 0; | |
b02e31e5 | 848 | |
b521931e MD |
849 | ust_marker_inf->trace = ustcomm_print_data(ust_marker_inf->data, |
850 | sizeof(ust_marker_inf->data), | |
d89b8191 NC |
851 | &offset, |
852 | trace); | |
853 | ||
b521931e | 854 | if (ust_marker_inf->trace == USTCOMM_POISON_PTR) { |
d89b8191 NC |
855 | return -ENOMEM; |
856 | } | |
857 | ||
858 | ||
b521931e MD |
859 | ust_marker_inf->channel = ustcomm_print_data(ust_marker_inf->data, |
860 | sizeof(ust_marker_inf->data), | |
72098143 NC |
861 | &offset, |
862 | channel); | |
b02e31e5 | 863 | |
b521931e | 864 | if (ust_marker_inf->channel == USTCOMM_POISON_PTR) { |
72098143 NC |
865 | return -ENOMEM; |
866 | } | |
867 | ||
868 | ||
b521931e MD |
869 | ust_marker_inf->ust_marker = ustcomm_print_data(ust_marker_inf->data, |
870 | sizeof(ust_marker_inf->data), | |
72098143 | 871 | &offset, |
b521931e | 872 | ust_marker); |
b02e31e5 | 873 | |
b521931e | 874 | if (ust_marker_inf->ust_marker == USTCOMM_POISON_PTR) { |
72098143 | 875 | return -ENOMEM; |
b02e31e5 PMF |
876 | } |
877 | ||
b521931e | 878 | header->size = COMPUTE_MSG_SIZE(ust_marker_inf, offset); |
b02e31e5 | 879 | |
72098143 NC |
880 | return 0; |
881 | } | |
b02e31e5 | 882 | |
b521931e | 883 | int ustcomm_unpack_ust_marker_info(struct ustcomm_ust_marker_info *ust_marker_inf) |
72098143 | 884 | { |
b521931e MD |
885 | ust_marker_inf->trace = ustcomm_restore_ptr(ust_marker_inf->trace, |
886 | ust_marker_inf->data, | |
887 | sizeof(ust_marker_inf->data)); | |
888 | if (!ust_marker_inf->trace) { | |
d89b8191 NC |
889 | return -EINVAL; |
890 | } | |
891 | ||
b521931e MD |
892 | ust_marker_inf->channel = ustcomm_restore_ptr(ust_marker_inf->channel, |
893 | ust_marker_inf->data, | |
894 | sizeof(ust_marker_inf->data)); | |
895 | if (!ust_marker_inf->channel) { | |
72098143 NC |
896 | return -EINVAL; |
897 | } | |
898 | ||
b521931e MD |
899 | ust_marker_inf->ust_marker = ustcomm_restore_ptr(ust_marker_inf->ust_marker, |
900 | ust_marker_inf->data, | |
901 | sizeof(ust_marker_inf->data)); | |
902 | if (!ust_marker_inf->ust_marker) { | |
72098143 NC |
903 | return -EINVAL; |
904 | } | |
905 | ||
906 | return 0; | |
b02e31e5 PMF |
907 | } |
908 |