#include <stdlib.h>
#include <string.h>

#include "port_internal.h"
#include "context_internal.h"
#include "debug.h"

struct sepol_port {
	/* Low - High range. Same for single ports. */
	int low, high;

	/* Protocol */
	int proto;

	/* Context */
	sepol_context_t *con;
};

struct sepol_port_key {
	/* Low - High range. Same for single ports. */
	int low, high;

	/* Protocol */
	int proto;
};

/* Key */
int sepol_port_key_create(sepol_handle_t * handle,
			  int low, int high, int proto,
			  sepol_port_key_t ** key_ptr)
{

	sepol_port_key_t *tmp_key =
	    (sepol_port_key_t *) malloc(sizeof(sepol_port_key_t));

	if (!tmp_key) {
		ERR(handle, "out of memory, could not create " "port key");
		return STATUS_ERR;
	}

	tmp_key->low = low;
	tmp_key->high = high;
	tmp_key->proto = proto;

	*key_ptr = tmp_key;
	return STATUS_SUCCESS;
}

hidden_def(sepol_port_key_create)

void sepol_port_key_unpack(const sepol_port_key_t * key,
			   int *low, int *high, int *proto)
{

	*low = key->low;
	*high = key->high;
	*proto = key->proto;
}

hidden_def(sepol_port_key_unpack)

int sepol_port_key_extract(sepol_handle_t * handle,
			   const sepol_port_t * port,
			   sepol_port_key_t ** key_ptr)
{

	if (sepol_port_key_create
	    (handle, port->low, port->high, port->proto, key_ptr) < 0) {

		ERR(handle, "could not extract key from port %s %d:%d",
		    sepol_port_get_proto_str(port->proto),
		    port->low, port->high);

		return STATUS_ERR;
	}

	return STATUS_SUCCESS;
}

void sepol_port_key_free(sepol_port_key_t * key)
{
	free(key);
}

int sepol_port_compare(const sepol_port_t * port, const sepol_port_key_t * key)
{

	if ((port->low == key->low) &&
	    (port->high == key->high) && (port->proto == key->proto))
		return 0;

	if (port->low < key->low)
		return -1;

	else if (key->low < port->low)
		return 1;

	else if (port->high < key->high)
		return -1;

	else if (key->high < port->high)
		return 1;

	else if (port->proto < key->proto)
		return -1;

	else
		return 1;
}

int sepol_port_compare2(const sepol_port_t * port, const sepol_port_t * port2)
{

	if ((port->low == port2->low) &&
	    (port->high == port2->high) && (port->proto == port2->proto))
		return 0;

	if (port->low < port2->low)
		return -1;

	else if (port2->low < port->low)
		return 1;

	else if (port->high < port2->high)
		return -1;

	else if (port2->high < port->high)
		return 1;

	else if (port->proto < port2->proto)
		return -1;

	else
		return 1;
}

/* Port */
int sepol_port_get_low(const sepol_port_t * port)
{

	return port->low;
}

hidden_def(sepol_port_get_low)

int sepol_port_get_high(const sepol_port_t * port)
{

	return port->high;
}

hidden_def(sepol_port_get_high)

void sepol_port_set_port(sepol_port_t * port, int port_num)
{

	port->low = port_num;
	port->high = port_num;
}

void sepol_port_set_range(sepol_port_t * port, int low, int high)
{

	port->low = low;
	port->high = high;
}

hidden_def(sepol_port_set_range)

/* Protocol */
int sepol_port_get_proto(const sepol_port_t * port)
{

	return port->proto;
}

hidden_def(sepol_port_get_proto)

const char *sepol_port_get_proto_str(int proto)
{

	switch (proto) {
	case SEPOL_PROTO_UDP:
		return "udp";
	case SEPOL_PROTO_TCP:
		return "tcp";
	case SEPOL_PROTO_DCCP:
		return "dccp";
	case SEPOL_PROTO_SCTP:
		return "sctp";
	default:
		return "???";
	}
}

hidden_def(sepol_port_get_proto_str)

void sepol_port_set_proto(sepol_port_t * port, int proto)
{

	port->proto = proto;
}

hidden_def(sepol_port_set_proto)

/* Create */
int sepol_port_create(sepol_handle_t * handle, sepol_port_t ** port)
{

	sepol_port_t *tmp_port = (sepol_port_t *) malloc(sizeof(sepol_port_t));

	if (!tmp_port) {
		ERR(handle, "out of memory, could not create " "port record");
		return STATUS_ERR;
	}

	tmp_port->low = 0;
	tmp_port->high = 0;
	tmp_port->proto = SEPOL_PROTO_UDP;
	tmp_port->con = NULL;
	*port = tmp_port;

	return STATUS_SUCCESS;
}

hidden_def(sepol_port_create)

/* Deep copy clone */
int sepol_port_clone(sepol_handle_t * handle,
		     const sepol_port_t * port, sepol_port_t ** port_ptr)
{

	sepol_port_t *new_port = NULL;
	if (sepol_port_create(handle, &new_port) < 0)
		goto err;

	new_port->low = port->low;
	new_port->high = port->high;
	new_port->proto = port->proto;

	if (port->con &&
	    (sepol_context_clone(handle, port->con, &new_port->con) < 0))
		goto err;

	*port_ptr = new_port;
	return STATUS_SUCCESS;

      err:
	ERR(handle, "could not clone port record");
	sepol_port_free(new_port);
	return STATUS_ERR;
}

/* Destroy */
void sepol_port_free(sepol_port_t * port)
{

	if (!port)
		return;

	sepol_context_free(port->con);
	free(port);
}

hidden_def(sepol_port_free)

/* Context */
sepol_context_t *sepol_port_get_con(const sepol_port_t * port)
{

	return port->con;
}

hidden_def(sepol_port_get_con)

int sepol_port_set_con(sepol_handle_t * handle,
		       sepol_port_t * port, sepol_context_t * con)
{

	sepol_context_t *newcon;

	if (sepol_context_clone(handle, con, &newcon) < 0) {
		ERR(handle, "out of memory, could not set port context");
		return STATUS_ERR;
	}

	sepol_context_free(port->con);
	port->con = newcon;
	return STATUS_SUCCESS;
}

hidden_def(sepol_port_set_con)
