Add ust start trace feature
[lttng-tools.git] / ltt-sessiond / main.c
CommitLineData
826d496d
MD
1/*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
fac6795d
DG
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
91d76f53 8 *
fac6795d
DG
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
91d76f53 13 *
fac6795d
DG
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
fac6795d
DG
17 */
18
19#define _GNU_SOURCE
20#include <fcntl.h>
21#include <getopt.h>
22#include <grp.h>
23#include <limits.h>
24#include <pthread.h>
25#include <signal.h>
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29#include <sys/ipc.h>
30#include <sys/shm.h>
31#include <sys/socket.h>
32#include <sys/stat.h>
33#include <sys/types.h>
34#include <unistd.h>
35
36#include <urcu/list.h> /* URCU list library (-lurcu) */
37#include <ust/ustctl.h> /* UST control lib (-lust) */
ca95a216 38#include <lttng/liblttngctl.h>
fac6795d
DG
39
40#include "liblttsessiondcomm.h"
41#include "ltt-sessiond.h"
75462a81 42#include "lttngerr.h"
5b74c7b1 43#include "session.h"
fda89c9b 44#include "trace.h"
91d76f53 45#include "traceable-app.h"
fac6795d 46
75462a81 47/* Const values */
686204ab
MD
48const char default_home_dir[] = DEFAULT_HOME_DIR;
49const char default_tracing_group[] = DEFAULT_TRACING_GROUP;
50const char default_ust_sock_dir[] = DEFAULT_UST_SOCK_DIR;
51const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE;
52
fac6795d 53/* Static functions */
fac6795d 54static int check_existing_daemon(void);
1fd70b72 55static int connect_app(pid_t pid);
fac6795d 56static int init_daemon_socket(void);
62bd06d8 57static int notify_apps(const char* name);
e065084a
DG
58static int process_client_msg(int sock, struct lttcomm_session_msg*);
59static int send_unix_sock(int sock, void *buf, size_t len);
62bd06d8
DG
60static int set_signal_handler(void);
61static int set_socket_perms(void);
aaf97519 62static int setup_data_buffer(char **buf, size_t size, struct lttcomm_lttng_msg *llm);
62bd06d8
DG
63static void cleanup(void);
64static void copy_common_data(struct lttcomm_lttng_msg *llm, struct lttcomm_session_msg *lsm);
65static void sighandler(int sig);
fac6795d 66
1fd70b72
DG
67static void *thread_manage_clients(void *data);
68static void *thread_manage_apps(void *data);
fac6795d 69
fac6795d 70/* Variables */
62bd06d8
DG
71int opt_verbose;
72int opt_quiet;
fac6795d
DG
73const char *progname;
74const char *opt_tracing_group;
5b8719f5 75static int opt_sig_parent;
fac6795d
DG
76static int opt_daemon;
77static int is_root; /* Set to 1 if the daemon is running as root */
5b8719f5 78static pid_t ppid;
fac6795d
DG
79
80static char apps_unix_sock_path[PATH_MAX]; /* Global application Unix socket path */
81static char client_unix_sock_path[PATH_MAX]; /* Global client Unix socket path */
82
83static int client_socket;
84static int apps_socket;
85
86static struct ltt_session *current_session;
e065084a 87
fac6795d
DG
88/*
89 * thread_manage_apps
90 *
91 * This thread manage the application socket communication
92 */
93static void *thread_manage_apps(void *data)
94{
95 int sock, ret;
fac6795d
DG
96
97 /* TODO: Something more elegant is needed but fine for now */
686204ab 98 struct {
fac6795d 99 int reg; /* 1:register, 0:unregister */
686204ab
MD
100 pid_t pid;
101 uid_t uid;
102 } reg_msg;
fac6795d
DG
103
104 /* Notify all applications to register */
105 notify_apps(default_global_apps_pipe);
106
107 ret = lttcomm_listen_unix_sock(apps_socket);
108 if (ret < 0) {
109 goto error;
110 }
111
112 while (1) {
113 /* Blocking call, waiting for transmission */
114 sock = lttcomm_accept_unix_sock(apps_socket);
115 if (sock < 0) {
116 goto error;
117 }
118
119 /* Basic recv here to handle the very simple data
120 * that the libust send to register (reg_msg).
121 */
122 ret = recv(sock, &reg_msg, sizeof(reg_msg), 0);
123 if (ret < 0) {
124 perror("recv");
125 continue;
126 }
127
128 /* Add application to the global traceable list */
129 if (reg_msg.reg == 1) {
130 /* Registering */
91d76f53
DG
131 ret = register_traceable_app(reg_msg.pid, reg_msg.uid);
132 if (ret < 0) {
133 /* register_traceable_app only return an error with
134 * ENOMEM. At this point, we better stop everything.
135 */
136 goto error;
137 }
fac6795d
DG
138 } else {
139 /* Unregistering */
91d76f53 140 unregister_traceable_app(reg_msg.pid);
fac6795d
DG
141 }
142 }
143
144error:
145
146 return NULL;
147}
148
149/*
150 * thread_manage_clients
151 *
152 * This thread manage all clients request using the unix
153 * client socket for communication.
154 */
155static void *thread_manage_clients(void *data)
156{
157 int sock, ret;
158 struct lttcomm_session_msg lsm;
fac6795d
DG
159
160 ret = lttcomm_listen_unix_sock(client_socket);
161 if (ret < 0) {
162 goto error;
163 }
164
5b8719f5
DG
165 /* Notify parent pid that we are ready
166 * to accept command for client side.
167 */
168 if (opt_sig_parent) {
169 kill(ppid, SIGCHLD);
170 }
171
fac6795d
DG
172 while (1) {
173 /* Blocking call, waiting for transmission */
174 sock = lttcomm_accept_unix_sock(client_socket);
175 if (sock < 0) {
176 goto error;
177 }
178
179 /*
180 * Data is received from the lttng client. The struct
181 * lttcomm_session_msg (lsm) contains the command and data
182 * request of the client.
183 */
184 ret = lttcomm_recv_unix_sock(sock, &lsm, sizeof(lsm));
87378cf5 185 if (ret <= 0) {
fac6795d
DG
186 continue;
187 }
188
189 /* This function dispatch the work to the LTTng or UST libs
e065084a
DG
190 * and then sends back the response to the client. This is needed
191 * because there might be more then one lttcomm_lttng_msg to
192 * send out so process_client_msg do both jobs.
fac6795d 193 */
e065084a
DG
194 ret = process_client_msg(sock, &lsm);
195 if (ret < 0) {
196 /* Error detected but still accept command */
197 continue;
fac6795d
DG
198 }
199 }
200
201error:
202 return NULL;
203}
204
e065084a
DG
205/*
206 * send_unix_sock
207 *
208 * Send data on a unix socket using the liblttsessiondcomm API.
209 *
210 * Return lttcomm error code.
211 */
212static int send_unix_sock(int sock, void *buf, size_t len)
213{
214 /* Check valid length */
215 if (len <= 0) {
216 return -1;
217 }
218
219 return lttcomm_send_unix_sock(sock, buf, len);
220}
221
fac6795d
DG
222/*
223 * connect_app
224 *
225 * Return a socket connected to the libust communication socket
226 * of the application identified by the pid.
379473d2
DG
227 *
228 * If the pid is not found in the traceable list,
229 * return -1 to indicate error.
fac6795d
DG
230 */
231static int connect_app(pid_t pid)
232{
91d76f53
DG
233 int sock;
234 struct ltt_traceable_app *lta;
379473d2 235
91d76f53
DG
236 lta = find_app_by_pid(pid);
237 if (lta == NULL) {
238 /* App not found */
379473d2
DG
239 return -1;
240 }
fac6795d 241
91d76f53 242 sock = ustctl_connect_pid(lta->pid);
fac6795d 243 if (sock < 0) {
75462a81 244 ERR("Fail connecting to the PID %d\n", pid);
fac6795d
DG
245 }
246
247 return sock;
248}
249
250/*
251 * notify_apps
252 *
253 * Notify apps by writing 42 to a named pipe using name.
254 * Every applications waiting for a ltt-sessiond will be notified
255 * and re-register automatically to the session daemon.
256 *
257 * Return open or write error value.
258 */
259static int notify_apps(const char *name)
260{
261 int fd;
262 int ret = -1;
263
264 /* Try opening the global pipe */
265 fd = open(name, O_WRONLY);
266 if (fd < 0) {
267 goto error;
268 }
269
270 /* Notify by writing on the pipe */
271 ret = write(fd, "42", 2);
272 if (ret < 0) {
273 perror("write");
274 }
275
276error:
277 return ret;
278}
279
379473d2
DG
280/*
281 * ust_create_trace
282 *
283 * Create an userspace trace using pid.
284 * This trace is then appended to the current session
285 * ust trace list.
286 */
287static int ust_create_trace(pid_t pid)
288{
289 int sock, ret;
290 struct ltt_ust_trace *trace;
291
292 trace = malloc(sizeof(struct ltt_ust_trace));
293 if (trace == NULL) {
294 perror("malloc");
295 ret = -1;
296 goto error;
297 }
298
299 /* Init */
300 trace->pid = pid;
301 trace->shmid = 0;
302
303 /* Connect to app using ustctl API */
304 sock = connect_app(pid);
305 if (sock < 0) {
306 ret = LTTCOMM_NO_TRACEABLE;
307 goto error;
308 }
309
310 ret = ustctl_create_trace(sock, "auto");
311 if (ret < 0) {
312 ret = LTTCOMM_CREATE_FAIL;
313 goto error;
314 }
315
316 /* Check if current session is valid */
317 if (current_session) {
318 cds_list_add(&trace->list, &current_session->ust_traces);
319 }
320
321error:
322 return ret;
323}
324
ce3d728c
DG
325/*
326 * ust_start_trace
327 *
328 * Start a trace. This trace, identified by the pid, must be
329 * in the current session ust_traces list.
330 */
331static int ust_start_trace(pid_t pid)
332{
333 int sock, ret;
334 struct ltt_ust_trace *trace;
335
336 DBG("Starting trace for pid %d", pid);
337
338 trace = find_session_ust_trace_by_pid(current_session, pid);
339 if (trace == NULL) {
340 ret = LTTCOMM_NO_TRACE;
341 goto error;
342 }
343
344 /* Connect to app using ustctl API */
345 sock = connect_app(pid);
346 if (sock < 0) {
347 ret = LTTCOMM_NO_TRACEABLE;
348 goto error;
349 }
350
351 ret = ustctl_start_trace(sock, "auto");
352 if (ret < 0) {
353 ret = LTTCOMM_START_FAIL;
354 goto error;
355 }
356
357error:
358 return ret;
359}
360
e065084a
DG
361/*
362 * copy_common_data
363 *
364 * Copy common data between lttcomm_lttng_msg and lttcomm_session_msg
365 */
366static void copy_common_data(struct lttcomm_lttng_msg *llm, struct lttcomm_session_msg *lsm)
367{
368 llm->cmd_type = lsm->cmd_type;
369 llm->pid = lsm->pid;
aaf97519
DG
370
371 /* Manage uuid */
8028d920
DG
372 if (!uuid_is_null(lsm->session_id)) {
373 uuid_copy(llm->session_id, lsm->session_id);
e065084a 374 }
aaf97519
DG
375
376 strncpy(llm->trace_name, lsm->trace_name, strlen(llm->trace_name));
8028d920 377 llm->trace_name[strlen(llm->trace_name) - 1] = '\0';
e065084a
DG
378}
379
ca95a216
DG
380/*
381 * setup_data_buffer
382 *
383 * Setup the outgoing data buffer for the response
384 * data allocating the right amount of memory.
385 *
386 * Return total size of the buffer pointed by buf.
387 */
aaf97519 388static int setup_data_buffer(char **buf, size_t s_data, struct lttcomm_lttng_msg *llm)
ca95a216
DG
389{
390 int ret = 0;
ca95a216
DG
391 size_t buf_size;
392
393 buf_size = sizeof(struct lttcomm_lttng_msg) + s_data;
aaf97519
DG
394 *buf = malloc(buf_size);
395 if (*buf == NULL) {
ca95a216
DG
396 perror("malloc");
397 ret = -1;
398 goto error;
399 }
400
401 /* Setup lttcomm_lttng_msg data and copy
402 * it to the newly allocated buffer.
403 */
404 llm->size_payload = s_data;
aaf97519 405 memcpy(*buf, llm, sizeof(struct lttcomm_lttng_msg));
ca95a216
DG
406
407 return buf_size;
408
409error:
410 return ret;
411}
412
fac6795d
DG
413/*
414 * process_client_msg
415 *
416 * This takes the lttcomm_session_msg struct and process the command requested
e065084a
DG
417 * by the client. It then creates response(s) and send it back to the
418 * given socket (sock).
fac6795d 419 *
e065084a 420 * Return any error encountered or 0 for success.
fac6795d 421 */
e065084a 422static int process_client_msg(int sock, struct lttcomm_session_msg *lsm)
fac6795d 423{
e065084a 424 int ret;
ca95a216 425 int buf_size;
7e6e59cd 426 size_t header_size;
aaf97519
DG
427 char *send_buf = NULL;
428 struct lttcomm_lttng_msg llm;
fac6795d
DG
429
430 /* Copy common data to identify the response
431 * on the lttng client side.
432 */
e065084a 433 copy_common_data(&llm, lsm);
fac6795d 434
379473d2
DG
435 /* Check command that needs a session */
436 if (lsm->cmd_type != LTTNG_CREATE_SESSION &&
437 lsm->cmd_type != LTTNG_LIST_SESSIONS &&
438 lsm->cmd_type != UST_LIST_APPS)
439 {
440 current_session = find_session_by_uuid(lsm->session_id);
441 if (current_session == NULL) {
442 ret = LTTCOMM_SELECT_SESS;
443 goto end;
444 }
445 }
446
fac6795d 447 /* Default return code.
e065084a 448 * In our world, everything is OK... right? ;)
fac6795d 449 */
e065084a 450 llm.ret_code = LTTCOMM_OK;
fac6795d 451
7e6e59cd
DG
452 header_size = sizeof(struct lttcomm_lttng_msg);
453
fac6795d
DG
454 /* Process by command type */
455 switch (lsm->cmd_type) {
aaf97519
DG
456 case LTTNG_CREATE_SESSION:
457 {
8028d920 458 ret = create_session(lsm->session_name, &llm.session_id);
aaf97519 459 if (ret < 0) {
27673bb6
DG
460 if (ret == -1) {
461 ret = LTTCOMM_EXIST_SESS;
462 } else {
463 ret = LTTCOMM_FATAL;
464 }
8028d920 465 goto end;
aaf97519
DG
466 }
467
aaf97519
DG
468 buf_size = setup_data_buffer(&send_buf, 0, &llm);
469 if (buf_size < 0) {
470 ret = LTTCOMM_FATAL;
8028d920 471 goto end;
aaf97519
DG
472 }
473
aaf97519
DG
474 break;
475 }
8028d920
DG
476 case LTTNG_DESTROY_SESSION:
477 {
478 ret = destroy_session(&lsm->session_id);
479 if (ret < 0) {
480 ret = LTTCOMM_NO_SESS;
481 } else {
482 ret = LTTCOMM_OK;
483 }
484
485 /* No auxiliary data so only send the llm struct. */
486 goto end;
487 }
df0da139
DG
488 case UST_CREATE_TRACE:
489 {
379473d2 490 ret = ust_create_trace(lsm->pid);
df0da139 491 if (ret < 0) {
ce3d728c
DG
492 /* If -1 is returned from ust_create_trace, malloc
493 * failed so it's pretty much a fatal error.
494 */
495 ret = LTTCOMM_FATAL;
379473d2 496 goto end;
df0da139
DG
497 }
498
379473d2 499 /* No auxiliary data so only send the llm struct. */
df0da139
DG
500 goto end;
501 }
fac6795d
DG
502 case UST_LIST_APPS:
503 {
91d76f53 504 unsigned int app_count = get_app_count();
ca95a216 505 /* Stop right now if no apps */
91d76f53 506 if (app_count == 0) {
e065084a 507 ret = LTTCOMM_NO_APPS;
8028d920 508 goto end;
e065084a
DG
509 }
510
ca95a216
DG
511 /* Setup data buffer and details for transmission */
512 buf_size = setup_data_buffer(&send_buf,
91d76f53 513 sizeof(pid_t) * app_count, &llm);
ca95a216
DG
514 if (buf_size < 0) {
515 ret = LTTCOMM_FATAL;
8028d920 516 goto end;
ca95a216
DG
517 }
518
91d76f53 519 get_app_list_pids((pid_t *)(send_buf + header_size));
ca95a216 520
fac6795d
DG
521 break;
522 }
ce3d728c
DG
523 case UST_START_TRACE:
524 {
525 ret = ust_start_trace(lsm->pid);
526
527 /* No auxiliary data so only send the llm struct. */
528 goto end;
529 }
57167058
DG
530 case LTTNG_LIST_SESSIONS:
531 {
5b74c7b1 532 unsigned int session_count = get_session_count();
ca95a216
DG
533 /* Stop right now if no session */
534 if (session_count == 0) {
57167058 535 ret = LTTCOMM_NO_SESS;
8028d920 536 goto end;
57167058
DG
537 }
538
ca95a216
DG
539 /* Setup data buffer and details for transmission */
540 buf_size = setup_data_buffer(&send_buf,
541 (sizeof(struct lttng_session) * session_count), &llm);
542 if (buf_size < 0) {
543 ret = LTTCOMM_FATAL;
8028d920 544 goto end;
ca95a216
DG
545 }
546
5b74c7b1 547 get_lttng_session((struct lttng_session *)(send_buf + header_size));
ca95a216 548
57167058
DG
549 break;
550 }
fac6795d 551 default:
e065084a 552 {
fac6795d 553 /* Undefined command */
e065084a 554 ret = LTTCOMM_UND;
8028d920 555 goto end;
e065084a 556 }
fac6795d
DG
557 }
558
1fd70b72
DG
559 ret = send_unix_sock(sock, send_buf, buf_size);
560
ca95a216
DG
561 if (send_buf != NULL) {
562 free(send_buf);
563 }
564
e065084a
DG
565 return ret;
566
8028d920 567end:
e065084a
DG
568 /* Notify client of error */
569 llm.ret_code = ret;
ca95a216 570 llm.size_payload = 0;
e065084a
DG
571 send_unix_sock(sock, (void*) &llm, sizeof(llm));
572
8028d920 573 return ret;
fac6795d
DG
574}
575
576/*
577 * usage function on stderr
578 */
579static void usage(void)
580{
b716ce68
DG
581 fprintf(stderr, "Usage: %s OPTIONS\n\nOptions:\n", progname);
582 fprintf(stderr, " -h, --help Display this usage.\n");
583 fprintf(stderr, " -c, --client-sock PATH Specify path for the client unix socket\n");
584 fprintf(stderr, " -a, --apps-sock PATH Specify path for apps unix socket.\n");
585 fprintf(stderr, " -d, --daemonize Start as a daemon.\n");
586 fprintf(stderr, " -g, --group NAME Specify the tracing group name. (default: tracing)\n");
587 fprintf(stderr, " -V, --version Show version number.\n");
588 fprintf(stderr, " -S, --sig-parent Send SIGCHLD to parent pid to notify readiness.\n");
589 fprintf(stderr, " -q, --quiet No output at all.\n");
fac6795d
DG
590}
591
592/*
593 * daemon argument parsing
594 */
595static int parse_args(int argc, char **argv)
596{
597 int c;
598
599 static struct option long_options[] = {
600 { "client-sock", 1, 0, 'c' },
601 { "apps-sock", 1, 0, 'a' },
602 { "daemonize", 0, 0, 'd' },
5b8719f5 603 { "sig-parent", 0, 0, 'S' },
fac6795d
DG
604 { "help", 0, 0, 'h' },
605 { "group", 1, 0, 'g' },
606 { "version", 0, 0, 'V' },
75462a81 607 { "quiet", 0, 0, 'q' },
fac6795d
DG
608 { NULL, 0, 0, 0 }
609 };
610
611 while (1) {
612 int option_index = 0;
75462a81 613 c = getopt_long(argc, argv, "dhqVS" "a:c:g:s:", long_options, &option_index);
fac6795d
DG
614 if (c == -1) {
615 break;
616 }
617
618 switch (c) {
619 case 0:
620 fprintf(stderr, "option %s", long_options[option_index].name);
621 if (optarg) {
622 fprintf(stderr, " with arg %s\n", optarg);
623 }
624 break;
b716ce68 625 case 'c':
fac6795d
DG
626 snprintf(client_unix_sock_path, PATH_MAX, "%s", optarg);
627 break;
628 case 'a':
629 snprintf(apps_unix_sock_path, PATH_MAX, "%s", optarg);
630 break;
631 case 'd':
632 opt_daemon = 1;
633 break;
634 case 'g':
635 opt_tracing_group = strdup(optarg);
636 break;
637 case 'h':
638 usage();
639 exit(EXIT_FAILURE);
640 case 'V':
641 fprintf(stdout, "%s\n", VERSION);
642 exit(EXIT_SUCCESS);
5b8719f5
DG
643 case 'S':
644 opt_sig_parent = 1;
645 break;
75462a81
DG
646 case 'q':
647 opt_quiet = 1;
648 break;
fac6795d
DG
649 default:
650 /* Unknown option or other error.
651 * Error is printed by getopt, just return */
652 return -1;
653 }
654 }
655
656 return 0;
657}
658
659/*
660 * init_daemon_socket
661 *
662 * Creates the two needed socket by the daemon.
62bd06d8
DG
663 * apps_socket - The communication socket for all UST apps.
664 * client_socket - The communication of the cli tool (lttng).
fac6795d
DG
665 */
666static int init_daemon_socket()
667{
668 int ret = 0;
669 mode_t old_umask;
670
671 old_umask = umask(0);
672
673 /* Create client tool unix socket */
674 client_socket = lttcomm_create_unix_sock(client_unix_sock_path);
675 if (client_socket < 0) {
676 ret = -1;
677 goto end;
678 }
679
680 /* File permission MUST be 660 */
681 ret = chmod(client_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
682 if (ret < 0) {
683 perror("chmod");
684 goto end;
685 }
686
687 /* Create the application unix socket */
688 apps_socket = lttcomm_create_unix_sock(apps_unix_sock_path);
689 if (apps_socket < 0) {
690 ret = -1;
691 goto end;
692 }
693
694 /* File permission MUST be 660 */
695 ret = chmod(apps_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
696 if (ret < 0) {
697 perror("chmod");
698 goto end;
699 }
700
701end:
702 umask(old_umask);
703 return ret;
704}
705
706/*
707 * check_existing_daemon
708 *
709 * Check if the global socket is available.
62bd06d8 710 * If yes, error is returned.
fac6795d
DG
711 */
712static int check_existing_daemon()
713{
714 int ret;
715
716 ret = access(client_unix_sock_path, F_OK);
717 if (ret == 0) {
718 ret = access(apps_unix_sock_path, F_OK);
719 }
720
721 return ret;
722}
723
724/*
62bd06d8 725 * get_home_dir
fac6795d 726 *
62bd06d8
DG
727 * Return pointer to home directory path using
728 * the env variable HOME.
fac6795d 729 *
62bd06d8 730 * Default : /tmp
fac6795d
DG
731 */
732static const char *get_home_dir(void)
733{
734 const char *home_path;
735
686204ab 736 if ((home_path = (const char *) getenv("HOME")) == NULL) {
fac6795d
DG
737 home_path = default_home_dir;
738 }
739
740 return home_path;
741}
742
743/*
744 * set_socket_perms
745 *
746 * Set the tracing group gid onto the client socket.
747 */
748static int set_socket_perms(void)
749{
750 int ret;
751 struct group *grp;
752
753 /* Decide which group name to use */
754 (opt_tracing_group != NULL) ?
755 (grp = getgrnam(opt_tracing_group)) :
756 (grp = getgrnam(default_tracing_group));
757
758 if (grp == NULL) {
75462a81 759 ERR("Missing tracing group. Aborting execution.\n");
fac6795d
DG
760 ret = -1;
761 goto end;
762 }
763
764 ret = chown(client_unix_sock_path, 0, grp->gr_gid);
765 if (ret < 0) {
766 perror("chown");
767 }
768
769end:
770 return ret;
771}
772
fac6795d 773/*
62bd06d8 774 * set_signal_handler
fac6795d 775 *
62bd06d8 776 * Setup signal handler for :
fac6795d
DG
777 * SIGINT, SIGTERM, SIGPIPE
778 */
779static int set_signal_handler(void)
780{
781 int ret = 0;
782 struct sigaction sa;
783 sigset_t sigset;
784
785 if ((ret = sigemptyset(&sigset)) < 0) {
786 perror("sigemptyset");
787 return ret;
788 }
789
790 sa.sa_handler = sighandler;
791 sa.sa_mask = sigset;
792 sa.sa_flags = 0;
793 if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
794 perror("sigaction");
795 return ret;
796 }
797
798 if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
799 perror("sigaction");
800 return ret;
801 }
802
803 if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
804 perror("sigaction");
805 return ret;
806 }
807
808 return ret;
809}
810
811/**
62bd06d8 812 * sighandler
fac6795d 813 *
62bd06d8 814 * Signal handler for the daemon
fac6795d
DG
815 */
816static void sighandler(int sig)
817{
818 switch (sig) {
819 case SIGPIPE:
87378cf5 820 return;
fac6795d
DG
821 case SIGINT:
822 case SIGTERM:
823 cleanup();
686204ab 824 break;
fac6795d
DG
825 default:
826 break;
827 }
828
829 exit(EXIT_SUCCESS);
830}
831
832/*
62bd06d8 833 * cleanup
fac6795d 834 *
62bd06d8 835 * Cleanup the daemon on exit
fac6795d
DG
836 */
837static void cleanup()
838{
839 /* <fun> */
b716ce68
DG
840 MSG("\n%c[%d;%dm*** assert failed *** ==> %c[%dm", 27,1,31,27,0);
841 MSG("%c[%d;%dmMatthew, BEET driven development works!%c[%dm",27,1,33,27,0);
fac6795d
DG
842 /* </fun> */
843
844 unlink(client_unix_sock_path);
845 unlink(apps_unix_sock_path);
846}
847
848/*
849 * main
850 */
851int main(int argc, char **argv)
852{
853 int i;
854 int ret = 0;
855 void *status;
856 pthread_t threads[2];
857
858 /* Parse arguments */
859 progname = argv[0];
860 if ((ret = parse_args(argc, argv) < 0)) {
861 goto error;
862 }
863
864 /* Daemonize */
865 if (opt_daemon) {
53094c05
DG
866 ret = daemon(0, 0);
867 if (ret < 0) {
868 perror("daemon");
869 goto error;
870 }
fac6795d
DG
871 }
872
873 /* Check if daemon is UID = 0 */
874 is_root = !getuid();
875
876 /* Set all sockets path */
877 if (is_root) {
878 if (strlen(apps_unix_sock_path) == 0) {
879 (snprintf(apps_unix_sock_path, PATH_MAX,
880 DEFAULT_GLOBAL_APPS_UNIX_SOCK));
881 }
882
883 if (strlen(client_unix_sock_path) == 0) {
884 (snprintf(client_unix_sock_path, PATH_MAX,
885 DEFAULT_GLOBAL_CLIENT_UNIX_SOCK));
886 }
887 } else {
888 if (strlen(apps_unix_sock_path) == 0) {
889 (snprintf(apps_unix_sock_path, PATH_MAX,
890 DEFAULT_HOME_APPS_UNIX_SOCK, get_home_dir()));
891 }
892
893 /* Set the cli tool unix socket path */
894 if (strlen(client_unix_sock_path) == 0) {
895 (snprintf(client_unix_sock_path, PATH_MAX,
896 DEFAULT_HOME_CLIENT_UNIX_SOCK, get_home_dir()));
897 }
898 }
899
900 /* See if daemon already exist. If any of the two
901 * socket needed by the daemon are present, this test fails
902 */
903 if ((ret = check_existing_daemon()) == 0) {
75462a81 904 ERR("Already running daemon.\n");
ab118b20
DG
905 /* We do not goto error because we must not
906 * cleanup() because a daemon is already working.
907 */
908 return EXIT_FAILURE;
fac6795d
DG
909 }
910
911 if (set_signal_handler() < 0) {
912 goto error;
913 }
914
915 /* Setup the two needed unix socket */
916 if (init_daemon_socket() < 0) {
917 goto error;
918 }
919
920 /* Set credentials to socket */
921 if (is_root && (set_socket_perms() < 0)) {
922 goto error;
923 }
924
5b8719f5
DG
925 /* Get parent pid if -S, --sig-parent is specified. */
926 if (opt_sig_parent) {
927 ppid = getppid();
928 }
929
fac6795d
DG
930 while (1) {
931 /* Create thread to manage the client socket */
932 ret = pthread_create(&threads[0], NULL, thread_manage_clients, (void *) NULL);
933 if (ret != 0) {
934 perror("pthread_create");
935 goto error;
936 }
937
938 /* Create thread to manage application socket */
939 ret = pthread_create(&threads[1], NULL, thread_manage_apps, (void *) NULL);
940 if (ret != 0) {
941 perror("pthread_create");
942 goto error;
943 }
944
945 for (i = 0; i < 2; i++) {
946 ret = pthread_join(threads[i], &status);
947 if (ret != 0) {
948 perror("pthread_join");
949 goto error;
950 }
951 }
952 }
953
954 cleanup();
955 return 0;
956
957error:
958 cleanup();
959
960 return EXIT_FAILURE;
961}
This page took 0.104197 seconds and 4 git commands to generate.