unix-stream-server.c

   1 #include "git-compat-util.h"
   2 #include "lockfile.h"
   3 #include "unix-socket.h"
   4 #include "unix-stream-server.h"
   5
   6 #define DEFAULT_LOCK_TIMEOUT (100)
   7
   8 /*
   9  * Try to connect to a unix domain socket at `path` (if it exists) and
  10  * see if there is a server listening.
  11  *
  12  * We don't know if the socket exists, whether a server died and
  13  * failed to cleanup, or whether we have a live server listening, so
  14  * we "poke" it.
  15  *
  16  * We immediately hangup without sending/receiving any data because we
  17  * don't know anything about the protocol spoken and don't want to
  18  * block while writing/reading data.  It is sufficient to just know
  19  * that someone is listening.
  20  */
  21 static int is_another_server_alive(const char *path,
  22                                    const struct unix_stream_listen_opts *opts)
  23 {
  24         int fd = unix_stream_connect(path, opts->disallow_chdir);
  25         if (fd >= 0) {
  26                 close(fd);
  27                 return 1;
  28         }
  29
  30         return 0;
  31 }
  32
  33 int unix_ss_create(const char *path,
  34                    const struct unix_stream_listen_opts *opts,
  35                    long timeout_ms,
  36                    struct unix_ss_socket **new_server_socket)
  37 {
  38         struct lock_file lock = LOCK_INIT;
  39         int fd_socket;
  40         struct unix_ss_socket *server_socket;
  41
  42         *new_server_socket = NULL;
  43
  44         if (timeout_ms < 0)
  45                 timeout_ms = DEFAULT_LOCK_TIMEOUT;
  46
  47         /*
  48          * Create a lock at "<path>.lock" if we can.
  49          */
  50         if (hold_lock_file_for_update_timeout(&lock, path, 0, timeout_ms) < 0)
  51                 return -1;
  52
  53         /*
  54          * If another server is listening on "<path>" give up.  We do not
  55          * want to create a socket and steal future connections from them.
  56          */
  57         if (is_another_server_alive(path, opts)) {
  58                 rollback_lock_file(&lock);
  59                 errno = EADDRINUSE;
  60                 return -2;
  61         }
  62
  63         /*
  64          * Create and bind to a Unix domain socket at "<path>".
  65          */
  66         fd_socket = unix_stream_listen(path, opts);
  67         if (fd_socket < 0) {
  68                 int saved_errno = errno;
  69                 rollback_lock_file(&lock);
  70                 errno = saved_errno;
  71                 return -1;
  72         }
  73
  74         server_socket = xcalloc(1, sizeof(*server_socket));
  75         server_socket->path_socket = strdup(path);
  76         server_socket->fd_socket = fd_socket;
  77         lstat(path, &server_socket->st_socket);
  78
  79         *new_server_socket = server_socket;
  80
  81         /*
  82          * Always rollback (just delete) "<path>.lock" because we already created
  83          * "<path>" as a socket and do not want to commit_lock to do the atomic
  84          * rename trick.
  85          */
  86         rollback_lock_file(&lock);
  87
  88         return 0;
  89 }
  90
  91 void unix_ss_free(struct unix_ss_socket *server_socket)
  92 {
  93         if (!server_socket)
  94                 return;
  95
  96         if (server_socket->fd_socket >= 0) {
  97                 if (!unix_ss_was_stolen(server_socket))
  98                         unlink(server_socket->path_socket);
  99                 close(server_socket->fd_socket);
 100         }
 101
 102         free(server_socket->path_socket);
 103         free(server_socket);
 104 }
 105
 106 int unix_ss_was_stolen(struct unix_ss_socket *server_socket)
 107 {
 108         struct stat st_now;
 109
 110         if (!server_socket)
 111                 return 0;
 112
 113         if (lstat(server_socket->path_socket, &st_now) == -1)
 114                 return 1;
 115
 116         if (st_now.st_ino != server_socket->st_socket.st_ino)
 117                 return 1;
 118         if (st_now.st_dev != server_socket->st_socket.st_dev)
 119                 return 1;
 120
 121         if (!S_ISSOCK(st_now.st_mode))
 122                 return 1;
 123
 124         return 0;
 125 }