/* See LICENSE file for copyright and license details. */
#include "arg.h"
#include "util.h"
#include "state.h"
#include "servers-master.h"
#include "servers-kernel.h"
#include "servers-crtc.h"
#include "servers-gamma.h"
#include "servers-coopgamma.h"
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/**
* Number put in front of the marshalled data
* so the program an detect incompatible updates
*/
#define MARSHAL_VERSION 0
#ifndef GCC_ONLY
# if defined(__GNUC__) && !defined(__clang__)
# define GCC_ONLY(...) __VA_ARGS__
# else
# define GCC_ONLY(...) /* nothing */
# endif
#endif
/**
* Lists all function recognised adjustment methods,
* will call macro X with the code for the each
* adjustment method as the first argument and
* corresponding name as the second argument
*/
#define LIST_ADJUSTMENT_METHODS\
X(LIBGAMMA_METHOD_DUMMY, "dummy")\
X(LIBGAMMA_METHOD_X_RANDR, "randr")\
X(LIBGAMMA_METHOD_X_VIDMODE, "vidmode")\
X(LIBGAMMA_METHOD_LINUX_DRM, "drm")\
X(LIBGAMMA_METHOD_W32_GDI, "gdi")\
X(LIBGAMMA_METHOD_QUARTZ_CORE_GRAPHICS, "quartz")
/**
* Used by initialisation functions as their return type. If a
* value not listed here is returned by such function, it is the
* exit value the process shall exit with as soon as possible.
*/
enum init_status {
/**
* Initialisation was successful
*/
INIT_SUCCESS = -1,
/**
* Initialisation failed
*/
INIT_FAILURE = -2,
/**
* Server is already running
*/
INIT_RUNNING = -3,
};
/**
* The pathname of the PID file
*/
extern char *restrict pidpath;
char *restrict pidpath = NULL;
/**
* The pathname of the socket
*/
extern char *restrict socketpath;
char *restrict socketpath = NULL;
/**
* Called when the process receives
* a signal telling it to re-execute
*
* @param signo The received signal
*/
static void
sig_reexec(int signo)
{
int saved_errno = errno;
reexec = 1;
signal(signo, sig_reexec);
errno = saved_errno;
}
/**
* Called when the process receives
* a signal telling it to terminate
*
* @param signo The received signal
*/
static void
sig_terminate(int signo)
{
terminate = 1;
(void) signo;
}
/**
* Called when the process receives
* a signal telling it to disconnect
* from or reconnect to the site
*
* @param signo The received signal
*/
static void
sig_connection(int signo)
{
int saved_errno = errno;
connection = signo - SIGRTMIN + 1;
signal(signo, sig_connection);
errno = saved_errno;
}
/**
* Called when the process receives
* a signal telling it to dump its
* state to stderr
*
* @param signo The received signal
*/
static void
sig_info(int signo)
{
int saved_errno = errno;
char *env;
signal(signo, sig_info);
env = getenv("COOPGAMMAD_PIDFILE_TOKEN");
fprintf(stderr, "PID file token: %s\n", env ? env : "(null)");
fprintf(stderr, "PID file: %s\n", pidpath ? pidpath : "(null)");
fprintf(stderr, "Socket path: %s\n", socketpath ? socketpath : "(null)");
state_dump();
errno = saved_errno;
}
/**
* Parse adjustment method name (or stringised number)
*
* @param arg The adjustment method name (or stringised number)
* @return The adjustment method, -1 (negative) on error
*/
GCC_ONLY(__attribute__((__nonnull__)))
static int
get_method(const char *restrict arg)
{
#if LIBGAMMA_METHOD_MAX > 5
# warning libgamma has added more adjustment methods
#endif
const char *restrict p;
#define X(C, N) if (!strcmp(arg, N)) return C;
LIST_ADJUSTMENT_METHODS;
#undef X
if (!*arg || (/* avoid overflow: */ strlen(arg) > 4))
goto bad;
for (p = arg; *p; p++)
if ('0' > *p || *p > '9')
goto bad;
return atoi(arg);
bad:
fprintf(stderr, "%s: unrecognised adjustment method name: %s\n", argv0, arg);
errno = 0;
return -1;
}
/**
* Set up signal handlers
*
* @return Zero on success, -1 on error
*/
static int
set_up_signals(void)
{
if (signal(SIGUSR1, sig_reexec) == SIG_ERR ||
signal(SIGUSR2, sig_info) == SIG_ERR ||
#if defined(SIGINFO)
signal(SIGINFO, sig_info) == SIG_ERR ||
#endif
signal(SIGTERM, sig_terminate) == SIG_ERR ||
signal(SIGRTMIN + 0, sig_connection) == SIG_ERR ||
signal(SIGRTMIN + 1, sig_connection) == SIG_ERR)
return -1;
return 0;
}
/**
* Fork the process to the background
*
* @param keep_stderr Keep stderr open?
* @return An `enum init_status` value or an exit value
*/
static enum init_status
daemonise(int keep_stderr)
{
pid_t pid;
int fd = -1, saved_errno;
int notify_rw[2] = {-1, -1};
char a_byte = 0;
ssize_t got;
if (pipe(notify_rw) < 0)
goto fail;
if (notify_rw[0] <= STDERR_FILENO)
if ((notify_rw[0] = fcntl(notify_rw[0], F_DUPFD, STDERR_FILENO + 1)) < 0)
goto fail;
if (notify_rw[1] <= STDERR_FILENO)
if ((notify_rw[1] = fcntl(notify_rw[1], F_DUPFD, STDERR_FILENO + 1)) < 0)
goto fail;
if ((pid = fork()) < 0)
goto fail;
if (pid > 0) {
/* Original process (parent): */
waitpid(pid, NULL, 0);
close(notify_rw[1]), notify_rw[1] = -1;
got = read(notify_rw[0], &a_byte, 1);
if (got < 0)
goto fail;
close(notify_rw[0]);
errno = 0;
return got == 0 ? INIT_FAILURE : (enum init_status)0;
}
/* Intermediary process (child): */
close(notify_rw[0]), notify_rw[0] = -1;
if (setsid() < 0)
goto fail;
if ((pid = fork()) < 0)
goto fail;
if (pid > 0) {
/* Intermediary process (parent): */
return (enum init_status)0;
}
/* Daemon process (child): */
/* Replace std* with /dev/null */
fd = open("/dev/null", O_RDWR);
if (fd < 0 ||
dup2(fd, STDIN_FILENO) < 0 ||
dup2(fd, STDOUT_FILENO) < 0 ||
(keep_stderr && dup2(fd, STDERR_FILENO) < 0))
goto fail;
if (fd > STDERR_FILENO)
close(fd);
fd = -1;
/* Update PID file */
fd = open(pidpath, O_WRONLY);
if (fd < 0)
goto fail;
if (dprintf(fd, "%llu\n", (unsigned long long)getpid()) < 0)
goto fail;
close(fd);
fd = -1;
/* Notify */
if (write(notify_rw[1], &a_byte, 1) <= 0)
goto fail;
close(notify_rw[1]);
return INIT_SUCCESS;
fail:
saved_errno = errno;
if (fd >= 0)
close(fd);
if (notify_rw[0] >= 0)
close(notify_rw[0]);
if (notify_rw[1] >= 0)
close(notify_rw[1]);
errno = saved_errno;
return INIT_FAILURE;
}
/**
* Initialise the process
*
* @param foreground Keep process in the foreground
* @param keep_stderr Keep stderr open
* @param query Was -q used, see `main` for description
* @return An `enum init_status` value or an exit value
*/
static enum init_status
initialise(int foreground, int keep_stderr, int query)
{
struct rlimit rlimit;
size_t i, n;
sigset_t mask;
int s;
enum init_status r;
/* Zero out some memory so it can be destroyed safely. */
memset(&site, 0, sizeof(site));
if (!query) {
/* Close all file descriptors above stderr */
if (getrlimit(RLIMIT_NOFILE, &rlimit) || rlimit.rlim_cur == RLIM_INFINITY)
n = 4 << 10;
else
n = (size_t)(rlimit.rlim_cur);
for (i = STDERR_FILENO + 1; i < n; i++)
close((int)i);
/* Set umask, reset signal handlers, and reset signal mask */
umask(0);
for (s = 1; s < _NSIG; s++)
signal(s, SIG_DFL);
if (sigfillset(&mask))
perror(argv0);
else
sigprocmask(SIG_UNBLOCK, &mask, NULL);
}
/* Get method */
if (method < 0 && libgamma_list_methods(&method, 1, 0) < 1)
return fprintf(stderr, "%s: no adjustment method available\n", argv0), -1;
/* Go no further if we are just interested in the adjustment method and site */
if (query)
return INIT_SUCCESS;
/* Get site */
if (initialise_site() < 0)
goto fail;
/* Get PID file and socket pathname */
if (!(pidpath = get_pidfile_pathname()) ||
!(socketpath = get_socket_pathname()))
goto fail;
/* Create PID file */
if ((r = create_pidfile(pidpath)) < 0) {
free(pidpath);
pidpath = NULL;
if (r == -2)
return INIT_RUNNING;
goto fail;
}
/* Get partitions and CRTC:s */
if (initialise_crtcs() < 0)
goto fail;
/* Get CRTC information */
if (outputs_n && !(outputs = calloc(outputs_n, sizeof(*outputs))))
goto fail;
if (initialise_gamma_info() < 0)
goto fail;
/* Sort outputs */
qsort(outputs, outputs_n, sizeof(*outputs), output_cmp_by_name);
/* Load current gamma ramps */
store_gamma();
/* Preserve current gamma ramps at priority=0 if -p */
if (preserve && preserve_gamma() < 0)
goto fail;
/* Create socket and start listening */
if (create_socket(socketpath) < 0)
goto fail;
/* Get the real pathname of the process's binary, in case
* it is relative, so we can re-execute without problem. */
if (*argv0 != '/' && strchr(argv0, '/') && !(argv0_real = realpath(argv0, NULL)))
goto fail;
/* Change directory to / to avoid blocking umounting */
if (chdir("/") < 0)
perror(argv0);
/* Set up signal handlers */
if (set_up_signals() < 0)
goto fail;
/* Place in the background unless -f */
if (!foreground) {
return daemonise(keep_stderr);
} else {
/* Signal the spawner that the service is ready */
close(STDOUT_FILENO);
/* Avoid potential catastrophes that would occur if a library
* that is being used was so mindless as to write to stdout. */
if (dup2(STDERR_FILENO, STDOUT_FILENO) < 0)
perror(argv0);
}
return INIT_SUCCESS;
fail:
return INIT_FAILURE;
}
/**
* Deinitialise the process
*
* @param full Perform a full deinitialisation, shall be
* done iff the process is going to re-execute
*/
static void
destroy(int full)
{
if (full) {
disconnect_all();
close_socket(socketpath);
free(argv0_real);
if (outputs && connected)
restore_gamma();
}
state_destroy();
free(socketpath);
if (full && pidpath)
unlink(pidpath);
free(pidpath);
}
#if defined(__clang__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wcast-align"
#endif
/**
* Marshal the state of the process
*
* @param buf Output buffer for the marshalled data,
* `NULL` to only measure how large the
* buffer needs to be
* @return The number of marshalled bytes
*/
static size_t
marshal(void *restrict buf)
{
size_t off = 0, n;
char *restrict bs = buf;
if (bs)
*(int *)&bs[off] = MARSHAL_VERSION;
off += sizeof(int);
n = strlen(pidpath) + 1;
if (bs)
memcpy(&bs[off], pidpath, n);
off += n;
n = strlen(socketpath) + 1;
if (bs)
memcpy(&bs[off], socketpath, n);
off += n;
off += state_marshal(bs ? &bs[off] : NULL);
return off;
}
/**
* Unmarshal the state of the process
*
* @param buf Buffer with the marshalled data
* @return The number of marshalled bytes, 0 on error
*/
GCC_ONLY(__attribute__((__nonnull__)))
static size_t
unmarshal(const void *restrict buf)
{
size_t off = 0, n;
const char *restrict bs = buf;
if (*(const int *)&bs[off] != MARSHAL_VERSION) {
fprintf(stderr, "%s: re-executing to incompatible version, sorry about that\n", argv0);
errno = 0;
return 0;
}
off += sizeof(int);
n = strlen(&bs[off]) + 1;
if (!(pidpath = memdup(&bs[off], n)))
return 0;
off += n;
n = strlen(&bs[off]) + 1;
if (!(socketpath = memdup(&bs[off], n)))
return 0;
off += n;
off += n = state_unmarshal(&bs[off]);
if (!n)
return 0;
return off;
}
#if defined(__clang__)
# pragma GCC diagnostic pop
#endif
/**
* Do minimal initialisation, unmarshal the state of
* the process and merge with new state
*
* @param statefile The state file
* @return Zero on success, -1 on error
*/
GCC_ONLY(__attribute__((__nonnull__)))
static int
restore_state(const char *restrict statefile)
{
void *marshalled = NULL;
int fd = -1, saved_errno;
size_t r, n;
if (set_up_signals() < 0)
goto fail;
fd = open(statefile, O_RDONLY);
if (fd < 0)
goto fail;
if (!(marshalled = nread(fd, &n)))
goto fail;
close(fd);
fd = -1;
unlink(statefile);
statefile = NULL;
r = unmarshal(marshalled);
if (!r)
goto fail;
if (r != n) {
fprintf(stderr, "%s: unmarshalled state file was %s than the unmarshalled state: read %zu of %zu bytes\n",
argv0, n > r ? "larger" : "smaller", r, n);
errno = 0;
goto fail;
}
free(marshalled);
marshalled = NULL;
if (connected) {
connected = 0;
if (reconnect() < 0)
goto fail;
}
return 0;
fail:
saved_errno = errno;
if (fd >= 0)
close(fd);
free(marshalled);
errno = saved_errno;
return -1;
}
/**
* Reexecute the server
*
* Returns only on failure
*
* @return Pathname of file where the state is stored,
* `NULL` if the state is in tact
*/
static char *
reexecute(void)
{
char *statefile = NULL;
char *statebuffer = NULL;
size_t buffer_size;
int fd = -1, saved_errno;
statefile = get_state_pathname();
if (!statefile)
goto fail;
buffer_size = marshal(NULL);
statebuffer = malloc(buffer_size);
if (!statebuffer)
goto fail;
if (marshal(statebuffer) != buffer_size) {
fprintf(stderr, "%s: internal error\n", argv0);
errno = 0;
goto fail;
}
fd = open(statefile, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR);
if (fd < 0)
goto fail;
if (nwrite(fd, statebuffer, buffer_size) != buffer_size)
goto fail;
free(statebuffer);
statebuffer = NULL;
if (close(fd) < 0) {
fd = -1;
if (errno != EINTR)
goto fail;
}
fd = -1;
destroy(0);
execlp(argv0_real ? argv0_real : argv0, argv0, "- ", statefile, NULL);
free(argv0_real);
argv0_real = NULL;
return statefile;
fail:
saved_errno = errno;
free(statebuffer);
if (fd >= 0)
close(fd);
if (statefile != NULL) {
unlink(statefile);
free(statefile);
}
errno = saved_errno;
return NULL;
}
/**
* Print the response for the -q option
*
* @param query See -q for `main`, must be atleast 1
* @return Zero on success, -1 on error
*/
static int
print_method_and_site(int query)
{
const char *restrict methodname = NULL;
char *p;
if (query == 1) {
switch (method) {
#define X(C, N) case C: methodname = N; break;
LIST_ADJUSTMENT_METHODS;
#undef X
default:
if (printf("%i\n", method) < 0)
return -1;
break;
}
if (methodname)
if (printf("%s\n", methodname) < 0)
return -1;
}
if (!sitename)
if ((sitename = libgamma_method_default_site(method)))
if (!(sitename = memdup(sitename, strlen(sitename) + 1)))
return -1;
if (sitename) {
switch (method) {
case LIBGAMMA_METHOD_X_RANDR:
case LIBGAMMA_METHOD_X_VIDMODE:
if ((p = strrchr(sitename, ':')))
if ((p = strchr(p, '.')))
*p = '\0';
break;
default:
break;
}
}
if (sitename && query == 1)
if (printf("%s\n", sitename) < 0)
return -1;
if (query == 2) {
site.method = method;
site.site = sitename;
sitename = NULL;
socketpath = get_socket_pathname();
if (!socketpath)
return -1;
if (printf("%s\n", socketpath) < 0)
return -1;
}
if (fflush(stdout))
return -1;
return 0;
}
/**
* Print usage information and exit
*/
#if defined(__GNU__) || defined(__clang__)
__attribute__((__noreturn__))
#endif
static void
usage(void)
{
fprintf(stderr, "usage: %s [-m method] [-s site] [-fkpq]\n", argv0);
exit(1);
}
#if defined(__clang__)
# pragma GCC diagnostic ignored "-Wdocumentation-unknown-command"
#endif
/**
* Must not be started without stdin, stdout, or stderr (may be /dev/null)
*
* argv[0] must refer to the real command name or pathname,
* otherwise, re-execute will not work
*
* The process closes stdout when the socket has been created
*
* @signal SIGUSR1 Re-execute to updated process image
* @signal SIGUSR2 Dump the state of the process to standard error
* @signal SIGINFO Ditto
* @signal SIGTERM Terminate the process gracefully
* @signal SIGRTMIN+0 Disconnect from the site
* @signal SiGRTMIN+1 Reconnect to the site
*
* @param argc The number of elements in `argv`
* @param argv Command line arguments. Recognised options:
* -s SITENAME
* The site to which to connect
* -m METHOD
* Adjustment method name or adjustment method number
* -p
* Preserve current gamma ramps at priority 0
* -f
* Do not fork the process into the background
* -k
* Keep stderr open
* -q
* Print the select (possiblity default) adjustment
* method on the first line in stdout, and the
* selected (possibility defasult) site on the second
* line in stdout, and exit. If the site name is `NULL`,
* the second line is omitted. This is indented to
* be used by clients to figure out to which instance
* of the service it should connect. Use twice to
* simply ge the socket pathname, an a terminating LF.
* By combining -q and -m you can enumerate the name
* of all recognised adjustment method, start from 0
* and work up until a numerical adjustment method is
* returned.
* @return 0: Successful
* 1: An error occurred
* 2: Already running
*/
int
main(int argc, char *argv[])
{
int rc = 1, foreground = 0, keep_stderr = 0, query = 0, r;
char *statefile = NULL, *statefile_ = NULL;
ARGBEGIN {
case 's':
sitename = EARGF(usage());
/* To simplify re-exec: */
sitename = memdup(sitename, strlen(sitename) + 1);
if (!sitename)
goto fail;
break;
case 'm':
method = get_method(EARGF(usage()));
if (method < 0)
goto fail;
break;
case 'p': preserve = 1; break;
case 'f': foreground = 1; break;
case 'k': keep_stderr = 1; break;
case 'q': query = 1 + !!query; break;
case ' ': /* Internal, do not document */
statefile = statefile_ = EARGF(usage());
break;
default:
usage();
}
ARGEND;
if (argc > 0)
usage();
restart:
if (!statefile) {
switch ((r = initialise(foreground, keep_stderr, query))) {
case INIT_SUCCESS: break;
case INIT_RUNNING: rc = 2; /* fall through */
case INIT_FAILURE: goto fail;
default: return r;
}
} else if (restore_state(statefile) < 0) {
goto fail;
} else {
if (statefile != statefile_)
free(statefile);
unlink(statefile);
statefile = NULL;
}
if (query) {
if (print_method_and_site(query) < 0)
goto fail;
goto done;
}
reenter_loop:
if (main_loop() < 0)
goto fail;
if (reexec && !terminate) {
statefile = reexecute();
if (statefile) {
perror(argv0);
fprintf(stderr, "%s: restoring state without re-executing\n", argv0);
reexec = 0;
goto restart;
}
perror(argv0);
fprintf(stderr, "%s: continuing without re-executing\n", argv0);
reexec = 0;
goto reenter_loop;
}
done:
rc = 0;
deinit:
if (statefile)
unlink(statefile);
if (reexec)
free(statefile);
destroy(1);
return rc;
fail:
if (errno)
perror(argv0);
goto deinit;
}
