aboutsummaryrefslogtreecommitdiffhomepage
path: root/tools
diff options
context:
space:
mode:
Diffstat (limited to 'tools')
-rw-r--r--tools/gsr-cli/main.c281
1 files changed, 281 insertions, 0 deletions
diff --git a/tools/gsr-cli/main.c b/tools/gsr-cli/main.c
new file mode 100644
index 0000000..b536ceb
--- /dev/null
+++ b/tools/gsr-cli/main.c
@@ -0,0 +1,281 @@
+#include "../../include/json.h"
+#include "../../include/log.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/un.h>
+
+#define GSR_CLI_REQUEST_ID 1
+#define GSR_CLI_MAX_REQUEST_SIZE 256
+#define GSR_CLI_MAX_REPLY_SIZE 4096
+#define GSR_CLI_REPLY_TIMEOUT_SECONDS 10
+
+static void usage(void) {
+ printf("usage: gsr-cli -ipc <socket_path> <command> [command_argument]\n");
+ printf("\n");
+ printf("Sends a command to a GPU Screen Recorder instance that was started with the -ipc option.\n");
+ printf("\n");
+ printf("OPTIONS:\n");
+ printf(" -ipc <socket_path>\n");
+ printf(" The unix domain socket that GPU Screen Recorder was started with. Required.\n");
+ printf("\n");
+ printf("COMMANDS:\n");
+ printf(" status\n");
+ printf(" Check if a GPU Screen Recorder instance is listening on the socket. Prints \"running\" or\n");
+ printf(" \"not running\" and exits with 0 when it's running.\n");
+ printf(" stop\n");
+ printf(" Stop and save the recording (stop without save in replay mode).\n");
+ printf(" toggle-pause\n");
+ printf(" Pause/unpause the recording (not for streaming/replay).\n");
+ printf(" toggle-replay-recording\n");
+ printf(" Start/stop a regular recording during replay/streaming.\n");
+ printf(" save-replay [seconds]\n");
+ printf(" Save the replay. The number of seconds has to be larger than 0. The whole replay buffer is\n");
+ printf(" saved when no number of seconds is given.\n");
+ printf("\n");
+ printf("EXAMPLES:\n");
+ printf(" gsr-cli -ipc \"$XDG_RUNTIME_DIR/gsr.sock\" status\n");
+ printf(" gsr-cli -ipc \"$XDG_RUNTIME_DIR/gsr.sock\" save-replay 30\n");
+ fflush(stdout);
+}
+
+static bool string_to_int64(const char *str, int64_t *result) {
+ char *number_end = NULL;
+ errno = 0;
+ const long long parsed_value = strtoll(str, &number_end, 10);
+ if(errno != 0 || number_end == str || *number_end != '\0')
+ return false;
+
+ *result = parsed_value;
+ return true;
+}
+
+/* Returns the socket, or -1 on failure. Only logs an error when the failure isn't a missing GPU Screen Recorder instance */
+static int ipc_connect(const char *socket_filepath) {
+ struct sockaddr_un addr;
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ if(snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_filepath) >= (int)sizeof(addr.sun_path)) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "the ipc socket path is too long, it can be at most %d characters: \"%s\"", (int)sizeof(addr.sun_path) - 1, socket_filepath);
+ return -1;
+ }
+
+ const int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
+ if(fd == -1) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "failed to create a socket, error: %s", strerror(errno));
+ return -1;
+ }
+
+ struct timeval timeout;
+ timeout.tv_sec = GSR_CLI_REPLY_TIMEOUT_SECONDS;
+ timeout.tv_usec = 0;
+ setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
+ setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
+
+ if(connect(fd, (const struct sockaddr*)&addr, sizeof(addr)) == -1) {
+ close(fd);
+ return -1;
+ }
+
+ return fd;
+}
+
+static bool ipc_send_all(int fd, const char *data, size_t size) {
+ size_t offset = 0;
+ while(offset < size) {
+ const ssize_t bytes_written = send(fd, data + offset, size - offset, MSG_NOSIGNAL);
+ if(bytes_written > 0) {
+ offset += bytes_written;
+ continue;
+ }
+
+ if(bytes_written == -1 && errno == EINTR)
+ continue;
+
+ gsr_log(GSR_LOG_LEVEL_ERROR, "failed to send the request, error: %s", strerror(errno));
+ return false;
+ }
+ return true;
+}
+
+/* Reads until a newline. |reply_size| is set to the size of the reply, excluding the newline */
+static bool ipc_receive_reply(int fd, char *reply, size_t reply_capacity, size_t *reply_size) {
+ size_t offset = 0;
+ for(;;) {
+ if(offset == reply_capacity) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "the reply is too large");
+ return false;
+ }
+
+ const ssize_t bytes_read = recv(fd, reply + offset, reply_capacity - offset, 0);
+ if(bytes_read == 0) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "GPU Screen Recorder closed the connection before replying");
+ return false;
+ }
+
+ if(bytes_read == -1) {
+ if(errno == EINTR)
+ continue;
+
+ if(errno == EAGAIN || errno == EWOULDBLOCK)
+ gsr_log(GSR_LOG_LEVEL_ERROR, "timed out after %d seconds waiting for a reply", GSR_CLI_REPLY_TIMEOUT_SECONDS);
+ else
+ gsr_log(GSR_LOG_LEVEL_ERROR, "failed to receive the reply, error: %s", strerror(errno));
+ return false;
+ }
+
+ const char *newline = memchr(reply + offset, '\n', bytes_read);
+ offset += bytes_read;
+ if(newline) {
+ *reply_size = newline - reply;
+ return true;
+ }
+ }
+}
+
+/* Returns the exit code that gsr-cli should exit with */
+static int ipc_handle_reply(char *reply, size_t reply_size, int64_t request_id) {
+ sj_Reader reader = sj_reader(reply, reply_size);
+ const sj_Value root = sj_read(&reader);
+ if(root.type != SJ_OBJECT) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "expected the reply to be a json object, got: %.*s", (int)reply_size, reply);
+ return 1;
+ }
+
+ int64_t id = 0;
+ bool has_id = false;
+ sj_Value result_value;
+ bool has_result = false;
+ sj_Value data_value;
+ bool has_data = false;
+
+ sj_Value key;
+ sj_Value value;
+ while(sj_iter_object(&reader, root, &key, &value)) {
+ if(gsr_json_string_equals(&key, "id")) {
+ has_id = gsr_json_number_to_int64(&value, &id);
+ } else if(gsr_json_string_equals(&key, "result")) {
+ result_value = value;
+ has_result = value.type == SJ_STRING;
+ } else if(gsr_json_string_equals(&key, "data")) {
+ data_value = value;
+ has_data = true;
+ }
+ }
+
+ if(reader.error) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "failed to parse the reply: %s", reader.error);
+ return 1;
+ }
+
+ if(!has_id || id != request_id) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "received a reply to another request: %.*s", (int)reply_size, reply);
+ return 1;
+ }
+
+ if(!has_result) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "the reply is missing the 'result' field: %.*s", (int)reply_size, reply);
+ return 1;
+ }
+
+ if(gsr_json_string_equals(&result_value, "ok"))
+ return 0;
+
+ if(has_data && data_value.type == SJ_STRING)
+ gsr_log(GSR_LOG_LEVEL_ERROR, "%.*s", (int)(data_value.end - data_value.start), data_value.start);
+ else
+ gsr_log(GSR_LOG_LEVEL_ERROR, "the request failed: %.*s", (int)reply_size, reply);
+
+ return 1;
+}
+
+static int status_command(const char *socket_filepath) {
+ const int fd = ipc_connect(socket_filepath);
+ if(fd == -1) {
+ printf("not running\n");
+ fflush(stdout);
+ return 1;
+ }
+
+ close(fd);
+ printf("running\n");
+ fflush(stdout);
+ return 0;
+}
+
+static int send_command(const char *socket_filepath, const char *name, const char *seconds_str) {
+ char request[GSR_CLI_MAX_REQUEST_SIZE];
+ if(seconds_str) {
+ int64_t seconds = 0;
+ if(!string_to_int64(seconds_str, &seconds) || seconds <= 0 || seconds > INT_MAX) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "expected the number of seconds to save to be an integer larger than 0, got: '%s'", seconds_str);
+ return 1;
+ }
+ snprintf(request, sizeof(request), "{\"id\":%d,\"name\":\"%s\",\"data\":%" PRIi64 "}\n", GSR_CLI_REQUEST_ID, name, seconds);
+ } else {
+ snprintf(request, sizeof(request), "{\"id\":%d,\"name\":\"%s\"}\n", GSR_CLI_REQUEST_ID, name);
+ }
+
+ const int fd = ipc_connect(socket_filepath);
+ if(fd == -1) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "failed to connect to \"%s\". Is GPU Screen Recorder running with the -ipc option?", socket_filepath);
+ return 1;
+ }
+
+ int exit_code = 1;
+ char reply[GSR_CLI_MAX_REPLY_SIZE];
+ size_t reply_size = 0;
+ if(ipc_send_all(fd, request, strlen(request)) && ipc_receive_reply(fd, reply, sizeof(reply), &reply_size))
+ exit_code = ipc_handle_reply(reply, reply_size, GSR_CLI_REQUEST_ID);
+
+ close(fd);
+ return exit_code;
+}
+
+int main(int argc, char **argv) {
+ if(argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)) {
+ usage();
+ return 0;
+ }
+
+ if(argc < 4 || strcmp(argv[1], "-ipc") != 0) {
+ usage();
+ return 1;
+ }
+
+ if(argc > 5) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "too many arguments");
+ usage();
+ return 1;
+ }
+
+ const char *socket_filepath = argv[2];
+ const char *command = argv[3];
+ const char *command_argument = argc == 5 ? argv[4] : NULL;
+
+ if(strcmp(command, "save-replay") == 0)
+ return send_command(socket_filepath, command, command_argument);
+
+ if(command_argument) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "the '%s' command doesn't take an argument", command);
+ usage();
+ return 1;
+ }
+
+ if(strcmp(command, "status") == 0)
+ return status_command(socket_filepath);
+
+ if(strcmp(command, "stop") == 0 || strcmp(command, "toggle-pause") == 0 || strcmp(command, "toggle-replay-recording") == 0)
+ return send_command(socket_filepath, command, NULL);
+
+ gsr_log(GSR_LOG_LEVEL_ERROR, "invalid command '%s'", command);
+ usage();
+ return 1;
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-08-22 22:36:18 +0000