/*
 * Copyright (c) 2026 Christoph Liebender <christoph@liebender.dev>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "relayd.h"

#define PROXY_V2_CMD_PROXY 0x01

#define PROXY_V2_FAM_UNSPEC 0x00
#define PROXY_V2_FAM_TCP4   0x11
#define PROXY_V2_FAM_UDP4   0x12
#define PROXY_V2_FAM_TCP6   0x21
#define PROXY_V2_FAM_UDP6   0x22

static const u_int8_t PROXY_V2_SIG[12] = {
	0x0D, 0x0A, 0x0D, 0x0A, 0x00, 0x0D, 0x0A, 0x51, 0x55, 0x49, 0x54, 0x0A
};

struct proxy_v2_hdr {
	u_int8_t sig[12];
	u_int8_t ver_cmd;
	u_int8_t fam;
	u_int16_t len;
};

union proxy_v2_addr {
	struct {
		u_int32_t src_addr;
		u_int32_t dst_addr;
		in_port_t src_port;
		in_port_t dst_port;
	} ipv4_addr;
	struct {
		u_int8_t  src_addr[16];
		u_int8_t  dst_addr[16];
		in_port_t src_port;
		in_port_t dst_port;
	} ipv6_addr;
};

int
proxy_protocol_v1(struct rsession *con, struct evbuffer *dstout)
{
	char ibuf[128], obuf[128];
	const char *proxyproto;
	int ret;

	bzero(&ibuf, sizeof(ibuf));
	bzero(&obuf, sizeof(obuf));

	if (print_host(&con->se_in.ss, ibuf, sizeof(ibuf)) == NULL ||
	    print_host(&con->se_sockname, obuf, sizeof(obuf)) == NULL)
		return -1;

	if (con->se_relay->rl_conf.flags & F_UDP)
		proxyproto = "UNKNOWN";
	else {
		switch (con->se_in.ss.ss_family) {
		case AF_INET:
			proxyproto = "TCP4";
			break;
		case AF_INET6:
			proxyproto = "TCP6";
			break;
		default:
			proxyproto = "UNKNOWN";
			break;
		}
	}

	ret = evbuffer_add_printf(dstout,
		"PROXY %s %s %s %d %d\r\n", proxyproto, ibuf, obuf,
		ntohs(con->se_in.port), ntohs(con->se_relay->rl_conf.port));

	return ret == -1 ? -1 : 0;
}

int
proxy_protocol_v2(struct rsession *con, struct evbuffer *dstout)
{
	union proxy_v2_addr 	       addr;
	struct proxy_v2_hdr 	       hdr;
	const struct relay_config     *conf = &con->se_relay->rl_conf;
	const struct sockaddr_storage *srcss = &con->se_in.ss;
	const struct sockaddr_storage *dstss = &con->se_sockname;
	int 			       error;
	in_port_t		       srcport = con->se_in.port;
	in_port_t		       dstport = conf->port;
	u_int16_t 		       len;

	bcopy(PROXY_V2_SIG, hdr.sig, sizeof(hdr.sig));
	hdr.ver_cmd = 0x20 | PROXY_V2_CMD_PROXY;

	switch (dstss->ss_family) {
	case AF_INET:
		hdr.fam = (conf->flags & F_UDP) ?
			PROXY_V2_FAM_UDP4 : PROXY_V2_FAM_TCP4;
		len = sizeof(addr.ipv4_addr);
		addr.ipv4_addr.src_addr =
		    ((const struct sockaddr_in *)srcss)->sin_addr.s_addr;
		addr.ipv4_addr.dst_addr =
		    ((const struct sockaddr_in *)dstss)->sin_addr.s_addr;
		addr.ipv4_addr.src_port = srcport;
		addr.ipv4_addr.dst_port = dstport;
		break;
	case AF_INET6:
		hdr.fam = (conf->flags & F_UDP) ?
			PROXY_V2_FAM_UDP6 : PROXY_V2_FAM_TCP6;
		len = sizeof(addr.ipv6_addr);
		bcopy(&((const struct sockaddr_in6 *)srcss)->sin6_addr,
		    addr.ipv6_addr.src_addr, sizeof(addr.ipv6_addr.src_addr));
		bcopy(&((const struct sockaddr_in6 *)dstss)->sin6_addr,
		    addr.ipv6_addr.dst_addr, sizeof(addr.ipv6_addr.dst_addr));
		addr.ipv6_addr.src_port = srcport;
		addr.ipv6_addr.dst_port = dstport;
		break;
	default:
		hdr.fam = 0x00;
		len = 0;
		break;
	}

	hdr.len = htons(len);

	if ((error = evbuffer_add(dstout, &hdr, sizeof(hdr))) != 0)
		return error;

	if (len > 0 && (error = evbuffer_add(dstout, &addr, len)) != 0)
		return error;

	return 0;
}