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         /* 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 */
 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                         }
 138                 } else {
 139                         /* Unregistering */
 140                         unregister_traceable_app(reg_msg.pid);
 141                 }
 142         }
 143
 144 error:
 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  */
 155 static void *thread_manage_clients(void *data)
 156 {
 157         int sock, ret;
 158         struct lttcomm_session_msg lsm;
 159
 160         ret = lttcomm_listen_unix_sock(client_socket);
 161         if (ret < 0) {
 162                 goto error;
 163         }
 164
 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
 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));
 185                 if (ret <= 0) {
 186                         continue;
 187                 }
 188
 189                 /* This function dispatch the work to the LTTng or UST libs
 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.
 193                  */
 194                 ret = process_client_msg(sock, &lsm);
 195                 if (ret < 0) {
 196                         /* Error detected but still accept command */
 197                         continue;
 198                 }
 199         }
 200
 201 error:
 202         return NULL;
 203 }
 204
 205 /*
 206  *  send_unix_sock
 207  *
 208  *  Send data on a unix socket using the liblttsessiondcomm API.
 209  *
 210  *  Return lttcomm error code.
 211  */
 212 static 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
 222 /*
 223  *      connect_app
 224  *
 225  *      Return a socket connected to the libust communication socket
 226  *      of the application identified by the pid.
 227  *
 228  *      If the pid is not found in the traceable list,
 229  *      return -1 to indicate error.
 230  */
 231 static int connect_app(pid_t pid)
 232 {
 233         int sock;
 234         struct ltt_traceable_app *lta;
 235
 236         lta = find_app_by_pid(pid);
 237         if (lta == NULL) {
 238                 /* App not found */
 239                 return -1;
 240         }
 241
 242         sock = ustctl_connect_pid(lta->pid);
 243         if (sock < 0) {
 244                 ERR("Fail connecting to the PID %d\n", pid);
 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  */
 259 static 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
 276 error:
 277         return ret;
 278 }
 279
 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  */
 287 static 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
 321 error:
 322         return ret;
 323 }
 324
 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  */
 331 static 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
 357 error:
 358         return ret;
 359 }
 360
 361 /*
 362  *  copy_common_data
 363  *
 364  *  Copy common data between lttcomm_lttng_msg and lttcomm_session_msg
 365  */
 366 static 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;
 370
 371         /* Manage uuid */
 372         if (!uuid_is_null(lsm->session_id)) {
 373                 uuid_copy(llm->session_id, lsm->session_id);
 374         }
 375
 376         strncpy(llm->trace_name, lsm->trace_name, strlen(llm->trace_name));
 377         llm->trace_name[strlen(llm->trace_name) - 1] = '\0';
 378 }
 379
 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  */
 388 static int setup_data_buffer(char **buf, size_t s_data, struct lttcomm_lttng_msg *llm)
 389 {
 390         int ret = 0;
 391         size_t buf_size;
 392
 393         buf_size = sizeof(struct lttcomm_lttng_msg) + s_data;
 394         *buf = malloc(buf_size);
 395         if (*buf == NULL) {
 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;
 405         memcpy(*buf, llm, sizeof(struct lttcomm_lttng_msg));
 406
 407         return buf_size;
 408
 409 error:
 410         return ret;
 411 }
 412
 413 /*
 414  *      process_client_msg
 415  *
 416  *      This takes the lttcomm_session_msg struct and process the command requested
 417  *      by the client. It then creates response(s) and send it back to the
 418  *      given socket (sock).
 419  *
 420  *      Return any error encountered or 0 for success.
 421  */
 422 static int process_client_msg(int sock, struct lttcomm_session_msg *lsm)
 423 {
 424         int ret;
 425         int buf_size;
 426         size_t header_size;
 427         char *send_buf = NULL;
 428         struct lttcomm_lttng_msg llm;
 429
 430         /* Copy common data to identify the response
 431          * on the lttng client side.
 432          */
 433         copy_common_data(&llm, lsm);
 434
 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
 447         /* Default return code.
 448          * In our world, everything is OK... right? ;)
 449          */
 450         llm.ret_code = LTTCOMM_OK;
 451
 452         header_size = sizeof(struct lttcomm_lttng_msg);
 453
 454         /* Process by command type */
 455         switch (lsm->cmd_type) {
 456                 case LTTNG_CREATE_SESSION:
 457                 {
 458                         ret = create_session(lsm->session_name, &llm.session_id);
 459                         if (ret < 0) {
 460                                 if (ret == -1) {
 461                                         ret = LTTCOMM_EXIST_SESS;
 462                                 } else {
 463                                         ret = LTTCOMM_FATAL;
 464                                 }
 465                                 goto end;
 466                         }
 467
 468                         buf_size = setup_data_buffer(&send_buf, 0, &llm);
 469                         if (buf_size < 0) {
 470                                 ret = LTTCOMM_FATAL;
 471                                 goto end;
 472                         }
 473
 474                         break;
 475                 }
 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                 }
 488                 case UST_CREATE_TRACE:
 489                 {
 490                         ret = ust_create_trace(lsm->pid);
 491                         if (ret < 0) {
 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;
 496                                 goto end;
 497                         }
 498
 499                         /* No auxiliary data so only send the llm struct. */
 500                         goto end;
 501                 }
 502                 case UST_LIST_APPS:
 503                 {
 504                         unsigned int app_count = get_app_count();
 505                         /* Stop right now if no apps */
 506                         if (app_count == 0) {
 507                                 ret = LTTCOMM_NO_APPS;
 508                                 goto end;
 509                         }
 510
 511                         /* Setup data buffer and details for transmission */
 512                         buf_size = setup_data_buffer(&send_buf,
 513                                         sizeof(pid_t) * app_count, &llm);
 514                         if (buf_size < 0) {
 515                                 ret = LTTCOMM_FATAL;
 516                                 goto end;
 517                         }
 518
 519                         get_app_list_pids((pid_t *)(send_buf + header_size));
 520
 521                         break;
 522                 }
 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                 }
 530                 case LTTNG_LIST_SESSIONS:
 531                 {
 532                         unsigned int session_count = get_session_count();
 533                         /* Stop right now if no session */
 534                         if (session_count == 0) {
 535                                 ret = LTTCOMM_NO_SESS;
 536                                 goto end;
 537                         }
 538
 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;
 544                                 goto end;
 545                         }
 546
 547                         get_lttng_session((struct lttng_session *)(send_buf + header_size));
 548
 549                         break;
 550                 }
 551                 default:
 552                 {
 553                         /* Undefined command */
 554                         ret = LTTCOMM_UND;
 555                         goto end;
 556                 }
 557         }
 558
 559         ret = send_unix_sock(sock, send_buf, buf_size);
 560
 561         if (send_buf != NULL) {
 562                 free(send_buf);
 563         }
 564
 565         return ret;
 566
 567 end:
 568         /* Notify client of error */
 569         llm.ret_code = ret;
 570         llm.size_payload = 0;
 571         send_unix_sock(sock, (void*) &llm, sizeof(llm));
 572
 573         return ret;
 574 }
 575
 576 /*
 577  * usage function on stderr
 578  */
 579 static void usage(void)
 580 {
 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");
 590         fprintf(stderr, "  -v, --verbose             Verbose mode. Activate DBG() macro.\n");
 591 }
 592
 593 /*
 594  * daemon argument parsing
 595  */
 596 static int parse_args(int argc, char **argv)
 597 {
 598         int c;
 599
 600         static struct option long_options[] = {
 601                 { "client-sock", 1, 0, 'c' },
 602                 { "apps-sock", 1, 0, 'a' },
 603                 { "daemonize", 0, 0, 'd' },
 604                 { "sig-parent", 0, 0, 'S' },
 605                 { "help", 0, 0, 'h' },
 606                 { "group", 1, 0, 'g' },
 607                 { "version", 0, 0, 'V' },
 608                 { "quiet", 0, 0, 'q' },
 609                 { "verbose", 0, 0, 'v' },
 610                 { NULL, 0, 0, 0 }
 611         };
 612
 613         while (1) {
 614                 int option_index = 0;
 615                 c = getopt_long(argc, argv, "dhqvVS" "a:c:g:s:", long_options, &option_index);
 616                 if (c == -1) {
 617                         break;
 618                 }
 619
 620                 switch (c) {
 621                 case 0:
 622                         fprintf(stderr, "option %s", long_options[option_index].name);
 623                         if (optarg) {
 624                                 fprintf(stderr, " with arg %s\n", optarg);
 625                         }
 626                         break;
 627                 case 'c':
 628                         snprintf(client_unix_sock_path, PATH_MAX, "%s", optarg);
 629                         break;
 630                 case 'a':
 631                         snprintf(apps_unix_sock_path, PATH_MAX, "%s", optarg);
 632                         break;
 633                 case 'd':
 634                         opt_daemon = 1;
 635                         break;
 636                 case 'g':
 637                         opt_tracing_group = strdup(optarg);
 638                         break;
 639                 case 'h':
 640                         usage();
 641                         exit(EXIT_FAILURE);
 642                 case 'V':
 643                         fprintf(stdout, "%s\n", VERSION);
 644                         exit(EXIT_SUCCESS);
 645                 case 'S':
 646                         opt_sig_parent = 1;
 647                         break;
 648                 case 'q':
 649                         opt_quiet = 1;
 650                         break;
 651                 case 'v':
 652                         opt_verbose = 1;
 653                         break;
 654                 default:
 655                         /* Unknown option or other error.
 656                          * Error is printed by getopt, just return */
 657                         return -1;
 658                 }
 659         }
 660
 661         return 0;
 662 }
 663
 664 /*
 665  *      init_daemon_socket
 666  *
 667  *      Creates the two needed socket by the daemon.
 668  *          apps_socket - The communication socket for all UST apps.
 669  *          client_socket - The communication of the cli tool (lttng).
 670  */
 671 static int init_daemon_socket()
 672 {
 673         int ret = 0;
 674         mode_t old_umask;
 675
 676         old_umask = umask(0);
 677
 678         /* Create client tool unix socket */
 679         client_socket = lttcomm_create_unix_sock(client_unix_sock_path);
 680         if (client_socket < 0) {
 681                 ret = -1;
 682                 goto end;
 683         }
 684
 685         /* File permission MUST be 660 */
 686         ret = chmod(client_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 687         if (ret < 0) {
 688                 perror("chmod");
 689                 goto end;
 690         }
 691
 692         /* Create the application unix socket */
 693         apps_socket = lttcomm_create_unix_sock(apps_unix_sock_path);
 694         if (apps_socket < 0) {
 695                 ret = -1;
 696                 goto end;
 697         }
 698
 699         /* File permission MUST be 660 */
 700         ret = chmod(apps_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
 701         if (ret < 0) {
 702                 perror("chmod");
 703                 goto end;
 704         }
 705
 706 end:
 707         umask(old_umask);
 708         return ret;
 709 }
 710
 711 /*
 712  *      check_existing_daemon
 713  *
 714  *      Check if the global socket is available.
 715  *  If yes, error is returned.
 716  */
 717 static int check_existing_daemon()
 718 {
 719         int ret;
 720
 721         ret = access(client_unix_sock_path, F_OK);
 722         if (ret == 0) {
 723                 ret = access(apps_unix_sock_path, F_OK);
 724         }
 725
 726         return ret;
 727 }
 728
 729 /*
 730  *  get_home_dir
 731  *
 732  *  Return pointer to home directory path using
 733  *  the env variable HOME.
 734  *
 735  *  Default : /tmp
 736  */
 737 static const char *get_home_dir(void)
 738 {
 739         const char *home_path;
 740
 741         if ((home_path = (const char *) getenv("HOME")) == NULL) {
 742                 home_path = default_home_dir;
 743         }
 744
 745         return home_path;
 746 }
 747
 748 /*
 749  *  set_socket_perms
 750  *
 751  *      Set the tracing group gid onto the client socket.
 752  */
 753 static int set_socket_perms(void)
 754 {
 755         int ret;
 756         struct group *grp;
 757
 758         /* Decide which group name to use */
 759         (opt_tracing_group != NULL) ?
 760                 (grp = getgrnam(opt_tracing_group)) :
 761                 (grp = getgrnam(default_tracing_group));
 762
 763         if (grp == NULL) {
 764                 ERR("Missing tracing group. Aborting execution.\n");
 765                 ret = -1;
 766                 goto end;
 767         }
 768
 769         ret = chown(client_unix_sock_path, 0, grp->gr_gid);
 770         if (ret < 0) {
 771                 perror("chown");
 772         }
 773
 774 end:
 775         return ret;
 776 }
 777
 778 /*
 779  *  set_signal_handler
 780  *
 781  *  Setup signal handler for :
 782  *              SIGINT, SIGTERM, SIGPIPE
 783  */
 784 static int set_signal_handler(void)
 785 {
 786         int ret = 0;
 787         struct sigaction sa;
 788         sigset_t sigset;
 789
 790         if ((ret = sigemptyset(&sigset)) < 0) {
 791                 perror("sigemptyset");
 792                 return ret;
 793         }
 794
 795         sa.sa_handler = sighandler;
 796         sa.sa_mask = sigset;
 797         sa.sa_flags = 0;
 798         if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
 799                 perror("sigaction");
 800                 return ret;
 801         }
 802
 803         if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
 804                 perror("sigaction");
 805                 return ret;
 806         }
 807
 808         if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
 809                 perror("sigaction");
 810                 return ret;
 811         }
 812
 813         return ret;
 814 }
 815
 816 /**
 817  *  sighandler
 818  *
 819  *  Signal handler for the daemon
 820  */
 821 static void sighandler(int sig)
 822 {
 823         switch (sig) {
 824                 case SIGPIPE:
 825                         return;
 826                 case SIGINT:
 827                 case SIGTERM:
 828                         cleanup();
 829                         break;
 830                 default:
 831                         break;
 832         }
 833
 834         exit(EXIT_SUCCESS);
 835 }
 836
 837 /*
 838  *  cleanup
 839  *
 840  *  Cleanup the daemon on exit
 841  */
 842 static void cleanup()
 843 {
 844         /* <fun> */
 845         MSG("\n%c[%d;%dm*** assert failed *** ==> %c[%dm", 27,1,31,27,0);
 846         MSG("%c[%d;%dmMatthew, BEET driven development works!%c[%dm",27,1,33,27,0);
 847         /* </fun> */
 848
 849         unlink(client_unix_sock_path);
 850         unlink(apps_unix_sock_path);
 851 }
 852
 853 /*
 854  * main
 855  */
 856 int main(int argc, char **argv)
 857 {
 858         int i;
 859         int ret = 0;
 860         void *status;
 861         pthread_t threads[2];
 862
 863         /* Parse arguments */
 864         progname = argv[0];
 865         if ((ret = parse_args(argc, argv) < 0)) {
 866                 goto error;
 867         }
 868
 869         /* Daemonize */
 870         if (opt_daemon) {
 871                 ret = daemon(0, 0);
 872                 if (ret < 0) {
 873                         perror("daemon");
 874                         goto error;
 875                 }
 876         }
 877
 878         /* Check if daemon is UID = 0 */
 879         is_root = !getuid();
 880
 881         /* Set all sockets path */
 882         if (is_root) {
 883                 if (strlen(apps_unix_sock_path) == 0) {
 884                         (snprintf(apps_unix_sock_path, PATH_MAX,
 885                                         DEFAULT_GLOBAL_APPS_UNIX_SOCK));
 886                 }
 887
 888                 if (strlen(client_unix_sock_path) == 0) {
 889                         (snprintf(client_unix_sock_path, PATH_MAX,
 890                                         DEFAULT_GLOBAL_CLIENT_UNIX_SOCK));
 891                 }
 892         } else {
 893                 if (strlen(apps_unix_sock_path) == 0) {
 894                         (snprintf(apps_unix_sock_path, PATH_MAX,
 895                                         DEFAULT_HOME_APPS_UNIX_SOCK, get_home_dir()));
 896                 }
 897
 898                 /* Set the cli tool unix socket path */
 899                 if (strlen(client_unix_sock_path) == 0) {
 900                         (snprintf(client_unix_sock_path, PATH_MAX,
 901                                         DEFAULT_HOME_CLIENT_UNIX_SOCK, get_home_dir()));
 902                 }
 903         }
 904
 905         /* See if daemon already exist. If any of the two
 906          * socket needed by the daemon are present, this test fails
 907          */
 908         if ((ret = check_existing_daemon()) == 0) {
 909                 ERR("Already running daemon.\n");
 910                 /* We do not goto error because we must not
 911                  * cleanup() because a daemon is already working.
 912                  */
 913                 return EXIT_FAILURE;
 914         }
 915
 916         if (set_signal_handler() < 0) {
 917                 goto error;
 918         }
 919
 920         /* Setup the two needed unix socket */
 921         if (init_daemon_socket() < 0) {
 922                 goto error;
 923         }
 924
 925         /* Set credentials to socket */
 926         if (is_root && (set_socket_perms() < 0)) {
 927                 goto error;
 928         }
 929
 930         /* Get parent pid if -S, --sig-parent is specified. */
 931         if (opt_sig_parent) {
 932                 ppid = getppid();
 933         }
 934
 935         while (1) {
 936                 /* Create thread to manage the client socket */
 937                 ret = pthread_create(&threads[0], NULL, thread_manage_clients, (void *) NULL);
 938                 if (ret != 0) {
 939                         perror("pthread_create");
 940                         goto error;
 941                 }
 942
 943                 /* Create thread to manage application socket */
 944                 ret = pthread_create(&threads[1], NULL, thread_manage_apps, (void *) NULL);
 945                 if (ret != 0) {
 946                         perror("pthread_create");
 947                         goto error;
 948                 }
 949
 950                 for (i = 0; i < 2; i++) {
 951                         ret = pthread_join(threads[i], &status);
 952                         if (ret != 0) {
 953                                 perror("pthread_join");
 954                                 goto error;
 955                         }
 956                 }
 957         }
 958
 959         cleanup();
 960         return 0;
 961
 962 error:
 963         cleanup();
 964
 965         return EXIT_FAILURE;
 966 }