#include "git-compat-util.h"

#include "lockfile.h"

#include "unix-socket.h"

#include "unix-stream-server.h"

#define DEFAULT_LOCK_TIMEOUT (100)

/*

 * Try to connect to a unix domain socket at `path` (if it exists) and

 * see if there is a server listening.

 *

 * We don't know if the socket exists, whether a server died and

 * failed to cleanup, or whether we have a live server listening, so

 * we "poke" it.

 *

 * We immediately hangup without sending/receiving any data because we

 * don't know anything about the protocol spoken and don't want to

 * block while writing/reading data.  It is sufficient to just know

 * that someone is listening.

 */

static int is_another_server_alive(const char *path,

           const struct unix_stream_listen_opts *opts)

{

  int fd = unix_stream_connect(path, opts->disallow_chdir);

  if (fd >= 0) {

    close(fd);

    return 1;

  }

  return 0;

}

int unix_ss_create(const char *path,

       const struct unix_stream_listen_opts *opts,

       long timeout_ms,

       struct unix_ss_socket **new_server_socket)

{

  struct lock_file lock = LOCK_INIT;

  int fd_socket;

  struct unix_ss_socket *server_socket;

  *new_server_socket = NULL;

  if (timeout_ms < 0)

    timeout_ms = DEFAULT_LOCK_TIMEOUT;

  /*

   * Create a lock at "<path>.lock" if we can.

   */

  if (hold_lock_file_for_update_timeout(&lock, path, 0, timeout_ms) < 0)

    return -1;

  /*

   * If another server is listening on "<path>" give up.  We do not

   * want to create a socket and steal future connections from them.

   */

  if (is_another_server_alive(path, opts)) {

    rollback_lock_file(&lock);

    errno = EADDRINUSE;

    return -2;

  }

  /*

   * Create and bind to a Unix domain socket at "<path>".

   */

  fd_socket = unix_stream_listen(path, opts);

  if (fd_socket < 0) {

    int saved_errno = errno;

    rollback_lock_file(&lock);

    errno = saved_errno;

    return -1;

  }

  server_socket = xcalloc(1, sizeof(*server_socket));

  server_socket->path_socket = strdup(path);

  server_socket->fd_socket = fd_socket;

  lstat(path, &server_socket->st_socket);

  *new_server_socket = server_socket;

  /*

   * Always rollback (just delete) "<path>.lock" because we already created

   * "<path>" as a socket and do not want to commit_lock to do the atomic

   * rename trick.

   */

  rollback_lock_file(&lock);

  return 0;

}

void unix_ss_free(struct unix_ss_socket *server_socket)

{

  if (!server_socket)

    return;

  if (server_socket->fd_socket >= 0) {

    if (!unix_ss_was_stolen(server_socket))

      unlink(server_socket->path_socket);

    close(server_socket->fd_socket);

  }

  free(server_socket->path_socket);

  free(server_socket);

}

int unix_ss_was_stolen(struct unix_ss_socket *server_socket)

{

  struct stat st_now;

  if (!server_socket)

    return 0;

  if (lstat(server_socket->path_socket, &st_now) == -1)

    return 1;

  if (st_now.st_ino != server_socket->st_socket.st_ino)

    return 1;

  if (st_now.st_dev != server_socket->st_socket.st_dev)

    return 1;

  if (!S_ISSOCK(st_now.st_mode))

    return 1;

  return 0;

}