/*
* High Speed modem to transfer data in a 2,7kHz SSB channel
* =========================================================
* Author: DJ0ABR
*
*   (c) DJ0ABR
*   www.dj0abr.de

websocket server: based on the work by: Davidson Francis <davidsondfgl@gmail.com>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>
*/
#include "../hsmodem.h"

/* Registered events. */
struct ws_events events;

/**
 * Gets the IP address relative to a
 * file descriptor opened by the server.
 * @param fd File descriptor target.
 * @return Pointer the ip address.
 */
char* ws_getaddress(int fd)
{
	struct sockaddr_in addr;
#ifdef WIN32
	int addr_size;
#else
    socklen_t addr_size;
#endif
    char *client;

    addr_size = sizeof(struct sockaddr_in);
    if ( getpeername(fd, (struct sockaddr *)&addr, &addr_size) < 0 )
    	return NULL;

    client = (char *)malloc(sizeof(char) * 20);
    if(client == NULL)
        return NULL;
    
    strcpy(client, inet_ntoa(addr.sin_addr));
    return (client);
}

/**
 * Creates and send a WebSocket frame
 * with some binary message.
 * @param fd  Target to be send.
 * @param msg Message to be send.
 */
int ws_sendframe_binary(int fd, unsigned char *msg, uint64_t length)
{
	unsigned char *response;  /* Response data.  */
	unsigned char frame[10];  /* Frame.          */
	uint8_t idx_first_rData;  /* Index data.     */
	int idx_response;      /* Index response. */
	int output;               /* Bytes sent.     */

	/* Binary data. */
	frame[0] = (WS_FIN | WS_FR_OP_BINARY);

	/* Split the size between octects. */
	if (length <= 125)
	{
		frame[1] = length & 0x7F;
		idx_first_rData = 2;
	}

	/* Size between 126 and 65535 bytes. */
	else if (length >= 126 && length <= 65535)
	{
		frame[1] = 126;
		frame[2] = (length >> 8) & 255;
		frame[3] = length & 255;
		idx_first_rData = 4;
	}

	/* More than 65535 bytes. */
	else
	{
		frame[1] = 127;
		frame[2] = (unsigned char) ((length >> 56) & 255);
		frame[3] = (unsigned char) ((length >> 48) & 255);
		frame[4] = (unsigned char) ((length >> 40) & 255);
		frame[5] = (unsigned char) ((length >> 32) & 255);
		frame[6] = (unsigned char) ((length >> 24) & 255);
		frame[7] = (unsigned char) ((length >> 16) & 255);
		frame[8] = (unsigned char) ((length >> 8) & 255);
		frame[9] = (unsigned char) (length & 255);
		idx_first_rData = 10;
	}

	/* Add frame bytes. */
	idx_response = 0;
	response = (unsigned char *)malloc((size_t)( sizeof(unsigned char) * (idx_first_rData + length + 1)));
    if(response != NULL)
    {
        for (int i = 0; i < idx_first_rData; i++)
        {
            response[i] = frame[i];
            idx_response++;
        }

        /* Add data bytes. */
        for (uint64_t i = 0; i < length; i++)
        {
            response[idx_response] = msg[i];
            idx_response++;
        }
		output = send(fd, (char *)response, idx_response,0);
        free(response);
        return (output);
    }
	return 0;
}


/**
 * Receives a text frame, parse and decodes it.
 * @param frame  WebSocket frame to be parsed.
 * @param length Frame length.
 * @param type   Frame type.
 */
static unsigned char* ws_receiveframe(unsigned char *frame, size_t length, int *type)
{
	unsigned char *msg;     /* Decoded message.        */
	uint8_t mask;           /* Payload is masked?      */
	uint8_t flength;        /* Raw length.             */
	uint8_t idx_first_mask; /* Index masking key.      */
	uint8_t idx_first_data; /* Index data.             */
	size_t  data_length;    /* Data length.            */
	uint8_t masks[4];       /* Masking key.            */
	int     i,j;            /* Loop indexes.           */

	msg = NULL;
	
	/* Checks the frame type and parse the frame. */
	if (frame[0] == (WS_FIN | WS_FR_OP_TXT) )
	{
		*type = WS_FR_OP_TXT;
		idx_first_mask = 2;
		mask           = frame[1];
		flength        = mask & 0x7F;

		if (flength == 126)
			idx_first_mask = 4;
		else if (flength == 127)
			idx_first_mask = 10;

		idx_first_data = idx_first_mask + 4;
		data_length = length - idx_first_data;

		masks[0] = frame[idx_first_mask+0];
		masks[1] = frame[idx_first_mask+1];
		masks[2] = frame[idx_first_mask+2];
		masks[3] = frame[idx_first_mask+3];

		msg = (unsigned char *)malloc(sizeof(unsigned char) * (data_length+1) );
        if(msg == NULL)
            return NULL;
        
		for (i = idx_first_data, j = 0; i < (int)length; i++, j++)
			msg[j] = frame[i] ^ masks[j % 4];

		msg[j] = '\0';
	}

	/* Close frame. */
	else if (frame[0] == (WS_FIN | WS_FR_OP_CLSE) )
		*type = WS_FR_OP_CLSE;
	
	/* Not supported frame yet. */
	else
		*type = frame[0] & 0x0F;

	return msg;
}

// nonblocking read with a 10ms timeout
int readsocket(int sock, unsigned char* buf, int maxlen)
{
	int n;
	// make the read unblocking
	// but check with select if something is in the receive buffer
	fd_set input;
	FD_ZERO(&input);
	FD_SET(sock, &input);
	struct timeval timeout;
	timeout.tv_sec = 0;
	timeout.tv_usec = 10000;
	n = select(sock + 1, &input, NULL, NULL, &timeout); // select will socket+1, blöd, aber ist so
	if (n <= 0)
	{
		return n; // 0=no data, <0=error
	}

	if (!FD_ISSET(sock, &input))
	{
		return -1;  // error
	}

	sleep_ms(10);  // wait a bit to give a message the chance to be rxed completely
	n = recv(sock, (char*)buf, maxlen, 0);
    return n;
}

/**
 * Establishes to connection with the client and trigger
 * events when occurs one.
 * @param vsock Client file descriptor.
 * @note This will be run on a different thread.
 */

#ifdef WIN32
void ws_establishconnection(void* vsock)
{
#else
void* ws_establishconnection(void* vsock)
{
	pthread_detach(pthread_self());
#endif

	int sock;
	size_t n;                           /* Number of bytes sent/received. */
	unsigned char frm[MESSAGE_LENGTH];  /* Frame.                         */
	unsigned char *msg;                 /* Message.                       */
	char *response;                     /* Response frame.                */
	int  handshaked;                    /* Handshake state.               */
	int  type;                          /* Frame type.                    */
	unsigned char cnt0=0,cnt1=0;

	handshaked = 0;
	sock = (int)(intptr_t)vsock;

	while (keeprunning)
	{
		n = readsocket(sock, frm, sizeof(unsigned char) * MESSAGE_LENGTH);
		/* Receives message until get some error. */
		if (n >= 0)
		{
			if (n > 0)
			{
				// data received
				/* If not handshaked yet. */
				if (!handshaked)
				{
					getHSresponse((char*)frm, &response);
					handshaked = 1;
					/*printf("Handshaked, response: \n"
						"------------------------------------\n"
						"%s"
						"------------------------------------\n"
						,response);*/
					n = send(sock, response, strlen(response),0);
					events.onopen(sock);
					free(response);
				}

				/* Decode/check type of frame. */
				msg = ws_receiveframe(frm, n, &type);

				if (msg == NULL)
					continue;

				/* Trigger events. */
				if (type == WS_FR_OP_TXT)
					events.onmessage(sock, msg);
				else if (type == WS_FR_OP_CLSE)
				{
					if (msg != NULL) free(msg);
					events.onclose(sock);
#ifdef WIN32
					return;
#else
					return vsock;
#endif
				}
				else
					printf("type :%d\n", type);

				if (msg != NULL) free(msg);
			}
			if (n == 0)
			{
				if (get_alive(sock) == 0)
				{
					events.onclose(sock);
#ifdef WIN32
					return;
#else
					return vsock;
#endif
				}
				
				// no data received, normal processing loop
				int ret = events.onwork(sock, &cnt0, &cnt1);
				if (ret == -1)
				{
					// other side closed the connection (write error)
					events.onclose(sock);
#ifdef WIN32
					return;
#else
					return vsock;
#endif
				}
				sleep_ms(10);      // do not eat up the CPU time
			}
		}
	}

	
#ifdef WIN32
	_close(sock);
	return;
#else
	close(sock);
	return vsock;
#endif
}

/**
 * Main loop for the server, runs in a thread
 * @param evs  Events structure.
 * @param port Server port.
 */
int ws_socket(struct ws_events *evs, int port)
{
	int sock;                  /* Current socket.        */
	int new_sock;              /* New opened connection. */
	struct sockaddr_in server; /* Server.                */
	struct sockaddr_in client; /* Client.                */
	int len;                   /* Length of sockaddr.    */

	if (evs == NULL || port <= 0 || port >  65535)
	{
		printf("An error has ocurred, please review your events or the desired port!\n");
		return -1;
	}

	/* Copy events. */
	memcpy(&events, evs, sizeof(struct ws_events));

#ifdef _WIN32_
	WSADATA wsaData = { 0 };
	int ires = WSAStartup(MAKEWORD(2, 2), &wsaData);
	if (ires != 0)
		printf("WSAStartup failed: %d\n", ires);
#endif

	/* Create socket. */
	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock < 0) {
		printf("Could not create socket\n");
		return -1;
	}

	/* Reuse previous address. */
	const char val = 1;
	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int)) < 0)
	{
    	perror("setsockopt(SO_REUSEADDR) failed");
		return -1;
	}

	/* Prepare the sockaddr_in structure. */
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = INADDR_ANY;
    printf("Websocket Server: listen to port:%d\n",port);
	server.sin_port = htons(port);

	/* Bind. */
	if( bind(sock, (struct sockaddr *)&server, sizeof(server)) < 0 )
	{
		perror("Bind failed");
		return -1;
	}

	/* Listen. */
	listen(sock, MAX_CLIENTS);

	/* Wait for incoming connections. */
	printf("Waiting for incoming connections...\n");

	len = sizeof(struct sockaddr_in);
	
	/* Accept connections. */
	while (keeprunning)
	{
		//if (extData_active)
		{
			/* Accept. */
#ifdef WIN32
			new_sock = accept(sock, (struct sockaddr*)&client, &len);
			printf("new socket: %d\n", new_sock);
#else
			new_sock = accept(sock, (struct sockaddr*)&client, (socklen_t*)&len);
#endif
			if (new_sock < 0)
			{
				perror("Error on accepting conections..");
				exit(-1);
			}

#ifdef WIN32
			printf("start Thread\n");
			_beginthread(ws_establishconnection, 0, (void*)(intptr_t)new_sock);
#else
			pthread_t client_thread;
			if (pthread_create(&client_thread, NULL, ws_establishconnection, (void*)(intptr_t)new_sock) < 0)
				perror("Could not create the client thread!");

			pthread_detach(client_thread); // automatically release all ressources as soon as the thread is done
#endif
		}
		/*else
		{
			sleep_ms(100);
		}*/
	}
	return 0;
}