src/unixsock.c

   1 /**
   2  * collectd - src/unixsock.c
   3  * Copyright (C) 2007,2008  Florian octo Forster
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian octo Forster <octo at collectd.org>
  25  **/
  26
  27 #include "collectd.h"
  28 #include "common.h"
  29 #include "plugin.h"
  30 #include "configfile.h"
  31
  32 #include "utils_cmd_flush.h"
  33 #include "utils_cmd_getval.h"
  34 #include "utils_cmd_getthreshold.h"
  35 #include "utils_cmd_listval.h"
  36 #include "utils_cmd_putval.h"
  37 #include "utils_cmd_putnotif.h"
  38
  39 /* Folks without pthread will need to disable this plugin. */
  40 #include <pthread.h>
  41
  42 #include <sys/socket.h>
  43 #include <sys/stat.h>
  44 #include <sys/un.h>
  45
  46 #include <grp.h>
  47
  48 #ifndef UNIX_PATH_MAX
  49 # define UNIX_PATH_MAX sizeof (((struct sockaddr_un *)0)->sun_path)
  50 #endif
  51
  52 #define US_DEFAULT_PATH LOCALSTATEDIR"/run/"PACKAGE_NAME"-unixsock"
  53
  54 /*
  55  * Private variables
  56  */
  57 /* valid configuration file keys */
  58 static const char *config_keys[] =
  59 {
  60         "SocketFile",
  61         "SocketGroup",
  62         "SocketPerms",
  63         "DeleteSocket"
  64 };
  65 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
  66
  67 static int loop = 0;
  68
  69 /* socket configuration */
  70 static int   sock_fd    = -1;
  71 static char *sock_file  = NULL;
  72 static char *sock_group = NULL;
  73 static int   sock_perms = S_IRWXU | S_IRWXG;
  74 static _Bool delete_socket = 0;
  75
  76 static pthread_t listen_thread = (pthread_t) 0;
  77
  78 /*
  79  * Functions
  80  */
  81 static int us_open_socket (void)
  82 {
  83         struct sockaddr_un sa;
  84         int status;
  85
  86         sock_fd = socket (PF_UNIX, SOCK_STREAM, 0);
  87         if (sock_fd < 0)
  88         {
  89                 char errbuf[1024];
  90                 ERROR ("unixsock plugin: socket failed: %s",
  91                                 sstrerror (errno, errbuf, sizeof (errbuf)));
  92                 return (-1);
  93         }
  94
  95         memset (&sa, '\0', sizeof (sa));
  96         sa.sun_family = AF_UNIX;
  97         sstrncpy (sa.sun_path, (sock_file != NULL) ? sock_file : US_DEFAULT_PATH,
  98                         sizeof (sa.sun_path));
  99
 100         DEBUG ("unixsock plugin: socket path = %s", sa.sun_path);
 101
 102         if (delete_socket)
 103         {
 104                 errno = 0;
 105                 status = unlink (sa.sun_path);
 106                 if ((status != 0) && (errno != ENOENT))
 107                 {
 108                         char errbuf[1024];
 109                         WARNING ("unixsock plugin: Deleting socket file \"%s\" failed: %s",
 110                                         sa.sun_path,
 111                                         sstrerror (errno, errbuf, sizeof (errbuf)));
 112                 }
 113                 else if (status == 0)
 114                 {
 115                         INFO ("unixsock plugin: Successfully deleted socket file \"%s\".",
 116                                         sa.sun_path);
 117                 }
 118         }
 119
 120         status = bind (sock_fd, (struct sockaddr *) &sa, sizeof (sa));
 121         if (status != 0)
 122         {
 123                 char errbuf[1024];
 124                 sstrerror (errno, errbuf, sizeof (errbuf));
 125                 ERROR ("unixsock plugin: bind failed: %s", errbuf);
 126                 close (sock_fd);
 127                 sock_fd = -1;
 128                 return (-1);
 129         }
 130
 131         chmod (sa.sun_path, sock_perms);
 132
 133         status = listen (sock_fd, 8);
 134         if (status != 0)
 135         {
 136                 char errbuf[1024];
 137                 ERROR ("unixsock plugin: listen failed: %s",
 138                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 139                 close (sock_fd);
 140                 sock_fd = -1;
 141                 return (-1);
 142         }
 143
 144         do
 145         {
 146                 char *grpname;
 147                 struct group *g;
 148                 struct group sg;
 149                 char grbuf[2048];
 150
 151                 grpname = (sock_group != NULL) ? sock_group : COLLECTD_GRP_NAME;
 152                 g = NULL;
 153
 154                 status = getgrnam_r (grpname, &sg, grbuf, sizeof (grbuf), &g);
 155                 if (status != 0)
 156                 {
 157                         char errbuf[1024];
 158                         WARNING ("unixsock plugin: getgrnam_r (%s) failed: %s", grpname,
 159                                         sstrerror (errno, errbuf, sizeof (errbuf)));
 160                         break;
 161                 }
 162                 if (g == NULL)
 163                 {
 164                         WARNING ("unixsock plugin: No such group: `%s'",
 165                                         grpname);
 166                         break;
 167                 }
 168
 169                 if (chown ((sock_file != NULL) ? sock_file : US_DEFAULT_PATH,
 170                                         (uid_t) -1, g->gr_gid) != 0)
 171                 {
 172                         char errbuf[1024];
 173                         WARNING ("unixsock plugin: chown (%s, -1, %i) failed: %s",
 174                                         (sock_file != NULL) ? sock_file : US_DEFAULT_PATH,
 175                                         (int) g->gr_gid,
 176                                         sstrerror (errno, errbuf, sizeof (errbuf)));
 177                 }
 178         } while (0);
 179
 180         return (0);
 181 } /* int us_open_socket */
 182
 183 static void *us_handle_client (void *arg)
 184 {
 185         int fdin;
 186         int fdout;
 187         FILE *fhin, *fhout;
 188
 189         fdin = *((int *) arg);
 190         free (arg);
 191         arg = NULL;
 192
 193         DEBUG ("unixsock plugin: us_handle_client: Reading from fd #%i", fdin);
 194
 195         fdout = dup (fdin);
 196         if (fdout < 0)
 197         {
 198                 char errbuf[1024];
 199                 ERROR ("unixsock plugin: dup failed: %s",
 200                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 201                 close (fdin);
 202                 pthread_exit ((void *) 1);
 203         }
 204
 205         fhin  = fdopen (fdin, "r");
 206         if (fhin == NULL)
 207         {
 208                 char errbuf[1024];
 209                 ERROR ("unixsock plugin: fdopen failed: %s",
 210                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 211                 close (fdin);
 212                 close (fdout);
 213                 pthread_exit ((void *) 1);
 214                 return ((void *) 1);
 215         }
 216
 217         fhout = fdopen (fdout, "w");
 218         if (fhout == NULL)
 219         {
 220                 char errbuf[1024];
 221                 ERROR ("unixsock plugin: fdopen failed: %s",
 222                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 223                 fclose (fhin); /* this closes fdin as well */
 224                 close (fdout);
 225                 pthread_exit ((void *) 1);
 226                 return ((void *) 1);
 227         }
 228
 229         /* change output buffer to line buffered mode */
 230         if (setvbuf (fhout, NULL, _IOLBF, 0) != 0)
 231         {
 232                 char errbuf[1024];
 233                 ERROR ("unixsock plugin: setvbuf failed: %s",
 234                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 235                 fclose (fhin);
 236                 fclose (fhout);
 237                 pthread_exit ((void *) 1);
 238                 return ((void *) 0);
 239         }
 240
 241         while (42)
 242         {
 243                 char buffer[1024];
 244                 char buffer_copy[1024];
 245                 char *fields[128];
 246                 int   fields_num;
 247                 int   len;
 248
 249                 errno = 0;
 250                 if (fgets (buffer, sizeof (buffer), fhin) == NULL)
 251                 {
 252                         if ((errno == EINTR) || (errno == EAGAIN))
 253                                 continue;
 254
 255                         if (errno != 0)
 256                         {
 257                                 char errbuf[1024];
 258                                 WARNING ("unixsock plugin: failed to read from socket #%i: %s",
 259                                                 fileno (fhin),
 260                                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 261                         }
 262                         break;
 263                 }
 264
 265                 len = strlen (buffer);
 266                 while ((len > 0)
 267                                 && ((buffer[len - 1] == '\n') || (buffer[len - 1] == '\r')))
 268                         buffer[--len] = '\0';
 269
 270                 if (len == 0)
 271                         continue;
 272
 273                 sstrncpy (buffer_copy, buffer, sizeof (buffer_copy));
 274
 275                 fields_num = strsplit (buffer_copy, fields,
 276                                 sizeof (fields) / sizeof (fields[0]));
 277                 if (fields_num < 1)
 278                 {
 279                         fprintf (fhout, "-1 Internal error\n");
 280                         fclose (fhin);
 281                         fclose (fhout);
 282                         pthread_exit ((void *) 1);
 283                         return ((void *) 1);
 284                 }
 285
 286                 if (strcasecmp (fields[0], "getval") == 0)
 287                 {
 288                         handle_getval (fhout, buffer);
 289                 }
 290                 else if (strcasecmp (fields[0], "getthreshold") == 0)
 291                 {
 292                         handle_getthreshold (fhout, buffer);
 293                 }
 294                 else if (strcasecmp (fields[0], "putval") == 0)
 295                 {
 296                         handle_putval (fhout, buffer);
 297                 }
 298                 else if (strcasecmp (fields[0], "listval") == 0)
 299                 {
 300                         handle_listval (fhout, buffer);
 301                 }
 302                 else if (strcasecmp (fields[0], "putnotif") == 0)
 303                 {
 304                         handle_putnotif (fhout, buffer);
 305                 }
 306                 else if (strcasecmp (fields[0], "flush") == 0)
 307                 {
 308                         handle_flush (fhout, buffer);
 309                 }
 310                 else
 311                 {
 312                         if (fprintf (fhout, "-1 Unknown command: %s\n", fields[0]) < 0)
 313                         {
 314                                 char errbuf[1024];
 315                                 WARNING ("unixsock plugin: failed to write to socket #%i: %s",
 316                                                 fileno (fhout),
 317                                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 318                                 break;
 319                         }
 320                 }
 321         } /* while (fgets) */
 322
 323         DEBUG ("unixsock plugin: us_handle_client: Exiting..");
 324         fclose (fhin);
 325         fclose (fhout);
 326
 327         pthread_exit ((void *) 0);
 328         return ((void *) 0);
 329 } /* void *us_handle_client */
 330
 331 static void *us_server_thread (void __attribute__((unused)) *arg)
 332 {
 333         int  status;
 334         int *remote_fd;
 335         pthread_t th;
 336         pthread_attr_t th_attr;
 337
 338         pthread_attr_init (&th_attr);
 339         pthread_attr_setdetachstate (&th_attr, PTHREAD_CREATE_DETACHED);
 340
 341         if (us_open_socket () != 0)
 342                 pthread_exit ((void *) 1);
 343
 344         while (loop != 0)
 345         {
 346                 DEBUG ("unixsock plugin: Calling accept..");
 347                 status = accept (sock_fd, NULL, NULL);
 348                 if (status < 0)
 349                 {
 350                         char errbuf[1024];
 351
 352                         if (errno == EINTR)
 353                                 continue;
 354
 355                         ERROR ("unixsock plugin: accept failed: %s",
 356                                         sstrerror (errno, errbuf, sizeof (errbuf)));
 357                         close (sock_fd);
 358                         sock_fd = -1;
 359                         pthread_attr_destroy (&th_attr);
 360                         pthread_exit ((void *) 1);
 361                 }
 362
 363                 remote_fd = (int *) malloc (sizeof (int));
 364                 if (remote_fd == NULL)
 365                 {
 366                         char errbuf[1024];
 367                         WARNING ("unixsock plugin: malloc failed: %s",
 368                                         sstrerror (errno, errbuf, sizeof (errbuf)));
 369                         close (status);
 370                         continue;
 371                 }
 372                 *remote_fd = status;
 373
 374                 DEBUG ("Spawning child to handle connection on fd #%i", *remote_fd);
 375
 376                 status = plugin_thread_create (&th, &th_attr,
 377                                 us_handle_client, (void *) remote_fd);
 378                 if (status != 0)
 379                 {
 380                         char errbuf[1024];
 381                         WARNING ("unixsock plugin: pthread_create failed: %s",
 382                                         sstrerror (errno, errbuf, sizeof (errbuf)));
 383                         close (*remote_fd);
 384                         free (remote_fd);
 385                         continue;
 386                 }
 387         } /* while (loop) */
 388
 389         close (sock_fd);
 390         sock_fd = -1;
 391         pthread_attr_destroy (&th_attr);
 392
 393         status = unlink ((sock_file != NULL) ? sock_file : US_DEFAULT_PATH);
 394         if (status != 0)
 395         {
 396                 char errbuf[1024];
 397                 NOTICE ("unixsock plugin: unlink (%s) failed: %s",
 398                                 (sock_file != NULL) ? sock_file : US_DEFAULT_PATH,
 399                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 400         }
 401
 402         return ((void *) 0);
 403 } /* void *us_server_thread */
 404
 405 static int us_config (const char *key, const char *val)
 406 {
 407         if (strcasecmp (key, "SocketFile") == 0)
 408         {
 409                 char *new_sock_file = strdup (val);
 410                 if (new_sock_file == NULL)
 411                         return (1);
 412
 413                 sfree (sock_file);
 414                 sock_file = new_sock_file;
 415         }
 416         else if (strcasecmp (key, "SocketGroup") == 0)
 417         {
 418                 char *new_sock_group = strdup (val);
 419                 if (new_sock_group == NULL)
 420                         return (1);
 421
 422                 sfree (sock_group);
 423                 sock_group = new_sock_group;
 424         }
 425         else if (strcasecmp (key, "SocketPerms") == 0)
 426         {
 427                 sock_perms = (int) strtol (val, NULL, 8);
 428         }
 429         else if (strcasecmp (key, "DeleteSocket") == 0)
 430         {
 431                 if (IS_TRUE (val))
 432                         delete_socket = 1;
 433                 else
 434                         delete_socket = 0;
 435         }
 436         else
 437         {
 438                 return (-1);
 439         }
 440
 441         return (0);
 442 } /* int us_config */
 443
 444 static int us_init (void)
 445 {
 446         static int have_init = 0;
 447
 448         int status;
 449
 450         /* Initialize only once. */
 451         if (have_init != 0)
 452                 return (0);
 453         have_init = 1;
 454
 455         loop = 1;
 456
 457         status = plugin_thread_create (&listen_thread, NULL,
 458                         us_server_thread, NULL);
 459         if (status != 0)
 460         {
 461                 char errbuf[1024];
 462                 ERROR ("unixsock plugin: pthread_create failed: %s",
 463                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 464                 return (-1);
 465         }
 466
 467         return (0);
 468 } /* int us_init */
 469
 470 static int us_shutdown (void)
 471 {
 472         void *ret;
 473
 474         loop = 0;
 475
 476         if (listen_thread != (pthread_t) 0)
 477         {
 478                 pthread_kill (listen_thread, SIGTERM);
 479                 pthread_join (listen_thread, &ret);
 480                 listen_thread = (pthread_t) 0;
 481         }
 482
 483         plugin_unregister_init ("unixsock");
 484         plugin_unregister_shutdown ("unixsock");
 485
 486         return (0);
 487 } /* int us_shutdown */
 488
 489 void module_register (void)
 490 {
 491         plugin_register_config ("unixsock", us_config,
 492                         config_keys, config_keys_num);
 493         plugin_register_init ("unixsock", us_init);
 494         plugin_register_shutdown ("unixsock", us_shutdown);
 495 } /* void module_register (void) */
 496
 497 /* vim: set sw=4 ts=4 sts=4 tw=78 : */