/*
 * Copyright (c) 2012 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@dragonflybsd.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. Neither the name of The DragonFly Project 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 HOLDERS 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 "dmsg_local.h"

const char *
dmsg_basecmd_str(uint32_t cmd)
{
	static char buf[64];
	char protobuf[32];
	char cmdbuf[32];
	const char *protostr;
	const char *cmdstr;

	switch(cmd & DMSGF_PROTOS) {
	case DMSG_PROTO_LNK:
		protostr = "LNK_";
		break;
	case DMSG_PROTO_DBG:
		protostr = "DBG_";
		break;
	case DMSG_PROTO_HM2:
		protostr = "HM2_";
		break;
	case DMSG_PROTO_BLK:
		protostr = "BLK_";
		break;
	case DMSG_PROTO_VOP:
		protostr = "VOP_";
		break;
	default:
		snprintf(protobuf, sizeof(protobuf), "%x_",
			(cmd & DMSGF_PROTOS) >> 20);
		protostr = protobuf;
		break;
	}

	switch(cmd & (DMSGF_PROTOS |
		      DMSGF_CMDS |
		      DMSGF_SIZE)) {
	case DMSG_LNK_PAD:
		cmdstr = "PAD";
		break;
	case DMSG_LNK_PING:
		cmdstr = "PING";
		break;
	case DMSG_LNK_AUTH:
		cmdstr = "AUTH";
		break;
	case DMSG_LNK_CONN:
		cmdstr = "CONN";
		break;
	case DMSG_LNK_SPAN:
		cmdstr = "SPAN";
		break;
	case DMSG_LNK_ERROR:
		if (cmd & DMSGF_DELETE)
			cmdstr = "RETURN";
		else
			cmdstr = "RESULT";
		break;
	case DMSG_DBG_SHELL:
		cmdstr = "SHELL";
		break;
	default:
		snprintf(cmdbuf, sizeof(cmdbuf),
			 "%06x", (cmd & (DMSGF_PROTOS |
					 DMSGF_CMDS |
					 DMSGF_SIZE)));
		cmdstr = cmdbuf;
		break;
	}
	snprintf(buf, sizeof(buf), "%s%s", protostr, cmdstr);
	return (buf);
}

const char *
dmsg_msg_str(dmsg_msg_t *msg)
{
	dmsg_state_t *state;
	static char buf[256];
	char errbuf[16];
	char statebuf[64];
	char flagbuf[64];
	const char *statestr;
	const char *errstr;
	uint32_t basecmd;
	int i;

	/*
	 * Parse the state
	 */
	if ((state = msg->state) != NULL) {
		basecmd = (state->rxcmd & DMSGF_REPLY) ?
			  state->txcmd : state->rxcmd;
		snprintf(statebuf, sizeof(statebuf),
			 " %s=%s,L=%s%s,R=%s%s",
			 ((state->txcmd & DMSGF_REPLY) ?
				"rcvcmd" : "sndcmd"),
			 dmsg_basecmd_str(basecmd),
			 ((state->txcmd & DMSGF_CREATE) ? "C" : ""),
			 ((state->txcmd & DMSGF_DELETE) ? "D" : ""),
			 ((state->rxcmd & DMSGF_CREATE) ? "C" : ""),
			 ((state->rxcmd & DMSGF_DELETE) ? "D" : "")
		);
		statestr = statebuf;
	} else {
		statestr = "";
	}

	/*
	 * Parse the error
	 */
	switch(msg->any.head.error) {
	case 0:
		errstr = "";
		break;
	case DMSG_IOQ_ERROR_SYNC:
		errstr = "err=IOQ:NOSYNC";
		break;
	case DMSG_IOQ_ERROR_EOF:
		errstr = "err=IOQ:STREAMEOF";
		break;
	case DMSG_IOQ_ERROR_SOCK:
		errstr = "err=IOQ:SOCKERR";
		break;
	case DMSG_IOQ_ERROR_FIELD:
		errstr = "err=IOQ:BADFIELD";
		break;
	case DMSG_IOQ_ERROR_HCRC:
		errstr = "err=IOQ:BADHCRC";
		break;
	case DMSG_IOQ_ERROR_XCRC:
		errstr = "err=IOQ:BADXCRC";
		break;
	case DMSG_IOQ_ERROR_ACRC:
		errstr = "err=IOQ:BADACRC";
		break;
	case DMSG_IOQ_ERROR_STATE:
		errstr = "err=IOQ:BADSTATE";
		break;
	case DMSG_IOQ_ERROR_NOPEER:
		errstr = "err=IOQ:PEERCONFIG";
		break;
	case DMSG_IOQ_ERROR_NORKEY:
		errstr = "err=IOQ:BADRKEY";
		break;
	case DMSG_IOQ_ERROR_NOLKEY:
		errstr = "err=IOQ:BADLKEY";
		break;
	case DMSG_IOQ_ERROR_KEYXCHGFAIL:
		errstr = "err=IOQ:BADKEYXCHG";
		break;
	case DMSG_IOQ_ERROR_KEYFMT:
		errstr = "err=IOQ:BADFMT";
		break;
	case DMSG_IOQ_ERROR_BADURANDOM:
		errstr = "err=IOQ:BADRANDOM";
		break;
	case DMSG_IOQ_ERROR_MSGSEQ:
		errstr = "err=IOQ:BADSEQ";
		break;
	case DMSG_IOQ_ERROR_EALREADY:
		errstr = "err=IOQ:DUPMSG";
		break;
	case DMSG_IOQ_ERROR_TRANS:
		errstr = "err=IOQ:BADTRANS";
		break;
	case DMSG_IOQ_ERROR_IVWRAP:
		errstr = "err=IOQ:IVWRAP";
		break;
	case DMSG_IOQ_ERROR_MACFAIL:
		errstr = "err=IOQ:MACFAIL";
		break;
	case DMSG_IOQ_ERROR_ALGO:
		errstr = "err=IOQ:ALGOFAIL";
		break;
	case DMSG_ERR_NOSUPP:
		errstr = "err=NOSUPPORT";
		break;
	default:
		snprintf(errbuf, sizeof(errbuf),
			 " err=%d", msg->any.head.error);
		errstr = errbuf;
		break;
	}

	/*
	 * Message flags
	 */
	i = 0;
	if (msg->any.head.cmd & (DMSGF_CREATE | DMSGF_DELETE |
				 DMSGF_ABORT | DMSGF_REPLY)) {
		flagbuf[i++] = '|';
		if (msg->any.head.cmd & DMSGF_CREATE)
			flagbuf[i++] = 'C';
		if (msg->any.head.cmd & DMSGF_DELETE)
			flagbuf[i++] = 'D';
		if (msg->any.head.cmd & DMSGF_REPLY)
			flagbuf[i++] = 'R';
		if (msg->any.head.cmd & DMSGF_ABORT)
			flagbuf[i++] = 'A';
	}
	flagbuf[i] = 0;

	/*
	 * Generate the buf
	 */
	snprintf(buf, sizeof(buf),
		"msg=%s%s %s %s hcrc=%08x id=%016jx",
		 dmsg_basecmd_str(msg->any.head.cmd),
		 flagbuf,
		 errstr,
		 statestr,
		 msg->any.head.hdr_crc,
		 msg->any.head.msgid);

	return(buf);
}