/*
	 * Copyright 2004-2012 Red Hat, Inc.
	 *
	 * This copyrighted material is made available to anyone wishing to use,
	 * modify, copy, or redistribute it subject to the terms and conditions
	 * of the GNU General Public License v2 or (at your option) any later version.
	 */
	
	#include <stdio.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <stdint.h>
	#include <string.h>
	#include <errno.h>
	#include <time.h>
	#include <sys/types.h>
	#include <sys/socket.h>
	#include <sys/un.h>
	
	#include <linux/dlmconstants.h>
	#include "dlm_controld.h"
	#include "libdlmcontrol.h"
	
	static int do_read(int fd, void *buf, size_t count)
	{
		int rv, off = 0;
	

		while (off < count) {

			rv = read(fd, (char *)buf + off, count - off);

			if (rv == 0)

				return -1;

			if (rv == -1 && errno == EINTR)

				continue;

			if (rv == -1)

				return -1;
			off += rv;

		}
		return 0;
	}
	
	static int do_write(int fd, void *buf, size_t count)
	{
		int rv, off = 0;
	
	 retry:
		rv = write(fd, (char *)buf + off, count);
		if (rv == -1 && errno == EINTR)
			goto retry;
		if (rv < 0) {
			return rv;
		}
	
		if (rv != count) {
			count -= rv;
			off += rv;
			goto retry;
		}
		return 0;
	}
	
	static int do_connect(const char *sock_path)
	{
		struct sockaddr_un sun;
		socklen_t addrlen;
		int rv, fd;
	
		fd = socket(PF_UNIX, SOCK_STREAM, 0);
		if (fd < 0)
			goto out;
	
		memset(&sun, 0, sizeof(sun));
		sun.sun_family = AF_UNIX;
		strcpy(&sun.sun_path[1], sock_path);
		addrlen = sizeof(sa_family_t) + strlen(sun.sun_path+1) + 1;
	
		rv = connect(fd, (struct sockaddr *) &sun, addrlen);
		if (rv < 0) {
			close(fd);
			fd = rv;
		}
	 out:
		return fd;
	}
	
	static inline void init_header_name(struct dlmc_header *h,
					    const char *name, size_t len)
	{
	#pragma GCC diagnostic push
	#if __GNUC__ >= 8
	#pragma GCC diagnostic ignored "-Wstringop-truncation"
	#endif
		strncpy(h->name, name, len);
	#pragma GCC diagnostic pop
	}
	
	static void init_header(struct dlmc_header *h, int cmd, char *name,
				int extra_len)
	{
		memset(h, 0, sizeof(struct dlmc_header));
	
		h->magic = DLMC_MAGIC;
		h->version = DLMC_VERSION;
		h->len = sizeof(struct dlmc_header) + extra_len;
		h->command = cmd;
	
		if (name)
			init_header_name(h, name, DLM_LOCKSPACE_LEN);
	}
	
	static char copy_buf[DLMC_DUMP_SIZE];
	
	static int do_dump(int cmd, char *name, char *buf, int *data)
	{
		struct dlmc_header h;
		int fd, rv, len;
	
		memset(copy_buf, 0, DLMC_DUMP_SIZE);
	
		init_header(&h, cmd, name, 0);
	
		*data = 0;
	
		fd = do_connect(DLMC_QUERY_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
		rv = do_write(fd, &h, sizeof(h));
		if (rv < 0)
			goto out_close;
	
		memset(&h, 0, sizeof(h));
	
		rv = do_read(fd, &h, sizeof(h));
		if (rv < 0)
			goto out_close;
	
		*data = h.data;
		len = h.len - sizeof(h);
	
		if (len <= 0 || len > DLMC_DUMP_SIZE)
			goto out_close;
	
		rv = do_read(fd, copy_buf, len);
		if (rv < 0)
			goto out_close;
	
		memcpy(buf, copy_buf, len);
	 out_close:
		close(fd);
	 out:
		return rv;
	}
	
	int dlmc_dump_debug(char *buf, int *data)
	{
		return do_dump(DLMC_CMD_DUMP_DEBUG, NULL, buf, data);
	}
	
	int dlmc_dump_config(char *buf, int *data)
	{
		return do_dump(DLMC_CMD_DUMP_CONFIG, NULL, buf, data);
	}
	
	int dlmc_dump_log_plock(char *buf, int *data)
	{
		return do_dump(DLMC_CMD_DUMP_LOG_PLOCK, NULL, buf, data);
	}
	
	int dlmc_dump_plocks(char *name, char *buf, int *data)
	{
		return do_dump(DLMC_CMD_DUMP_PLOCKS, name, buf, data);
	}
	
	int dlmc_dump_run(char *buf, int *data)
	{
		return do_dump(DLMC_CMD_DUMP_RUN, NULL, buf, data);
	}
	
	int dlmc_reload_config(void)
	{
		struct dlmc_header h;
		int fd, rv;
	
		init_header(&h, DLMC_CMD_RELOAD_CONFIG, NULL, 0);
	
		fd = do_connect(DLMC_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
		rv = do_write(fd, &h, sizeof(h));
		close(fd);
	out:
		return rv;
	}
	
	int dlmc_set_config(char *command)
	{
		struct dlmc_header h;
		char *cmdbuf;
		int fd, rv;
	
		cmdbuf = malloc(DLMC_RUN_COMMAND_LEN);
		if (!cmdbuf)
			return -1;
	
		memset(cmdbuf, 0, DLMC_RUN_COMMAND_LEN);
		strncpy(cmdbuf, command, DLMC_RUN_COMMAND_LEN-1);
	
		init_header(&h, DLMC_CMD_SET_CONFIG, NULL, DLMC_RUN_COMMAND_LEN);
	
		fd = do_connect(DLMC_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
		rv = do_write(fd, &h, sizeof(h));
		if (rv < 0)
			goto out_close;
	
		rv = do_write(fd, cmdbuf, DLMC_RUN_COMMAND_LEN);
		if (rv < 0)
			goto out_close;
	
	out_close:
		close(fd);
	out:
		free(cmdbuf);
		return rv;
	}
	
	static int nodeid_compare(const void *va, const void *vb)
	{
		const int *a = va;
		const int *b = vb;
	
		return *a - *b;
	}
	
	static void print_str(char *str, int len)
	{
		char *p;
		int i;
	
		p = &str[0];
		for (i = 0; i < len-1; i++) {
			if (str[i] == ' ') {
				str[i] = '\0';
				printf("    %s\n", p);
				p = &str[i+1];
			}
		}
	
		if (p)
			printf("    %s\n", p);
	}
	
	static unsigned int kv(char *str, const char *k)
	{
		char valstr[64];
		char *p;
		int i;
	
		p = strstr(str, k);
		if (!p)
			return 0;
	
		p = strstr(p, "=");
		if (!p)
			return 0;
	
		/* move pointer after '=' */
		p++;
	
		memset(valstr, 0, 64);
	
		for (i = 0; i < 64; i++) {
			if (*p == ' ')
				break;
			if (*p == '\0')
				break;
			if (*p == '\n')
				break;
			valstr[i] = *p;
			p++;
		}
	
		return (unsigned int)strtoul(valstr, NULL, 0);
	}
	
	static char *ks(char *str, const char *k)
	{
		static char valstr[64];
		char *p;
		int i;
	
		p = strstr(str, k);
		if (!p)
			return 0;
	
		p = strstr(p, "=");
		if (!p)
			return 0;
	
		/* move pointer after '=' */
		p++;
	
		memset(valstr, 0, 64);
	
		for (i = 0; i < 64; i++) {
			if (*p == ' ')
				break;
			if (*p == '\0')
				break;
			if (*p == '\n')
				break;
			valstr[i] = *p;
			p++;
		}
	
		return valstr;
	}
	
	static void print_daemon(struct dlmc_state *st, char *str, char *bin, uint32_t flags)
	{
		unsigned int cluster_ringid, daemon_ringid;
		unsigned int fipu;
	
		if (flags & DLMC_STATUS_VERBOSE) {
			printf("our_nodeid %d\n", st->nodeid);
			print_str(str, st->str_len);
			return;
		}
	
		cluster_ringid = kv(str, "cluster_ringid");
		daemon_ringid = kv(str, "daemon_ringid");
	
		printf("cluster nodeid %d quorate %u ring seq %u %u\n",
			st->nodeid,
			kv(str, "quorate"),
			cluster_ringid, daemon_ringid);
	
		fipu = kv(str, "fence_in_progress_unknown");
	
		printf("daemon now %u fence_pid %u %s\n",
			kv(str, "monotime"),
			kv(str, "fence_pid"),
			fipu ? "fence_init" : "");
	}
	
	static void format_daemon_node(struct dlmc_state *st, char *str, char *bin, uint32_t flags,
				       char *node_line, char *fence_line)
	{
		unsigned int delay_fencing, result_wait, killed;
		char letter;
	
		if (st->type == DLMC_STATE_STARTUP_NODE)
			letter = 'U';
		else if (kv(str, "member"))
			letter = 'M';
		else
			letter = 'X';
		
	
		snprintf(node_line, DLMC_STATE_MAXSTR - 1,
			"node %d %c add %u rem %u fail %u fence %u at %u %u\n",
			st->nodeid,
			letter,
			kv(str, "add_time"),
			kv(str, "rem_time"),
			kv(str, "fail_monotime"),
			kv(str, "fence_monotime"),
			kv(str, "actor_done"),
			kv(str, "fence_walltime"));
	
		if (!kv(str, "need_fencing"))
			return;
	
		delay_fencing = kv(str, "delay_fencing");
		result_wait = kv(str, "fence_result_wait");
		killed = kv(str, "killed");
	
		if (delay_fencing)
			snprintf(fence_line, DLMC_STATE_MAXSTR - 1,
				"fence %d %s delay actor %u fail %u fence %u now %u%s%s\n",
				st->nodeid,
				ks(str, "left_reason"),
				kv(str, "actor_last"),
				kv(str, "fail_walltime"),
				kv(str, "fence_walltime"),
				(unsigned int)time(NULL),
				result_wait ? " result_wait" : "",
				killed ? " killed" : "");
		else
			snprintf(fence_line, DLMC_STATE_MAXSTR - 1,
				"fence %d %s pid %d actor %u fail %u fence %u now %u%s%s\n",
				st->nodeid,
				ks(str, "left_reason"),
				kv(str, "fence_pid"),
				kv(str, "actor_last"),
				kv(str, "fail_walltime"),
				kv(str, "fence_walltime"),
				(unsigned int)time(NULL),
				result_wait ? " result_wait" : "",
				killed ? " killed" : "");
	}
	
	#define MAX_SORT 64
	
	int dlmc_print_status(uint32_t flags)
	{
		struct dlmc_header h;
		struct dlmc_state state;
		struct dlmc_state *st;
		char maxstr[DLMC_STATE_MAXSTR];
		char maxbin[DLMC_STATE_MAXBIN];
		char *str;
		char *bin;
		int all_count, node_count, fence_count, startup_count;
		int all_ids[MAX_SORT];
		int node_ids[MAX_SORT];
		int fence_ids[MAX_SORT];
		int startup_ids[MAX_SORT];
		char *node_lines[MAX_SORT];
		char *fence_lines[MAX_SORT];
		char *node_line;
		char *fence_line;
		int found_node;
		int fd, rv;
		int i, j;
	
		init_header(&h, DLMC_CMD_DUMP_STATUS, NULL, 0);
	
		fd = do_connect(DLMC_QUERY_SOCK_PATH);
		if (fd < 0) {
			printf("cannot connect to dlm_controld\n");
			rv = fd;
			goto out;
		}
	
		rv = do_write(fd, &h, sizeof(h));
		if (rv < 0) {
			printf("cannot send to dlm_controld\n");
			goto out_close;
		}
	
		st = &state;
		str = maxstr;
		bin = maxbin;
	
		all_count = 0;
		node_count = 0;
		fence_count = 0;
		startup_count = 0;
		memset(&all_ids, 0, sizeof(all_ids));
		memset(&node_ids, 0, sizeof(node_ids));
		memset(&fence_ids, 0, sizeof(fence_ids));
		memset(&startup_ids, 0, sizeof(startup_ids));
		memset(node_lines, 0, sizeof(node_lines));
		memset(fence_lines, 0, sizeof(fence_lines));
	
		while (1) {
			memset(&state, 0, sizeof(state));
			memset(maxstr, 0, sizeof(maxstr));
			memset(maxbin, 0, sizeof(maxbin));
	
			rv = recv(fd, st, sizeof(struct dlmc_state), MSG_WAITALL);
			if (!rv)
				break;
			if (rv != sizeof(struct dlmc_state))
				break;
	
			if (st->str_len) {
				rv = recv(fd, str, st->str_len, MSG_WAITALL);
				if (rv != st->str_len)
					break;
			}
	
			if (st->bin_len) {
				rv = recv(fd, bin, st->bin_len, MSG_WAITALL);
				if (rv != st->bin_len)
					break;
			}
	
			switch (st->type) {
			case DLMC_STATE_DAEMON:
				print_daemon(st, str, bin, flags);
				break;
	
			case DLMC_STATE_STARTUP_NODE:
				startup_ids[startup_count++] = st->nodeid;
				break;
	
			case DLMC_STATE_DAEMON_NODE:
				if (flags & DLMC_STATUS_VERBOSE) {
					printf("nodeid %d\n", st->nodeid);
					print_str(str, st->str_len);
				} else {
					node_line = malloc(DLMC_STATE_MAXSTR);
					if (!node_line)
						break;
					fence_line = malloc(DLMC_STATE_MAXSTR);
					if (!fence_line) {
						free(node_line);
						break;
					}
					memset(node_line, 0, DLMC_STATE_MAXSTR);
					memset(fence_line, 0, DLMC_STATE_MAXSTR);
	
					format_daemon_node(st, str, bin, flags,
							   node_line, fence_line);
	
					all_ids[all_count++] = st->nodeid;
	
					node_ids[node_count] = st->nodeid;
					node_lines[node_count] = node_line;
					node_count++;
	
					if (!fence_line[0]) {
						free(fence_line);
					} else {
						fence_ids[fence_count] = st->nodeid;
						fence_lines[fence_count] = fence_line;
						fence_count++;
					}
				}
				break;
	
			default:
				break;
			}
	
			if (rv < 0)
				break;
		}
	
		if (all_count)
			qsort(all_ids, all_count, sizeof(int), nodeid_compare);
	
		/* don't free any node_lines in this startup loop because we are just
		   borrowing them; they are needed in the real node loop below. */
	
		if (startup_count) {
			for (i = 0; i < startup_count; i++) {
				found_node = 0;
				for (j = 0; j < node_count; j++) {
					if (startup_ids[i] != node_ids[j])
						continue;
					found_node = 1;
					if (!node_lines[j])
						printf("startup node %d\n", st->nodeid);
					else
						printf("startup %s", node_lines[j]);
					break;
				}
				if (!found_node)
					printf("startup node %d\n", st->nodeid);
			}
		}
	
		if (all_count && fence_count) {
			for (i = 0; i < all_count; i++) {
				for (j = 0; j < fence_count; j++) {
					if (all_ids[i] != fence_ids[j])
						continue;
					if (!fence_lines[j]) {
						printf("fence %d no data\n", fence_ids[j]);
					} else {
						printf("%s", fence_lines[j]);
						free(fence_lines[j]);
						fence_lines[j] = NULL;
					}
					break;
				}
			}
		}
	
		if (all_count && node_count) {
			for (i = 0; i < all_count; i++) {
				for (j = 0; j < node_count; j++) {
					if (all_ids[i] != node_ids[j])
						continue;
					if (!node_lines[j]) {
						printf("node %d no data\n", node_ids[j]);
					} else {
						printf("%s", node_lines[j]);
						free(node_lines[j]);
						node_lines[j] = NULL;
					}
					break;
				}
			}
		}
	
	 out_close:
		close(fd);
	 out:
		return rv;
	}
	
	int dlmc_node_info(char *name, int nodeid, struct dlmc_node *node)
	{
		struct dlmc_header h, *rh;
		char reply[sizeof(struct dlmc_header) + sizeof(struct dlmc_node)];
		int fd, rv;
	
		init_header(&h, DLMC_CMD_NODE_INFO, name, 0);
		h.data = nodeid;
	
		memset(reply, 0, sizeof(reply));
	
		fd = do_connect(DLMC_QUERY_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
		rv = do_write(fd, &h, sizeof(h));
		if (rv < 0)
			goto out_close;
	
		rv = do_read(fd, reply, sizeof(reply));
		if (rv < 0)
			goto out_close;
	
		rh = (struct dlmc_header *)reply;
		rv = rh->data;
		if (rv < 0)
			goto out_close;
	
		memcpy(node, (char *)reply + sizeof(struct dlmc_header),
		       sizeof(struct dlmc_node));
	 out_close:
		close(fd);
	 out:
		return rv;
	}
	
	int dlmc_lockspace_info(char *name, struct dlmc_lockspace *lockspace)
	{
		struct dlmc_header h, *rh;
		char reply[sizeof(struct dlmc_header) + sizeof(struct dlmc_lockspace)];
		int fd, rv;
	
		init_header(&h, DLMC_CMD_LOCKSPACE_INFO, name, 0);
	
		memset(reply, 0, sizeof(reply));
	
		fd = do_connect(DLMC_QUERY_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
		rv = do_write(fd, &h, sizeof(h));
		if (rv < 0)
			goto out_close;
	
		rv = do_read(fd, reply, sizeof(reply));
		if (rv < 0)
			goto out_close;
	
		rh = (struct dlmc_header *)reply;
		rv = rh->data;
		if (rv < 0)
			goto out_close;
	
		memcpy(lockspace, (char *)reply + sizeof(struct dlmc_header),
		       sizeof(struct dlmc_lockspace));
	 out_close:
		close(fd);
	 out:
		return rv;
	}
	
	int dlmc_lockspaces(int *count, struct dlmc_lockspace **lss)
	{
		struct dlmc_header h;
		int reply_len;
		int fd, rv, result;
	
		fd = do_connect(DLMC_QUERY_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
		init_header(&h, DLMC_CMD_LOCKSPACES, NULL, 0);
	
		rv = do_write(fd, &h, sizeof(h));
		if (rv < 0)
			goto out_close;
	
		rv = do_read(fd, &h, sizeof(h));
		if (rv <0)
			goto out_close;
	
		result = h.data;
		if (result < 0) {
			rv = result;
			goto out_close;
		}
	
		*count = result;
	
		reply_len = h.len - sizeof(struct dlmc_header);
		*lss = malloc(reply_len);
		if (!*lss) {
			rv = -1;
			goto out;
		}
		memset(*lss, 0, reply_len);
	
		rv = do_read(fd, *lss, reply_len);
		if (rv < 0) {
			free(*lss);
			goto out;
		}
	
		rv = 0;
	
	 out_close:
		close(fd);
	 out:
		return rv;
	}
	
	int dlmc_lockspace_nodes(char *name, int type, int max, int *count,
				 struct dlmc_node *nodes)
	{
		struct dlmc_header h, *rh;
		char *reply;
		int reply_len;
		int fd, rv, result, node_count;
	
		init_header(&h, DLMC_CMD_LOCKSPACE_NODES, name, 0);
		h.option = type;
		h.data = max;
	
		reply_len = sizeof(struct dlmc_header) +
			    (max * sizeof(struct dlmc_node));
		reply = malloc(reply_len);

		if (!reply) {
			rv = -1;
			goto out;

		}
		memset(reply, 0, reply_len);
	
		fd = do_connect(DLMC_QUERY_SOCK_PATH);

		if (fd < 0) {
			rv = fd;
			goto out;

		}
	
		rv = do_write(fd, &h, sizeof(h));

		if (rv < 0)

			goto out_close;
	
		/* won't usually get back the full reply_len */

		do_read(fd, reply, reply_len);
	

		rh = (struct dlmc_header *)reply;

		result = rh->data;

		if (result < 0 && result != -E2BIG) {
			rv = result;
			goto out_close;

		}
	

		if (result == -E2BIG) {
			*count = -E2BIG;
			node_count = max;

		} else {

			*count = result;
			node_count = result;
		}
		rv = 0;
	
		memcpy(nodes, (char *)reply + sizeof(struct dlmc_header),
		       node_count * sizeof(struct dlmc_node));
	 out_close:
		close(fd);
	 out:
		return rv;
	}
	
	int dlmc_fs_connect(void)
	{
		return do_connect(DLMC_SOCK_PATH);
	}
	
	void dlmc_fs_disconnect(int fd)
	{
		close(fd);
	}
	
	int dlmc_fs_register(int fd, char *name)
	{
		struct dlmc_header h;
	
		init_header(&h, DLMC_CMD_FS_REGISTER, name, 0);
	
		return do_write(fd, &h, sizeof(h));
	}
	
	int dlmc_fs_unregister(int fd, char *name)
	{
		struct dlmc_header h;
	
		init_header(&h, DLMC_CMD_FS_UNREGISTER, name, 0);
	
		return do_write(fd, &h, sizeof(h));
	}
	
	int dlmc_fs_notified(int fd, char *name, int nodeid)
	{
		struct dlmc_header h;
	
		init_header(&h, DLMC_CMD_FS_NOTIFIED, name, 0);
		h.data = nodeid;
	
		return do_write(fd, &h, sizeof(h));
	}
	
	int dlmc_fs_result(int fd, char *name, int *type, int *nodeid, int *result)
	{
		struct dlmc_header h;
		int rv;
	
		rv = do_read(fd, &h, sizeof(h));
		if (rv < 0)
			goto out;
	
		strncpy(name, h.name, DLM_LOCKSPACE_LEN);
		*nodeid = h.option;
		*result = h.data;
	
		switch (h.command) {
		case DLMC_CMD_FS_REGISTER:
			*type = DLMC_RESULT_REGISTER;
			break;
		case DLMC_CMD_FS_NOTIFIED:
			*type = DLMC_RESULT_NOTIFIED;
			break;
		default:
			*type = 0;
		}
	 out:
		return rv;
	}
	
	int dlmc_deadlock_check(char *name)
	{
		struct dlmc_header h;
		int fd, rv;
	
		init_header(&h, DLMC_CMD_DEADLOCK_CHECK, name, 0);
	
		fd = do_connect(DLMC_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
		rv = do_write(fd, &h, sizeof(h));
		close(fd);
	 out:
		return rv;
	}
	
	int dlmc_fence_ack(char *name)
	{
		struct dlmc_header h;
		int fd, rv;
	
		init_header(&h, DLMC_CMD_FENCE_ACK, name, 0);
	
		fd = do_connect(DLMC_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
		rv = do_write(fd, &h, sizeof(h));
		close(fd);
	 out:
		return rv;
	}
	
	int dlmc_run_start(char *run_command, int len, int nodeid, uint32_t flags, char *run_uuid)
	{
		struct dlmc_header h;
		struct dlmc_header rh;
		char *cmdbuf;
		int fd, rv;
	
		cmdbuf = malloc(DLMC_RUN_COMMAND_LEN);
		if (!cmdbuf)
			return -1;
	
		memset(cmdbuf, 0, DLMC_RUN_COMMAND_LEN);
		strncpy(cmdbuf, run_command, DLMC_RUN_COMMAND_LEN-1);
	
		init_header(&h, DLMC_CMD_RUN_START, NULL, DLMC_RUN_COMMAND_LEN);
		h.data = nodeid;
		h.flags = flags;
	
		memset(&rh, 0, sizeof(rh));
	
		fd = do_connect(DLMC_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
		rv = do_write(fd, &h, sizeof(h));
		if (rv < 0)
			goto out_close;
	
		rv = do_write(fd, cmdbuf, DLMC_RUN_COMMAND_LEN);
		if (rv < 0)
			goto out_close;
	
		rv = do_read(fd, &rh, sizeof(rh));
		if (rv < 0)
			goto out_close;
	
		rv = rh.data;
		if (rv < 0)
			goto out_close;
	
		memcpy(run_uuid, rh.name, DLMC_RUN_UUID_LEN);
		rv = 0;
	
	 out_close:
		close(fd);
	 out:
		free(cmdbuf);
		return rv;
	}
	
	int dlmc_run_check(char *run_uuid, int len, int wait_sec, uint32_t flags,
			   uint32_t *check_status)
	{
		struct dlmc_header h;
		struct dlmc_header rh;
		struct dlmc_run_check_state state;
		uint64_t wait_start = 0;
		int fd, rv;
	
		init_header(&h, DLMC_CMD_RUN_CHECK, NULL, 0);
		h.flags = flags;
		init_header_name(&h, run_uuid, DLMC_RUN_UUID_LEN);
	
		memset(&rh, 0, sizeof(rh));
	
		fd = do_connect(DLMC_SOCK_PATH);
		if (fd < 0) {
			rv = fd;
			goto out;
		}
	
	 retry:
	
		rv = do_write(fd, &h, sizeof(h));
		if (rv < 0) {
			goto out_close;
		}
	
		rv = do_read(fd, &rh, sizeof(rh));
		if (rv < 0) {
			goto out_close;
		}
	
		rv = do_read(fd, &state, sizeof(state));
		if (rv < 0) {
			goto out_close;
		}
	
		if ((state.check_status & DLMC_RUN_STATUS_WAITING) && wait_sec) {
			if (!wait_start) {
				wait_start = time(NULL);
				sleep(1);
				goto retry;
			}
	
			if (time(NULL) - wait_start < wait_sec) {
				sleep(1);
				goto retry;
			}
		}
	
		*check_status = state.check_status;
		rv = 0;
	
	 out_close:
		close(fd);
	 out:
		return rv;
	}