ltt-sessiond/main.c

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