/*
Copyright (C) 2017 Paweł Redman

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, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
*/

#include "shared.h"

int server_sockfd;

static int parse_req_addr(char *begin, char *end, uint32_t *out)
{
	char *p;
	size_t i = 0, parts[4] = {0, 0, 0, 0};

	for (p = begin; p < end; p++) {
		if (*p >= '0' && *p <= '9') {
			parts[i] *= 10;
			parts[i] += *p - '0';

			if (parts[i] > 255)
				return 1;
		} else if (*p == '.') {
			i++;

			if (i > 3)
				return 1;
		} else
			break;
	}

	if (i != 3)
		return 1;

	*out = (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3];
	return 0;
}

#define NUM_WORKERS 8 // FIXME: shouldn't be hardcoded

int main(void)
{
	int error = 0; // return value
	struct sockaddr_in sockaddr;
	pthread_t workers[NUM_WORKERS];
	size_t i;

	if (lists_load("schachts.list", 0)) {
		eprintf("fatal error: couldn't load the lists\n");
		goto error_lists;
	}

	server_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (server_sockfd == -1) {
		perror("socket");
		error = 1;
		goto error_socket;
	}

	sockaddr.sin_family = AF_INET;
	sockaddr.sin_addr.s_addr = INADDR_ANY;
	sockaddr.sin_port = htons(1337);

	if (bind(server_sockfd, (void*)&sockaddr, sizeof(sockaddr)) == -1) {
		perror("bind");
		error = 1;
		goto error_bind;
	}

	for (i = 0; i < NUM_WORKERS; i++)
		pthread_create(workers + i, NULL, worker_main, NULL);

	while (1) {
		char buffer[256];
		struct sockaddr_in addr;
		socklen_t addrlen = sizeof(addr);
		ssize_t size;
		uint32_t query;
		job_t *job;

		size = recvfrom(server_sockfd, buffer, sizeof(buffer), 0,
		                (void*)&addr, &addrlen);
		if (size == -1) {
			perror("recvfrom");
			goto error_recvfrom;
		}

		if ((ntohl(addr.sin_addr.s_addr) & LOCALHOST_MASK)
		    != LOCALHOST_NETWORK)
			continue;

		if (size < REQUEST_HEADER_LEN)
			continue;

		if (memcmp(buffer, REQUEST_HEADER, REQUEST_HEADER_LEN))
			continue;

		if (parse_req_addr(buffer + REQUEST_HEADER_LEN, buffer + size,
		                   &query))
			continue;

		job = job_create();
		job->type = JOB_TEST;
		job->query = query;
		memcpy(&job->reply_to, &addr, sizeof(addr));
		job_enqueue(job);
	}

	job_quit();

	for (i = 0; i < NUM_WORKERS; i++)
		pthread_join(workers[i], NULL);

	cache_destroy();
	// todo: clear all jobs

error_recvfrom:
error_bind:
	shutdown(server_sockfd, SHUT_RDWR);
	close(server_sockfd);
error_socket:
	lists_destroy();
error_lists:
	return error;
}