tcprpf-server.c - net/tcprpf - Rivoreo Source Code Repositories

 /*
  * Copyright 2015-2017 Rivoreo
  *
  * 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 2 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.
  */

 #include "common.h"
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/wait.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <unistd.h>
 #include "syncrw.h"
 #include <signal.h>
 #include <string.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>

 #define SELECT_TIMEOUT 60

 extern int forward(int, int);

 //static int alrm = 0;

 static void signal_handler(int sig) {
 	switch(sig) {
 		case SIGCHLD:
 			//while(wait(NULL) < 0) {
 			while(waitpid(-1, NULL, WNOHANG) < 0) {
 				if(errno == EINTR) continue;
 				perror("waitpid");
 				return;
 			}
 			return;
 		//case SIGALRM:
 		//	alrm = 1;
 		//	return;
 	}
 }

 static int fill_address_and_port_number(char *s, struct sockaddr_in *addr) {
 	int port;
 	char *col = strchr(s, ':');
 	if(col) {
 		*col = 0;
 		if(inet_pton(AF_INET, s, &addr->sin_addr) < 1) {
 			fprintf(stderr, "Invalid address '%s'\n", s);
 			return -1;
 		}
 		port = atoi(col + 1);
 	} else {
 		addr->sin_addr.s_addr = htonl(INADDR_ANY);
 		port = atoi(s);
 	}
 	if(port < 1) {
 		fprintf(stderr, "Port number must be greater than 0, got %d\n", port);
 		return -1;
 	}
 	addr->sin_port = htons(port);
 	return 0;
 }

 static void print_usage(const char *name) {
 	fprintf(stderr, "Usage: %s -d [<bind-address>:]<data-listen-port> -f [<bind-address>:]<forward-listen-port>\n"
 		"	[-f [<bind-address>:]<forward-listen-port>] [...]\n"
 		"Usage: %s [<bind-address>:]<forward-listen-port> [<bind-address>:]<data-listen-port>\n",
 		name, name);
 }

 int main(int argc, char **argv) {
 	const char *name = strrchr(argv[0], '/');
 	if(name) name++; else name = argv[0];

 	struct sockaddr_in data_listen_addr = {
 		.sin_family = AF_INET,
 		.sin_addr.s_addr = htonl(INADDR_ANY),
 		.sin_port = 0
 	};
 	struct sockaddr_in *forward_listen_addr_list = NULL;
 	size_t forward_listen_count = 0, forward_listen_allocated_size = 0;

 	if(argc == 3 && argv[1][0] != '-' && argv[2][0] != '-') {
 		forward_listen_addr_list = malloc(sizeof(struct sockaddr_in));
 		if(!forward_listen_addr_list) {
 			perror("malloc");
 			return 1;
 		}
 		forward_listen_count = 1;
 		memset(forward_listen_addr_list, 0, sizeof(struct sockaddr_in));
 		forward_listen_addr_list->sin_family = AF_INET;
 		if(fill_address_and_port_number(argv[1], forward_listen_addr_list) < 0) return -1;
 		if(fill_address_and_port_number(argv[2], &data_listen_addr) < 0) return -1;
 	} else while(1) {
 		int c = getopt(argc, argv, "d:f:");
 		if(c == -1) break;
 		switch(c) {
 			case 'd':
 				if(data_listen_addr.sin_port) {
 					fprintf(stderr, "%s: only one data port can be specified\n", argv[0]);
 					return -1;
 				}
 				if(fill_address_and_port_number(optarg, &data_listen_addr) < 0) return 1;
 				break;
 			case 'f':
 				if(forward_listen_count * sizeof(struct sockaddr_in) >= forward_listen_allocated_size) {
 					forward_listen_addr_list = realloc(forward_listen_addr_list, forward_listen_allocated_size += 2 * sizeof(struct sockaddr_in));
 					if(!forward_listen_addr_list) {
 						perror("realloc");
 						return 1;
 					}
 				}
 				if(fill_address_and_port_number(optarg, forward_listen_addr_list + forward_listen_count) < 0) {
 					return -1;
 				}
 				forward_listen_count++;
 				break;
 			case 'h':
 				print_usage(name);
 				return 0;
 			case '?':
 				return -1;
 		}
 	}

 	if(!data_listen_addr.sin_port || !forward_listen_count) {
 		print_usage(name);
 		return -1;
 	}
 	if(optind > 1 && argc > optind) {
 		fprintf(stderr, "%s: Extra '%s' in command line\n", name, argv[optind]);
 		return -1;
 	}

 	struct sigaction act = { .sa_handler = SIG_IGN };
 	if(sigaction(SIGPIPE, &act, NULL) < 0) {
 		perror("sigaction");
 		return 1;
 	}
 	act.sa_handler = signal_handler;
 	sigaction(SIGCHLD, &act, NULL);
 	//sigaction(SIGALRM, &act, NULL);

 	fprintf(stderr, "\nTCP Reverse Port Forwarding Server - %s\n"
 		RIVOREO_COPYRIGHT_NOTICE "\n"
 		LICENSE_INFORMATION "\n\n", name);

 	int forward_sockets[forward_listen_count];
 	int data_socket = socket(AF_INET, SOCK_STREAM, 0);
 	if(data_socket == -1) {
 		perror("socket");
 		return 1;
 	}
 	static const int reuseaddr = 1;
 	if(setsockopt(data_socket, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof reuseaddr) < 0) perror("setsockopt");

 	static const struct timeval sendtimeout = { .tv_sec = 20 };
 	if(setsockopt(data_socket, SOL_SOCKET, SO_SNDTIMEO, &sendtimeout, sizeof sendtimeout) < 0) perror("setsockopt");

 	while(bind(data_socket, (struct sockaddr *)&data_listen_addr, sizeof data_listen_addr) < 0) {
 		if(errno == EAGAIN || errno == EINTR) continue;
 		perror("bind: data");
 		return 1;
 	}

 	if(listen(data_socket, 1) < 0) {
 		perror("listen: data");
 		return 1;
 	}

 	int i = 0;
 	do {
 		int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 		if(fd == -1) {
 			perror("socket");
 			return 1;
 		}
 		if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof reuseaddr) < 0) perror("setsockopt");
 		const struct sockaddr_in *addr = forward_listen_addr_list + i;
 		while(bind(fd, (const struct sockaddr *)addr, sizeof(struct sockaddr_in)) < 0) {
 			if(errno == EAGAIN || errno == EINTR) continue;
 			//perror("bind: forward");
 			fprintf(stderr, "%s: bind: %s:%hu: %s\n", name, inet_ntoa(addr->sin_addr),
 				ntohs(addr->sin_port), strerror(errno));
 			return 1;
 		}
 		if(listen(fd, 256) < 0) {
 			perror("listen: forward");
 			return 1;
 		}
 		forward_sockets[i] = fd;
 	} while(++i < forward_listen_count);

 	fd_set fdset;
 	struct timeval delay_tv;

 	while(1) {
 		struct sockaddr_in data_client_addr;
 		socklen_t data_addr_len = sizeof data_client_addr;
 		int data_c_fd;
 		do {
 			data_c_fd = accept(data_socket, (struct sockaddr *)&data_client_addr, &data_addr_len);
 		} while(data_c_fd == -1 && errno == EINTR);
 		if(data_c_fd == -1) {
 			perror("accept: data");
 			sleep(1);
 			continue;
 		}
 		fprintf(stderr, "connection to data port %hu from %s port %hu fd %d\n",
 			ntohs(data_listen_addr.sin_port), inet_ntoa(data_client_addr.sin_addr),
 			ntohs(data_client_addr.sin_port), data_c_fd);

 		static const struct timeval receivetimeout = { .tv_sec = 20 };
 		if(setsockopt(data_c_fd, SOL_SOCKET, SO_RCVTIMEO, &receivetimeout, sizeof receivetimeout) < 0) perror("setsockopt");

 		int max_fd = data_c_fd;
 		FD_ZERO(&fdset);
 		FD_SET(data_c_fd, &fdset);
 		for(i=0; i<forward_listen_count; i++) {
 			FD_SET(forward_sockets[i], &fdset);
 			if(forward_sockets[i] > max_fd) max_fd = forward_sockets[i];
 		}
 		int keep_alive_sent = 0;

 		while(1) {
 			fd_set rfdset = fdset;
 			delay_tv.tv_sec = SELECT_TIMEOUT;
 			delay_tv.tv_usec = 0;
 			int n = select(max_fd + 1, &rfdset, NULL, NULL, &delay_tv);
 			if(n < 0) {
 				if(errno == EINTR) continue;
 				perror("select");
 				sleep(1);
 				continue;
 			}
 			if(n) {
 				for(i=0; i<forward_listen_count; i++) {
 					int forward_socket = forward_sockets[i];
 					if(!FD_ISSET(forward_socket, &rfdset)) continue;
 					struct sockaddr_in forward_client_addr;
 					socklen_t forward_addr_len = sizeof forward_client_addr;
 					int forward_c_fd;
 					do {
 						forward_c_fd = accept(forward_socket, (struct sockaddr *)&forward_client_addr, &forward_addr_len);
 					} while(forward_c_fd == -1 && errno == EINTR);
 					if(forward_c_fd == -1) {
 						perror("accept: forward");
 						sleep(1);
 						continue;
 					}
 					char to_addr_s[16], from_addr_s[16];
 					const struct in_addr *to_addr = &forward_listen_addr_list[i].sin_addr;
 					fprintf(stderr, "connection to forward listen address %s port %hu from %s port %hu fd %d\n",
 						inet_ntop(AF_INET, to_addr, to_addr_s, sizeof to_addr_s),
 						ntohs(forward_listen_addr_list[i].sin_port),
 						inet_ntop(AF_INET, &forward_client_addr.sin_addr, from_addr_s, sizeof from_addr_s),
 						ntohs(forward_client_addr.sin_port), data_c_fd);
 					uint16_t packet_type = htons(NEW_CONNECTION);
 					struct new_connection_packet packet;
 					packet.len = htonl(sizeof packet);
 					packet.address = forward_client_addr.sin_addr;
 					packet.port = forward_client_addr.sin_port;
 					if(sync_write(data_c_fd, MAGIC, 4) < 0 || sync_write(data_c_fd, &packet_type, sizeof packet_type) < 0 || sync_write(data_c_fd, &packet, sizeof packet) < 0) {
 						perror("write: data");
 						goto close_old_and_reaccept_data_connection;
 					}

 					pid_t pid = fork();
 					if(pid < 0) {
 						perror("fork");
 						close(forward_c_fd);
 						continue;
 					}
 					if(pid) {
 						//close(data_c_fd);	// Will be closed after goto
 						close(forward_c_fd);
 						goto close_old_and_reaccept_data_connection;
 					} else {
 						close(data_socket);
 						close(forward_socket);
 						exit(forward(data_c_fd, forward_c_fd) < 0 ? 1 : 0);
 					}
 				}
 				if(FD_ISSET(data_c_fd, &rfdset)) {
 					char magic[sizeof MAGIC - 1];
 					int s;
 					do {
 						s = read(data_c_fd, magic, sizeof magic);
 					} while(s < 0 && errno == EINTR);
 					if(s < (int)sizeof magic) {
 						if(s < 0) perror("read: data");
 						else if(s) fprintf(stderr, "%s: closing connection due to incomplete packet (received %d byte(s))\n", name, s);
 						break;
 					}
 					if(memcmp(magic, MAGIC, sizeof magic)) {
 						fprintf(stderr, "%s: Protocol mismatch\n", name);
 						break;
 					}
 					uint16_t packet_type;
 					//alarm(10);
 					//alrm = 0;
 					do {
 						s = read(data_c_fd, &packet_type, sizeof packet_type);
 					} while(s < 0 && errno == EINTR/* && !alrm*/);
 					//alarm(0);
 					if(s < (int)sizeof packet_type) {
 						if(s < 0) perror("read: data");
 						else if(s) fprintf(stderr, "%s: closing connection due to incomplete packet (received %d byte)\n", name, s);
 						break;
 					}
 					packet_type = ntohs(packet_type);
 					if(packet_type == KEEP_ALIVE) {
 						fprintf(stderr, "%s: keep alive from client\n", name);
 						packet_type = htons(KEEP_ALIVE_REPLY);
 						if(sync_write(data_c_fd, MAGIC, 4) < 0 ||
 						sync_write(data_c_fd, &packet_type, sizeof packet_type) < 0) {
 							perror("write: data");
 							break;
 						}
 					} else if(packet_type == KEEP_ALIVE_REPLY) {
 						if(!keep_alive_sent) {
 							fprintf(stderr, "%s: Unexpected keep alive reply from client, disconnecting\n", name);
 							break;
 						}
 						keep_alive_sent--;
 					} else {
 						fprintf(stderr, "%s: Unknown packet type %hu received from client\n", name, packet_type);
 						break;
 					}
 				}
 			} else {
 				if(keep_alive_sent) {
 					fprintf(stderr, "%s: Client dosen't reply the recent keep alive message in %u sec\n",
 						name, (unsigned int)SELECT_TIMEOUT);
 					break;
 				}
 				uint16_t packet_type = htons(KEEP_ALIVE);
 				if(sync_write(data_c_fd, MAGIC, 4) < 0 || sync_write(data_c_fd, &packet_type, sizeof packet_type) < 0) {
 					perror("write: data");
 					break;
 				}
 				keep_alive_sent++;
 			}
 		}
 close_old_and_reaccept_data_connection:
 		close(data_c_fd);
 	}
 }
	/*
	* Copyright 2015-2017 Rivoreo
	*
	* 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 2 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.
	*/

	#include "common.h"
	#include <sys/types.h>
	#include <sys/time.h>
	#include <sys/wait.h>
	#include <sys/socket.h>
	#include <netinet/in.h>
	#include <arpa/inet.h>
	#include <unistd.h>
	#include "syncrw.h"
	#include <signal.h>
	#include <string.h>
	#include <stdint.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <errno.h>

	#define SELECT_TIMEOUT 60

	extern int forward(int, int);

	//static int alrm = 0;

	static void signal_handler(int sig) {
	switch(sig) {
	case SIGCHLD:
	//while(wait(NULL) < 0) {
	while(waitpid(-1, NULL, WNOHANG) < 0) {
	if(errno == EINTR) continue;
	perror("waitpid");
	return;
	}
	return;
	//case SIGALRM:
	// alrm = 1;
	// return;
	}
	}

	static int fill_address_and_port_number(char s, struct sockaddr_in addr) {
	int port;
	char *col = strchr(s, ':');
	if(col) {
	*col = 0;
	if(inet_pton(AF_INET, s, &addr->sin_addr) < 1) {
	fprintf(stderr, "Invalid address '%s'\n", s);
	return -1;
	}
	port = atoi(col + 1);
	} else {
	addr->sin_addr.s_addr = htonl(INADDR_ANY);
	port = atoi(s);
	}
	if(port < 1) {
	fprintf(stderr, "Port number must be greater than 0, got %d\n", port);
	return -1;
	}
	addr->sin_port = htons(port);
	return 0;
	}

	static void print_usage(const char *name) {
	fprintf(stderr, "Usage: %s -d [<bind-address>:]<data-listen-port> -f [<bind-address>:]<forward-listen-port>\n"
	" [-f [<bind-address>:]<forward-listen-port>] [...]\n"
	"Usage: %s [<bind-address>:]<forward-listen-port> [<bind-address>:]<data-listen-port>\n",
	name, name);
	}

	int main(int argc, char **argv) {
	const char *name = strrchr(argv[0], '/');
	if(name) name++; else name = argv[0];

	struct sockaddr_in data_listen_addr = {
	.sin_family = AF_INET,
	.sin_addr.s_addr = htonl(INADDR_ANY),
	.sin_port = 0
	};
	struct sockaddr_in *forward_listen_addr_list = NULL;
	size_t forward_listen_count = 0, forward_listen_allocated_size = 0;

	if(argc == 3 && argv[1][0] != '-' && argv[2][0] != '-') {
	forward_listen_addr_list = malloc(sizeof(struct sockaddr_in));
	if(!forward_listen_addr_list) {
	perror("malloc");
	return 1;
	}
	forward_listen_count = 1;
	memset(forward_listen_addr_list, 0, sizeof(struct sockaddr_in));
	forward_listen_addr_list->sin_family = AF_INET;
	if(fill_address_and_port_number(argv[1], forward_listen_addr_list) < 0) return -1;
	if(fill_address_and_port_number(argv[2], &data_listen_addr) < 0) return -1;
	} else while(1) {
	int c = getopt(argc, argv, "d:f:");
	if(c == -1) break;
	switch(c) {
	case 'd':
	if(data_listen_addr.sin_port) {
	fprintf(stderr, "%s: only one data port can be specified\n", argv[0]);
	return -1;
	}
	if(fill_address_and_port_number(optarg, &data_listen_addr) < 0) return 1;
	break;
	case 'f':
	if(forward_listen_count * sizeof(struct sockaddr_in) >= forward_listen_allocated_size) {
	forward_listen_addr_list = realloc(forward_listen_addr_list, forward_listen_allocated_size += 2 * sizeof(struct sockaddr_in));
	if(!forward_listen_addr_list) {
	perror("realloc");
	return 1;
	}
	}
	if(fill_address_and_port_number(optarg, forward_listen_addr_list + forward_listen_count) < 0) {
	return -1;
	}
	forward_listen_count++;
	break;
	case 'h':
	print_usage(name);
	return 0;
	case '?':
	return -1;
	}
	}

	if(!data_listen_addr.sin_port \|\| !forward_listen_count) {
	print_usage(name);
	return -1;
	}
	if(optind > 1 && argc > optind) {
	fprintf(stderr, "%s: Extra '%s' in command line\n", name, argv[optind]);
	return -1;
	}

	struct sigaction act = { .sa_handler = SIG_IGN };
	if(sigaction(SIGPIPE, &act, NULL) < 0) {
	perror("sigaction");
	return 1;
	}
	act.sa_handler = signal_handler;
	sigaction(SIGCHLD, &act, NULL);
	//sigaction(SIGALRM, &act, NULL);

	fprintf(stderr, "\nTCP Reverse Port Forwarding Server - %s\n"
	RIVOREO_COPYRIGHT_NOTICE "\n"
	LICENSE_INFORMATION "\n\n", name);

	int forward_sockets[forward_listen_count];
	int data_socket = socket(AF_INET, SOCK_STREAM, 0);
	if(data_socket == -1) {
	perror("socket");
	return 1;
	}
	static const int reuseaddr = 1;
	if(setsockopt(data_socket, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof reuseaddr) < 0) perror("setsockopt");

	static const struct timeval sendtimeout = { .tv_sec = 20 };
	if(setsockopt(data_socket, SOL_SOCKET, SO_SNDTIMEO, &sendtimeout, sizeof sendtimeout) < 0) perror("setsockopt");

	while(bind(data_socket, (struct sockaddr *)&data_listen_addr, sizeof data_listen_addr) < 0) {
	if(errno == EAGAIN \|\| errno == EINTR) continue;
	perror("bind: data");
	return 1;
	}

	if(listen(data_socket, 1) < 0) {
	perror("listen: data");
	return 1;
	}

	int i = 0;
	do {
	int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if(fd == -1) {
	perror("socket");
	return 1;
	}
	if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof reuseaddr) < 0) perror("setsockopt");
	const struct sockaddr_in *addr = forward_listen_addr_list + i;
	while(bind(fd, (const struct sockaddr *)addr, sizeof(struct sockaddr_in)) < 0) {
	if(errno == EAGAIN \|\| errno == EINTR) continue;
	//perror("bind: forward");
	fprintf(stderr, "%s: bind: %s:%hu: %s\n", name, inet_ntoa(addr->sin_addr),
	ntohs(addr->sin_port), strerror(errno));
	return 1;
	}
	if(listen(fd, 256) < 0) {
	perror("listen: forward");
	return 1;
	}
	forward_sockets[i] = fd;
	} while(++i < forward_listen_count);

	fd_set fdset;
	struct timeval delay_tv;

	while(1) {
	struct sockaddr_in data_client_addr;
	socklen_t data_addr_len = sizeof data_client_addr;
	int data_c_fd;
	do {
	data_c_fd = accept(data_socket, (struct sockaddr *)&data_client_addr, &data_addr_len);
	} while(data_c_fd == -1 && errno == EINTR);
	if(data_c_fd == -1) {
	perror("accept: data");
	sleep(1);
	continue;
	}
	fprintf(stderr, "connection to data port %hu from %s port %hu fd %d\n",
	ntohs(data_listen_addr.sin_port), inet_ntoa(data_client_addr.sin_addr),
	ntohs(data_client_addr.sin_port), data_c_fd);

	static const struct timeval receivetimeout = { .tv_sec = 20 };
	if(setsockopt(data_c_fd, SOL_SOCKET, SO_RCVTIMEO, &receivetimeout, sizeof receivetimeout) < 0) perror("setsockopt");

	int max_fd = data_c_fd;
	FD_ZERO(&fdset);
	FD_SET(data_c_fd, &fdset);
	for(i=0; i<forward_listen_count; i++) {
	FD_SET(forward_sockets[i], &fdset);
	if(forward_sockets[i] > max_fd) max_fd = forward_sockets[i];
	}
	int keep_alive_sent = 0;

	while(1) {
	fd_set rfdset = fdset;
	delay_tv.tv_sec = SELECT_TIMEOUT;
	delay_tv.tv_usec = 0;
	int n = select(max_fd + 1, &rfdset, NULL, NULL, &delay_tv);
	if(n < 0) {
	if(errno == EINTR) continue;
	perror("select");
	sleep(1);
	continue;
	}
	if(n) {
	for(i=0; i<forward_listen_count; i++) {
	int forward_socket = forward_sockets[i];
	if(!FD_ISSET(forward_socket, &rfdset)) continue;
	struct sockaddr_in forward_client_addr;
	socklen_t forward_addr_len = sizeof forward_client_addr;
	int forward_c_fd;
	do {
	forward_c_fd = accept(forward_socket, (struct sockaddr *)&forward_client_addr, &forward_addr_len);
	} while(forward_c_fd == -1 && errno == EINTR);
	if(forward_c_fd == -1) {
	perror("accept: forward");
	sleep(1);
	continue;
	}
	char to_addr_s[16], from_addr_s[16];
	const struct in_addr *to_addr = &forward_listen_addr_list[i].sin_addr;
	fprintf(stderr, "connection to forward listen address %s port %hu from %s port %hu fd %d\n",
	inet_ntop(AF_INET, to_addr, to_addr_s, sizeof to_addr_s),
	ntohs(forward_listen_addr_list[i].sin_port),
	inet_ntop(AF_INET, &forward_client_addr.sin_addr, from_addr_s, sizeof from_addr_s),
	ntohs(forward_client_addr.sin_port), data_c_fd);
	uint16_t packet_type = htons(NEW_CONNECTION);
	struct new_connection_packet packet;
	packet.len = htonl(sizeof packet);
	packet.address = forward_client_addr.sin_addr;
	packet.port = forward_client_addr.sin_port;
	if(sync_write(data_c_fd, MAGIC, 4) < 0 \|\| sync_write(data_c_fd, &packet_type, sizeof packet_type) < 0 \|\| sync_write(data_c_fd, &packet, sizeof packet) < 0) {
	perror("write: data");
	goto close_old_and_reaccept_data_connection;
	}

	pid_t pid = fork();
	if(pid < 0) {
	perror("fork");
	close(forward_c_fd);
	continue;
	}
	if(pid) {
	//close(data_c_fd); // Will be closed after goto
	close(forward_c_fd);
	goto close_old_and_reaccept_data_connection;
	} else {
	close(data_socket);
	close(forward_socket);
	exit(forward(data_c_fd, forward_c_fd) < 0 ? 1 : 0);
	}
	}
	if(FD_ISSET(data_c_fd, &rfdset)) {
	char magic[sizeof MAGIC - 1];
	int s;
	do {
	s = read(data_c_fd, magic, sizeof magic);
	} while(s < 0 && errno == EINTR);
	if(s < (int)sizeof magic) {
	if(s < 0) perror("read: data");
	else if(s) fprintf(stderr, "%s: closing connection due to incomplete packet (received %d byte(s))\n", name, s);
	break;
	}
	if(memcmp(magic, MAGIC, sizeof magic)) {
	fprintf(stderr, "%s: Protocol mismatch\n", name);
	break;
	}
	uint16_t packet_type;
	//alarm(10);
	//alrm = 0;
	do {
	s = read(data_c_fd, &packet_type, sizeof packet_type);
	} while(s < 0 && errno == EINTR/* && !alrm*/);
	//alarm(0);
	if(s < (int)sizeof packet_type) {
	if(s < 0) perror("read: data");
	else if(s) fprintf(stderr, "%s: closing connection due to incomplete packet (received %d byte)\n", name, s);
	break;
	}
	packet_type = ntohs(packet_type);
	if(packet_type == KEEP_ALIVE) {
	fprintf(stderr, "%s: keep alive from client\n", name);
	packet_type = htons(KEEP_ALIVE_REPLY);
	if(sync_write(data_c_fd, MAGIC, 4) < 0 \|\|
	sync_write(data_c_fd, &packet_type, sizeof packet_type) < 0) {
	perror("write: data");
	break;
	}
	} else if(packet_type == KEEP_ALIVE_REPLY) {
	if(!keep_alive_sent) {
	fprintf(stderr, "%s: Unexpected keep alive reply from client, disconnecting\n", name);
	break;
	}
	keep_alive_sent--;
	} else {
	fprintf(stderr, "%s: Unknown packet type %hu received from client\n", name, packet_type);
	break;
	}
	}
	} else {
	if(keep_alive_sent) {
	fprintf(stderr, "%s: Client dosen't reply the recent keep alive message in %u sec\n",
	name, (unsigned int)SELECT_TIMEOUT);
	break;
	}
	uint16_t packet_type = htons(KEEP_ALIVE);
	if(sync_write(data_c_fd, MAGIC, 4) < 0 \|\| sync_write(data_c_fd, &packet_type, sizeof packet_type) < 0) {
	perror("write: data");
	break;
	}
	keep_alive_sent++;
	}
	}
	close_old_and_reaccept_data_connection:
	close(data_c_fd);
	}
	}