/**
 * coopgammad -- Cooperative gamma server
 * Copyright (C) 2016  Mattias Andrée (maandree@kth.se)
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "kernel.h"
#include "../state.h"
#include "../util.h"

#include <libgamma.h>

#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <errno.h>
#include <fcntl.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>



/**
 * Get the pathname of the runtime file
 * 
 * @param   suffix  The suffix for the file
 * @return          The pathname of the file, `NULL` on error
 */
GCC_ONLY(__attribute__((malloc, nonnull)))
static char* get_pathname(const char* restrict suffix)
{
  const char* restrict rundir = getenv("XDG_RUNTIME_DIR");
  const char* restrict username = "";
  char* name = NULL;
  char* p;
  char* restrict rc;
  struct passwd* restrict pw;
  size_t n;
  int saved_errno;
  
  if (sitename)
    {
      name = memdup(sitename, strlen(sitename) + 1);
      if (name == NULL)
	goto fail;
    }
  else if ((name = libgamma_method_default_site(method)))
    {
      name = memdup(name, strlen(name) + 1);
      if (name == NULL)
	goto fail;
    }
  
  if (name != NULL)
    switch (method)
      {
      case LIBGAMMA_METHOD_X_RANDR:
      case LIBGAMMA_METHOD_X_VIDMODE:
	if ((p = strrchr(name, ':')))
	  if ((p = strchr(p, '.')))
	    *p = '\0';
	break;
      default:
	break;
      }
  
  if (!rundir || !*rundir)
    rundir = "/tmp";
  
  if ((pw = getpwuid(getuid())))
    username = pw->pw_name ? pw->pw_name : "";
  
  n = sizeof("/.coopgammad/~/.") + 3 * sizeof(int);
  n += strlen(rundir) + strlen(username) + ((name != NULL) ? strlen(name) : 0) + strlen(suffix);
  if (!(rc = malloc(n)))
    goto fail;
  sprintf(rc, "%s/.coopgammad/~%s/%i%s%s%s",
	  rundir, username, method, name ? "." : "", name ? name : "", suffix);
  free(name);
  return rc;
  
 fail:
  saved_errno = errno;
  free(name);
  errno = saved_errno;
  return NULL;
}


/**
 * Get the pathname of the socket
 * 
 * @return  The pathname of the socket, `NULL` on error
 */
char* get_socket_pathname(void)
{
  return get_pathname(".socket");
}


/**
 * Get the pathname of the PID file
 * 
 * @return  The pathname of the PID file, `NULL` on error
 */
char* get_pidfile_pathname(void)
{
  return get_pathname(".pid");
}


/**
 * Get the pathname of the state file
 * 
 * @return  The pathname of the state file, `NULL` on error
 */
char* get_state_pathname(void)
{
  return get_pathname(".state");
}


/**
 * Check whether a PID file is outdated
 * 
 * @param   pidpath  The PID file
 * @param   token    An environment variable (including both key and value)
 *                   that must exist in the process if it is a coopgammad process
 * @return           -1: An error occurred
 *                    0: The service is already running
 *                    1: The PID file is outdated
 */
GCC_ONLY(__attribute__((nonnull)))
static int is_pidfile_reusable(const char* restrict pidpath, const char* restrict token)
{
  /* PORTERS: /proc/$PID/environ is Linux specific */
  
  char temp[sizeof("/proc//environ") + 3 * sizeof(long long int)];
  int fd = -1, saved_errno, tries = 0;
  char* content = NULL;
  char* p;
  pid_t pid = 0;
  size_t n;
#if defined(HAVE_LINUX_PROCFS)
  char* end;
#else
  (void) token;
#endif
  
  /* Get PID */
 retry:
  fd = open(pidpath, O_RDONLY);
  if (fd < 0)
    return -1;
  content = nread(fd, &n);
  if (content == NULL)
    goto fail;
  close(fd), fd = -1;
  
  if (n == 0)
    {
      if (++tries > 1)
	goto bad;
      msleep(100); /* 1 tenth of a second */
      goto retry;
    }
  
  if (('0' > content[0]) || (content[0] > '9'))
    goto bad;
  if ((content[0] == '0') && ('0' <= content[1]) && (content[1] <= '9'))
    goto bad;
  for (p = content; *p; p++)
    if (('0' <= *p) && (*p <= '9'))
      pid = pid * 10 + (*p & 15);
    else
      break;
  if (*p++ != '\n')
    goto bad;
  if (*p)
    goto bad;
  if ((size_t)(p - content) != n)
    goto bad;
  sprintf(temp, "%llu\n", (unsigned long long)pid);
  if (strcmp(content, temp))
    goto bad;
  free(content);
  
  /* Validate PID */
#if defined(HAVE_LINUX_PROCFS)
  sprintf(temp, "/proc/%llu/environ", (unsigned long long)pid);
  fd = open(temp, O_RDONLY);
  if (fd < 0)
    return ((errno == ENOENT) || (errno == EACCES)) ? 1 : -1;
  content = nread(fd, &n);
  if (content == NULL)
    goto fail;
  close(fd), fd = -1;
  
  for (end = (p = content) + n; p != end; p = strchr(p, '\0') + 1)
    if (!strcmp(p, token))
      return free(content), 0;
  free(content);
#else
  if ((kill(pid, 0) == 0) || (errno == EINVAL))
    return 0;
#endif
  
  return 1;
 bad:
  fprintf(stderr, "%s: pid file contains invalid content: %s\n", argv0, pidpath);
  errno = 0;
  return -1;
 fail:
  saved_errno = errno;
  free(content);
  if (fd >= 0)
    close(fd);
  errno = saved_errno;
  return -1;
}


/**
 * Create PID file
 * 
 * @param   pidpath  The pathname of the PID file
 * @return           Zero on success, -1 on error,
 *                   -2 if the service is already running
 */
int create_pidfile(char* pidpath)
{
  int fd = -1, r, saved_errno;
  char* p;
  char* restrict token = NULL;
  
  /* Create token used to validate the service. */
  token = malloc(sizeof("COOPGAMMAD_PIDFILE_TOKEN=") + strlen(pidpath));
  if (token == NULL)
    return -1;
  sprintf(token, "COOPGAMMAD_PIDFILE_TOKEN=%s", pidpath);
#if !defined(USE_VALGRIND)
  if (putenv(token))
    goto putenv_fail;
  /* `token` must not be free! */
#else
  {
    static char static_token[sizeof("COOPGAMMAD_PIDFILE_TOKEN=") + PATH_MAX];
    if (strlen(pidpath) > PATH_MAX)
      abort();
    strcpy(static_token, token);
    if (putenv(static_token))
      goto fail;
  }
#endif
  
  /* Create PID file's directory. */
  for (p = pidpath; *p == '/'; p++);
  while ((p = strchr(p, '/')))
    {
      *p = '\0';
      if (mkdir(pidpath, 0755) < 0)
	if (errno != EEXIST)
	  {
	    *p = '/';
	    goto fail;
	  }
      *p++ = '/';
    }
  
  /* Create PID file. */
 retry:
  fd = open(pidpath, O_CREAT | O_EXCL | O_WRONLY, 0644);
  if (fd < 0)
    {
      if (errno == EINTR)
	goto retry;
      if (errno != EEXIST)
	return -1;
      r = is_pidfile_reusable(pidpath, token);
      if (r > 0)
	{
	  unlink(pidpath);
	  goto retry;
	}
      else if (r < 0)
	goto fail;
      fprintf(stderr, "%s: service is already running\n", argv0);
      errno = 0;
      return -2;
    }
  
  /* Write PID to PID file. */
  if (dprintf(fd, "%llu\n", (unsigned long long)getpid()) < 0)
    goto fail;
  
  /* Done */
#if defined(USE_VALGRIND)
  free(token);
#endif
  if (close(fd) < 0)
    if (errno != EINTR)
      return -1;
  return 0;
#if !defined(USE_VALGRIND)
 putenv_fail:
  saved_errno = errno;
  free(token);
  errno = saved_errno;
#endif
 fail:
  saved_errno = errno;
#if defined(USE_VALGRIND)
  free(token);
#endif
  if (fd >= 0)
    {
      close(fd);
      unlink(pidpath);
    }
  errno = saved_errno;
  return -1;
}


/**
 * Create socket and start listening
 * 
 * @param   socketpath  The pathname of the socket
 * @return              Zero on success, -1 on error
 */
int create_socket(const char* socketpath)
{
  struct sockaddr_un address;
  
  address.sun_family = AF_UNIX;
  if (strlen(socketpath) >= sizeof(address.sun_path))
    {
      errno = ENAMETOOLONG;
      return -1;
    }
  strcpy(address.sun_path, socketpath);
  unlink(socketpath);
  if ((socketfd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
    return -1;
  if (fchmod(socketfd, S_IRWXU) < 0)
    return -1;
  if (bind(socketfd, (struct sockaddr*)(&address), (socklen_t)sizeof(address)) < 0)
    return -1;
  if (listen(socketfd, SOMAXCONN) < 0)
    return -1;
  
  return 0;
}


/**
 * Close and unlink the socket
 * 
 * @param  socketpath  The pathname of the socket
 */
void close_socket(const char* socketpath)
{
  if (socketfd >= 0)
    {
      shutdown(socketfd, SHUT_RDWR);
      close(socketfd);
      unlink(socketpath);
    }
}