| #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; |
| } |