/*
 *  EMU10k1 loader lib
 *  Copyright (c) 2003,2004 by Peter Zubaj
 *
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as
 *   published by the Free Software Foundation; either version 2.1 of
 *   the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
#include <stddef.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <netdb.h>

#include "comm.h"
#include "ld10k1_error.h"

/* taken from glibc example */
int setup_comm(comm_param *param)
{
	int sock;
	struct sockaddr_un lname;
	struct sockaddr_in iname;
	size_t size;

	/* Create the socket. */
	if (param->type == COMM_TYPE_LOCAL)
		sock = socket (PF_LOCAL, SOCK_STREAM, 0);
	else
		sock = socket (PF_INET, SOCK_STREAM, 0);
	if (sock < 0)
		return -1;

	if (param->server)	{
		if (param->type == COMM_TYPE_LOCAL) {
			unlink(param->name);

			/* Bind a name to the socket. */
			memset(&lname, 0, sizeof(struct sockaddr_un));
			lname.sun_family = AF_LOCAL;
			strncpy (lname.sun_path, param->name, sizeof (lname.sun_path) - 1);
			lname.sun_path[sizeof (lname.sun_path) - 1] = '\0';

			/* The size of the address is
			the offset of the start of the filename,
			plus its length,
			plus one for the terminating null byte.
			Alternatively you can just do:
			size = SUN_LEN (&name);
			*/
			size = (offsetof (struct sockaddr_un, sun_path)	+ strlen (lname.sun_path) + 1);

			if (bind (sock, (struct sockaddr *) &lname, size) < 0)
				return -1;

			chmod(param->name, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
		} else {
			/* Give the socket a name. */
			memset(&iname, 0, sizeof(struct sockaddr_in));
			iname.sin_family = AF_INET;
			iname.sin_port = htons (param->port);
			iname.sin_addr.s_addr = htonl(INADDR_ANY);
			if (bind(sock, (struct sockaddr *) &iname, sizeof (iname)) < 0)
				return -1;
		}
	}

	return sock;
}

int connect_comm(int conn_num, comm_param *param)
{
	struct sockaddr_un lname;
	struct sockaddr_in iname;
	struct hostent *hostinfo;
	size_t size;
	
	int attempt;
	int max_attempt;
	int not_connected;
	
	attempt = 0;
	if (param->wfc)
		max_attempt = param->wfc / 10;
	else
		max_attempt = 0;

	if (param->type == COMM_TYPE_LOCAL) {
		memset(&lname, 0, sizeof(struct sockaddr_un));
		lname.sun_family = AF_LOCAL;
		strncpy (lname.sun_path, param->name, sizeof (lname.sun_path) - 1);
		lname.sun_path[sizeof(lname.sun_path) - 1] = '\0';

		size = (offsetof(struct sockaddr_un, sun_path)) + strlen(lname.sun_path) + 1;

		while (1)
		{
			not_connected = connect(conn_num, (struct sockaddr *) &lname, size);
			if (!not_connected)
				break;
			if (attempt >= max_attempt)
				return -1;
			attempt++;
			usleep(10000);
		}
	} else {
		memset(&iname, 0, sizeof(struct sockaddr_in));
		iname.sin_family = AF_INET;
		iname.sin_port = htons(param->port);
		hostinfo = gethostbyname(param->name);
		if (hostinfo == NULL)
			return -1;
		iname.sin_addr = *(struct in_addr *)hostinfo->h_addr;
		
		while (1)
		{
			not_connected = connect(conn_num, (struct sockaddr *) &iname, sizeof(struct sockaddr_in));
			if (!not_connected)
				break;
			if (attempt >= max_attempt)
				return -1;
			attempt++;
			usleep(10000);
		}
	}
	return 0;
}

int listen_comm(int conn_num)
{
	if (listen(conn_num, 1) < 0)
		return -1;
	return 0;
}

int accept_comm(int conn_num)
{
	struct sockaddr addr;
	socklen_t addr_len;
	int sock;

	addr_len = sizeof(addr);
	
	sock = accept(conn_num, &addr, &addr_len);
	
	if (sock < 0)
		return -1;

	return sock;
}

int free_comm(int conn_num)
{	
	if (shutdown(conn_num, 2))
		return -1;
	if (close(conn_num) < 0)
		return -1;

	return 0;
}

#define MAX_ATEMPT 5

int read_all(int conn_num, void *data, int data_size)
{
	int offset = 0;
	int how_much = data_size;
	int atempt = 0;
	int readed = 0;
	
	while (atempt < MAX_ATEMPT && how_much > 0)	{
		readed = read(conn_num, ((char *)data) + offset, how_much);
		if (readed < 0)
			return LD10K1_ERR_COMM_READ;
		offset += readed;
		how_much -= readed;
		atempt++;
		if (how_much > 0)
			usleep(10000);
	}
	
	if (how_much > 0)
		return LD10K1_ERR_COMM_READ;
	else
		return data_size;
}

int write_all(int conn_num, void *data, int data_size)
{
	int offset = 0;
	int how_much = data_size;
	int atempt = 0;
	int writed = 0;
	
	while (atempt < MAX_ATEMPT && how_much > 0)	{
		writed = write(conn_num, ((char *)data) + offset, how_much);
		if (writed < 0)
			return LD10K1_ERR_COMM_WRITE;
		offset += writed;
		how_much -= writed;
		atempt++;
		if (how_much > 0)
			usleep(50000);
	}
	
	if (how_much > 0)
		return LD10K1_ERR_COMM_WRITE;
	else
		return data_size;
}

int send_request(int conn_num, int op, void *data, int data_size)
{
	int nbytes;
	struct msg_req header;

	header.op = op;
	header.size = data_size;

	/* header */
	nbytes = write_all(conn_num, &header, sizeof(header));
	if (nbytes < 0)
		return nbytes;

	if (data_size > 0) {
		/* data */
		nbytes = write_all(conn_num, data, data_size);
		if (nbytes < 0)
			return nbytes;
	}
	return 0;
}

int send_response(int conn_num, int op, int err, void *data, int data_size)
{
	int nbytes;
	struct msg_resp header;

	header.op = op;
	header.err = err;
	header.size = data_size;

	/* header */
	nbytes = write_all(conn_num, &header, sizeof(header));
	if (nbytes < 0)
		return nbytes;

	if (data_size > 0) {
		/* data */
		nbytes = write_all(conn_num, data, data_size);
		if (nbytes < 0)
			return nbytes;
	}
	return 0;
}

int send_msg_data(int conn_num, void *data, int data_size)
{
	int nbytes;

	if (data_size > 0) {
		/* data */
		nbytes = write_all(conn_num, data, data_size);
		if (nbytes < 0)
			return nbytes;
	}
	return 0;
}

int receive_request(int conn_num, int *op, int *data_size)
{
	struct msg_req header;
	int nbytes;
	
	nbytes = read_all(conn_num, &header, sizeof(header));
	if (nbytes < 0)
		return nbytes;
	if (nbytes == 0) {
		*op = -1;
		*data_size = 0;
		return 0;
	}
	*op = header.op;
	*data_size = header.size;
	return 0;
}

int receive_response(int conn_num, int *op, int *data_size)
{
	struct msg_resp header;
	int nbytes;
	
	nbytes = read_all(conn_num, &header, sizeof(header));
	if (nbytes < 0)
		return nbytes;
	if (nbytes == 0) {
		*op = -1;
		*data_size = 0;
		return 0;
	}
	*op = header.op;
	*data_size = header.size;
	if (header.err < 0)
		return header.err;
	return 0;
}

int receive_msg_data(int conn_num, void *data, int data_size)
{
	int nbytes;
	nbytes = read_all(conn_num, data, data_size);
	if (nbytes < 0)
		return nbytes;
	return 0;
}

void *receive_msg_data_malloc(int conn_num, int data_size)
{
	void *tmp;
	
	tmp = malloc(data_size);
	if (!tmp)
		return NULL;
		
	if (receive_msg_data(conn_num, tmp, data_size)) {
		free(tmp);
		return NULL;	
	}
	return tmp;
}