/*
	 * Copyright (c) 2026 IBM, Inc.
	 *
	 * All rights reserved.
	 *
	 * Authors: Thomas Jones <thomas.jones@ibm.com>
	 *
	 * This software licensed under BSD license, the text of which follows:
	 *
	 * Redistribution and use in source and binary forms, with or without
	 * modification, are permitted provided that the following conditions are met:
	 *
	 * - Redistributions of source code must retain the above copyright notice,
	 *   this list of conditions and the following disclaimer.
	 * - Redistributions in binary form must reproduce the above copyright notice,
	 *   this list of conditions and the following disclaimer in the documentation
	 *   and/or other materials provided with the distribution.
	 * - Neither the name of the Red Hat Inc. nor the names of its
	 *   contributors may be used to endorse or promote products derived from this
	 *   software without specific prior written permission.
	 *
	 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	 * THE POSSIBILITY OF SUCH DAMAGE.
	 */
	
	#include <config.h>
	
	#include <ctype.h>
	#include <unistd.h>
	#include <inttypes.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <stdbool.h>
	#include <string.h>
	#include <sys/types.h>
	#include <sys/socket.h>
	#include <netdb.h>
	#include <limits.h>
	
	#include <corosync/totem/totem.h>
	#include <corosync/cfg.h>
	#include <corosync/cmap.h>
	#include <corosync/quorum.h>
	#include <corosync/votequorum.h>
	#include "util.h"
	
	typedef enum {
		CMD_SHOWSTATUS,
		CMD_SETINFO,
		CMD_CLEARINFO,
		CMD_MONITOR
	} command_t;
	
	static void show_usage(const char *name)
	{
		printf("usage: \n");
		printf("%s <options>\n", name);
		printf("\n");
		printf("  options:\n");
		printf("\n");
		printf("  -s             show current extra info as strings\n");
		printf("  -m             constantly monitor for updates\n");
		printf("  -S <info>      set the extra info on the node running the command\n");
		printf("  -c             clear the extra info on the node running the command\n");
		printf("  -h             show this help text\n");
		printf("  -V             show version and exit\n");
		printf("\n");
	}
	
	static cmap_handle_t cmap_handle;
	
	/*
	 * votequorum bits
	 */
	static void vq_qdevice_extra_info_fn(
		votequorum_handle_t handle,
		uint64_t context,
		uint32_t nodeid,
		uint32_t ei_size,
		void *extra_info);
	static void vq_quorum_notification_fn_t (
		votequorum_handle_t handle,
		uint64_t context,
		uint32_t quorate,
		uint32_t node_list_entries,
		votequorum_node_t node_list[]);
	static void vq_notification_fn(
		votequorum_handle_t handle,
		uint64_t context,
		votequorum_ring_id_t ring_id,
		uint32_t node_list_entries,
		uint32_t node_list[]);
	
	static votequorum_handle_t v_handle;
	static votequorum_model_v1_data_t v_callbacks = {
		.model = VOTEQUORUM_MODEL_V1,
		.votequorum_quorum_notify_fn = vq_quorum_notification_fn_t,
		.votequorum_expectedvotes_notify_fn = NULL,
		.votequorum_nodelist_notify_fn = vq_notification_fn,
		.votequorum_qdevice_extra_info_fn = vq_qdevice_extra_info_fn,
	};
	
	static bool g_quorate = false;
	static bool g_vq_called = false;
	static bool g_vq_quorum_called = false;
	static uint32_t g_node_list_entries = 0;
	static uint32_t *g_node_list = NULL;
	
	static uint32_t g_vqnode_list_entries = 0;
	static votequorum_node_t *g_vqnode_list = NULL;
	
	static void vq_notification_fn(
		votequorum_handle_t handle,
		uint64_t context,
		votequorum_ring_id_t ring_id,
		uint32_t node_list_entries,
		uint32_t node_list[])
	{
		(void)handle; (void)context; (void)ring_id;
		if(g_node_list) {
			free(g_node_list);
		}
	
		g_node_list_entries = node_list_entries;
		g_node_list = malloc(sizeof(*node_list) * node_list_entries);
		memcpy(g_node_list, node_list, sizeof(*node_list) * node_list_entries);
	
		g_vq_called = true;
	}
	
	static void vq_quorum_notification_fn_t (
		votequorum_handle_t handle,
		uint64_t context,
		uint32_t quorate,
		uint32_t node_list_entries,
		votequorum_node_t node_list[])
	{
		if(g_vqnode_list) {
			free(g_vqnode_list);
		}
		g_vqnode_list_entries = node_list_entries;
		g_vqnode_list = malloc(sizeof(*node_list) * node_list_entries);
		memcpy(g_vqnode_list, node_list, sizeof(*node_list) * node_list_entries);
	
		g_quorate = quorate;
	
		g_vq_quorum_called = true;
	}
	
	static int get_quorum_type(char *quorum_type, size_t quorum_type_len)
	{
		int err;
		char *str = NULL;
	
		if ((quorum_type == NULL) || (quorum_type_len <= 0)) {
			return -1;
		}
	
		err = cmap_get_string(cmap_handle, "quorum.provider", &str);
		if (err != CS_OK) {
			goto out;
		}
	
		if (str == NULL) {
			return -1;
		}
	
		strncpy(quorum_type, str, quorum_type_len - 1);
		free(str);
	
		return 0;
	out:
		return err;
	}
	
	/*
	 * Returns 1 if 'votequorum' is active. The called then knows that
	 * votequorum calls should work and can provide extra information
	 */
	static int using_votequorum(void)
	{
		char quorumtype[256];
		int using_voteq;
	
		memset(quorumtype, 0, sizeof(quorumtype));
	
		if (get_quorum_type(quorumtype, sizeof(quorumtype))) {
			return -1;
		}
	
		if (strcmp(quorumtype, "corosync_votequorum") == 0) {
			using_voteq = 1;
		} else {
			using_voteq = 0;
		}
	
		return using_voteq;
	}
	
	static int init_vq_info(void)
	{
		int err;
	
		err = votequorum_trackstart(v_handle, 0LL, CS_TRACK_CURRENT);
		if (err != CS_OK) {
			fprintf(stderr, "Unable to start votequorum status tracking: %s\n", cs_strerror(err));
			goto exit;
		}
	
		g_vq_called = false;
		g_vq_quorum_called = false;
		while ((!g_vq_called || !g_vq_quorum_called) && err == CS_OK) {
			err = votequorum_dispatch(v_handle, CS_DISPATCH_ONE);
			if (err != CS_OK) {
				fprintf(stderr, "Unable to dispatch votequorum status: %s\n", cs_strerror(err));
				goto exit;
			}
		}
	
	exit:
		if (err != CS_OK) {
			return EXIT_FAILURE;
		}
		return EXIT_SUCCESS;
	}
	
	static void print_extra_info(uint32_t ei_size, const char *extra_info)
	{
		if (ei_size == 0) {
			printf("<unset>");
			return;
		}
	
		if (strncmp(extra_info, "Qdsk", 4) == 0) {
			printf("<Qdisk> key:%s", extra_info+5);
			return;
		}
	
		bool is_printable = extra_info[ei_size-1] == '\0';
		for (uint32_t i = 0; i < ei_size - 1; i++) {
			if(!isprint((unsigned char)extra_info[i])) {
				is_printable = false;
			}
		}
		if (is_printable) {
			printf("<unknown> %s", extra_info);
			return;
		}
	
		printf("<unknown> %" PRIu32 " bytes: ", ei_size);
		for (uint32_t i = 0; i < ei_size; i++) {
			printf("%02hhX ", (unsigned char)extra_info[i]);
		}
	}
	
	static int show_status(void)
	{
		int err = CS_OK;
	
		if (init_vq_info()) {
			return EXIT_FAILURE;
		}
	
		for (uint32_t i = 0; i < g_vqnode_list_entries; i++) {
			uint32_t ei_size = 0;
			char buf[VOTEQUORUM_QDEVICE_EXTRA_NODEINFO_MAXSIZE+1] = { 0 };
			err = votequorum_get_qdevice_extra_info (v_handle, g_vqnode_list[i].nodeid, &ei_size, buf);
	
			printf(CS_PRI_NODE_ID_PADDED " ", g_vqnode_list[i].nodeid);
			if (err == CS_OK && ei_size) {
				print_extra_info(ei_size, buf);
				printf("\n");
			} else {
				printf("<unset>\n");
			}
		}
	
		if (err != CS_OK) {
			return EXIT_FAILURE;
		}
	
		return EXIT_SUCCESS;
	}
	
	bool g_monitor_output = false;
	
	static void vq_qdevice_extra_info_fn(
		votequorum_handle_t handle,
		uint64_t context,
		uint32_t nodeid,
		uint32_t ei_size,
		void *extra_info)
	{
		if (g_monitor_output) {
			printf(CS_PRI_NODE_ID_PADDED " ", nodeid);
			print_extra_info(ei_size, extra_info);
			printf("\n");
		}
	}
	
	static int monitor_status(void)
	{
		int err;
	
		printf("Watching for updates:\n");
	
		g_monitor_output = true;
	
		err = votequorum_trackstart(v_handle, UINT64_C(0), CS_TRACK_CURRENT | CS_TRACK_CHANGES);

		if (err != CS_OK) {
			fprintf(stderr, "Unable to start votequorum status tracking: %s\n", cs_strerror(err));
			goto exit;
		}
	
		while (1) {
			err = votequorum_dispatch(v_handle, CS_DISPATCH_ONE);

			if (err != CS_OK) {
				fprintf(stderr, "Unable to dispatch votequorum status: %s\n", cs_strerror(err));
				goto exit;
			}
		}
	
	exit:

		if (err != CS_OK) {
			return EXIT_FAILURE;
		}
	

		return EXIT_SUCCESS;
	}
	
	static int set_info(const char *extra_info)
	{
		int err;
	
		if (init_vq_info()) {
			return EXIT_FAILURE;
		}
	
		uint32_t ei_size = 0;
		if (extra_info) {
			ei_size = strlen(extra_info) + 1;
		}
	
		err = votequorum_set_qdevice_extra_info(v_handle, ei_size, extra_info);
		if (err != CS_OK) {
			fprintf(stderr, "Failed to set extra info %s\n", cs_strerror(err));
			return EXIT_FAILURE;
		}
	
		return EXIT_SUCCESS;
	}
	
	static int init_all(void)
	{
		if (cmap_initialize(&cmap_handle) != CS_OK) {
			fprintf(stderr, "Cannot initialize CMAP service\n");
			cmap_handle = 0;
			goto out;
		}
	
		if (using_votequorum() <= 0) {
			goto out;
		}
	
		if (votequorum_model_initialize(&v_handle, &v_callbacks) != CS_OK) {
			fprintf(stderr, "Cannot initialise VOTEQUORUM service\n");
			v_handle = 0;
			goto out;
		}
	
		return 0;
	out:
		return -1;
	}
	
	static void close_all(void) {
		if (cmap_handle) {
			cmap_finalize(cmap_handle);
		}
		if (v_handle) {
			votequorum_finalize(v_handle);
		}
	}
	
	int main(int argc, char *argv[])
	{
		const char *options = "VhsmcS:";
		int opt;
		int ret = 0;
		command_t command_opt = CMD_SHOWSTATUS;
		const char *extra_info = NULL;
	
		while ( (opt = getopt(argc, argv, options)) != -1 ) {
			switch (opt) {
			case 's':
				command_opt = CMD_SHOWSTATUS;
				break;
			case 'm':
				command_opt = CMD_MONITOR;
				break;
			case 'c':
				command_opt = CMD_CLEARINFO;
				break;
			case 'S':
				command_opt = CMD_SETINFO;
				extra_info = strdup(optarg);
				break;
			case 'V':
				printf("corosync-qdeitool version: %s\n", VERSION);
				exit(EXIT_SUCCESS);
				break;
			case 'h':
				show_usage(argv[0]);
				exit(EXIT_SUCCESS);
				break;
			case ':':
			case '?':
			default:
				show_usage(argv[0]);
				exit(EXIT_FAILURE);
				break;
			}
		}
	
		if (init_all()) {
			close_all();
			exit(EXIT_FAILURE);
		}
	
		switch (command_opt) {
			case CMD_SHOWSTATUS:
				ret = show_status();
				break;
			case CMD_CLEARINFO:
			case CMD_SETINFO:
				ret = set_info(extra_info);
				break;
			case CMD_MONITOR:
				ret = monitor_status();
				break;
			default:
				break;
		}
	
		close_all();
		return ret;
	}