/*
Russian Port Convertor
Nickolay N. Parfenov <nik@eastsoft.saratov.su>

Example inetd.conf entries:
smtpwin stream tcp nowait nouser /usr/local/etc/port_conv \
  port_koi2win localhost smtp
popwin stream tcp nowait nouser /usr/local/etc/port_conv \
  port_koi2win localhost pop
nntpwin stream tcp nowait nouser /usr/local/etc/port_conv \
  port_koi2win -t0 localhost nntp

Usage:
port_conv [-l logfile] [-p logfile] [-r] [-t timeout] \
	host port|service [protocol]
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/times.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <fcntl.h>
#include <ctype.h>
#include <unistd.h>
#include <errno.h>

#define BUFLEN 1024
#define DEFTIMEOUT 60
#define MAXPATHLEN 1024
#define USAGE "Usage: port_conv [-l logfile] [-p logfile] [-r] [-t timeout] host port|service [protocol]"


extern char	*optarg;
extern int	optind, opterr;

extern int	errno, sys_nerr;
#ifdef __FreeBSD__
extern __const char *__const sys_errlist[];
#else
extern char	*sys_errlist[];
#endif
extern int	h_errno;

unsigned char alt2koi[] = {
	0xe1, 0xe2, 0xf7, 0xe7, 0xe4, 0xe5, 0xf6, 0xfa,
	0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0,
	0xf2, 0xf3, 0xf4, 0xf5, 0xe6, 0xe8, 0xe3, 0xfe,
	0xfb, 0xfd, 0xff, 0xf9, 0xf8, 0xfc, 0xe0, 0xf1,
	0xc1, 0xc2, 0xd7, 0xc7, 0xc4, 0xc5, 0xd6, 0xda,
	0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0,
	0x90, 0x91, 0x92, 0x81, 0x87, 0xb2, 0xb4, 0xa7,
	0xa6, 0xb5, 0xa1, 0xa8, 0xae, 0xad, 0xac, 0x83,
	0x84, 0x89, 0x88, 0x86, 0x80, 0x8a, 0xaf, 0xb0,
	0xab, 0xa5, 0xbb, 0xb8, 0xb1, 0xa0, 0xbe, 0xb9,
	0xba, 0xb6, 0xb7, 0xaa, 0xa9, 0xa2, 0xa4, 0xbd,
	0xbc, 0x85, 0x82, 0x8d, 0x8c, 0x8e, 0x8f, 0x8b,
	0xd2, 0xd3, 0xd4, 0xd5, 0xc6, 0xc8, 0xc3, 0xde,
	0xdb, 0xdd, 0xdf, 0xd9, 0xd8, 0xdc, 0xc0, 0xd1,
	0xb3, 0xa3, 0x99, 0x98, 0x93, 0x9b, 0x9f, 0x97,
	0x9c, 0x95, 0x9e, 0x96, 0xbf, 0x9d, 0x94, 0x9a
};
unsigned char koi2alt[] = {
	0xc4, 0xb3, 0xda, 0xbf, 0xc0, 0xd9, 0xc3, 0xb4,
	0xc2, 0xc1, 0xc5, 0xdf, 0xdc, 0xdb, 0xdd, 0xde,
	0xb0, 0xb1, 0xb2, 0xf4, 0xfe, 0xf9, 0xfb, 0xf7,
	0xf3, 0xf2, 0xff, 0xf5, 0xf8, 0xfd, 0xfa, 0xf6,
	0xcd, 0xba, 0xd5, 0xf1, 0xd6, 0xc9, 0xb8, 0xb7,
	0xbb, 0xd4, 0xd3, 0xc8, 0xbe, 0xbd, 0xbc, 0xc6,
	0xc7, 0xcc, 0xb5, 0xf0, 0xb6, 0xb9, 0xd1, 0xd2,
	0xcb, 0xcf, 0xd0, 0xca, 0xd8, 0xd7, 0xce, 0xfc,
	0xee, 0xa0, 0xa1, 0xe6, 0xa4, 0xa5, 0xe4, 0xa3,
	0xe5, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae,
	0xaf, 0xef, 0xe0, 0xe1, 0xe2, 0xe3, 0xa6, 0xa2,
	0xec, 0xeb, 0xa7, 0xe8, 0xed, 0xe9, 0xe7, 0xea,
	0x9e, 0x80, 0x81, 0x96, 0x84, 0x85, 0x94, 0x83,
	0x95, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e,
	0x8f, 0x9f, 0x90, 0x91, 0x92, 0x93, 0x86, 0x82,
	0x9c, 0x9b, 0x87, 0x98, 0x9d, 0x99, 0x97, 0x9a
};
unsigned char alt2win[] = {
	0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
	0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
	0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
	0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
	0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
	0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
	0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
	0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
	0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
	0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
	0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
	0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf
};
unsigned char win2alt[] = {
	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
	0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
	0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
	0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
	0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
	0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
	0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
	0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
	0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
	0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
	0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
	0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
	0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef
};
unsigned char alt2iso[] = {
	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
	0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
	0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
	0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
	0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
	0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
	0x9b, 0x9c, 0x9d, 0xa5, 0xa7, 0x83, 0x84, 0x85,
	0x86, 0x97, 0x95, 0x91, 0x92, 0x8b, 0x8c, 0xa1,
	0xa3, 0xa8, 0xa6, 0xa9, 0xa4, 0xaa, 0x8d, 0x8e,
	0x93, 0x90, 0x98, 0x96, 0x99, 0x94, 0x9a, 0x80,
	0x81, 0x82, 0x87, 0x88, 0x89, 0x8a, 0x8f, 0x9e,
	0x9f, 0xa2, 0xa0, 0xab, 0xac, 0xad, 0xae, 0xaf,
	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
	0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};
unsigned char iso2alt[] = {
	0xcf, 0xd0, 0xd1, 0xb5, 0xb6, 0xb7, 0xb8, 0xd2,
	0xd3, 0xd4, 0xd5, 0xbd, 0xbe, 0xc6, 0xc7, 0xd6,
	0xc9, 0xbb, 0xbc, 0xc8, 0xcd, 0xba, 0xcb, 0xb9,
	0xca, 0xcc, 0xce, 0xb0, 0xb1, 0xb2, 0xd7, 0xd8,
	0xda, 0xbf, 0xd9, 0xc0, 0xc4, 0xb3, 0xc2, 0xb4,
	0xc1, 0xc3, 0xc5, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
	0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
	0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
	0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
	0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
	0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
	0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
	0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};
unsigned char tabrecv[] = {
	0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
	0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
	0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
	0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
	0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
	0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
	0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
	0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
	0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
	0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
	0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
	0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};
unsigned char tabsend[] = {
	0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
	0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
	0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
	0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
	0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
	0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
	0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
	0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
	0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
	0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
	0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
	0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};

char	*argv0;


void err(int, char*, char*);
char *basename(char*);
void maketab(unsigned char*, unsigned char*);
int sockcon(char*, char*, char*, int);


void err(int ret, char *str1, char *str2)
{
	fprintf(stderr, "%s: ", argv0);
	if(str2)
		fprintf(stderr, str1, str2);
	else
		fprintf(stderr, str1);
	if(errno > 0 && errno < sys_nerr)
		fprintf(stderr, " (%s)", sys_errlist[errno]);
	fprintf(stderr, "\n");
	exit(ret);
}


char *basename(char *path)
{
char	*basename;

	if((basename = strrchr(path, (int) '/')) == NULL)
		return(path);
	else
		return(basename + 1);
}


void maketab(unsigned char *tabconvr, unsigned char *tabconvs)
{
int	ch;

	for(ch = 0; ch < 128; ch++) {
		tabrecv[ch] = tabconvr[tabrecv[ch] & 0x7f];
		tabsend[ch] = tabconvs[tabsend[ch] & 0x7f];
	}
}


int sockcon(char *host_name, char *serv_name, char *proto_name, int fl_resv)
{
int			fd;
struct sockaddr_in	sin;
struct hostent		*phe;
struct servent		*pse;
struct protoent		*ppe;
int			sock_type;

	bzero((char *) &sin, sizeof(sin));
	sin.sin_family = AF_INET;

	if(phe = gethostbyname(host_name))
/*		sin.sin_addr = *((struct in_addr *) phe->h_addr); */
		bcopy(phe->h_addr, (char *) &sin.sin_addr, phe->h_length);
	else
		if((sin.sin_addr.s_addr = inet_addr(host_name)) == INADDR_NONE)
			err(3, "unknown host %s", host_name);

	if(proto_name && (ppe = getprotobyname(proto_name)) == NULL)
		err(3, "unknown protocol %s", proto_name);

	if(proto_name && strcmp(proto_name, "udp") == 0)
		sock_type = SOCK_DGRAM;
	else
		sock_type = SOCK_STREAM;

	if(pse = getservbyname(serv_name, proto_name))
		sin.sin_port = pse->s_port;
	else
		if((sin.sin_port = htons(atoi(serv_name))) == 0)
			err(3, "unknown service %s", serv_name);

	if(fl_resv == 1) {
		fd = IPPORT_RESERVED - 1;
		fd = rresvport(&fd);
	}
	else
		fd = socket(AF_INET, sock_type, 0);
	if(fd < 0) err(3, "can't create socket", NULL);

	if(connect(fd, (struct sockaddr *) &sin, sizeof(sin)) < 0)
		err(3, "host %s is not responding", host_name);
	return fd;
}


int main(int argc, char **argv)
{
int		fd, timeout = DEFTIMEOUT, bread, ld = -1, fl_resv = 0,
		fl_while = 1, sret, i;
fd_set		fdset;
struct timeval	tv, *ptv;
unsigned char	buf[BUFLEN];
char		*host_name, *serv_name, *proto_name = NULL,
		logname[MAXPATHLEN + 1],
		toclient[] = "\n--- To client: ---\n",
		toserver[] = "\n--- To server: ---\n",
		*tcpstr = "tcp", c, *bname;

	argv0 = argv[0];
	logname[0] = logname[MAXPATHLEN] = '\0';

	while((c = getopt(argc, argv, "hl:p:rt:")) != -1) {
		switch(c) {
		case 'l':
			strncpy(logname, optarg, MAXPATHLEN);
			break;
		case 'p':
			snprintf(logname, MAXPATHLEN, "%s-%ld", optarg, getpid());
			break;
		case 'r':
			fl_resv = 1;
			break;
		case 't':
			timeout = atoi(optarg);
			break;
		case 'h':
		default:
			err(0, USAGE, NULL);
		}
	}

	if((argc - optind) != 2 && (argc - optind) != 3) err(1, USAGE, NULL);

	if(logname[0] != '\0')
		if((ld = open(logname, O_WRONLY | O_APPEND | O_CREAT, 00600)) == -1)
			err(2, "can't open log %s", logname);

	host_name = argv[optind];
	serv_name = argv[optind + 1];
	if(fl_resv == 1)
		proto_name = tcpstr;
	else
		if((argc - optind) == 3)
			proto_name = argv[optind + 2];
		else
			proto_name = tcpstr;

	bname = basename(argv0);
	if(!strcmp(bname, "port_alt2koi")) {
		maketab(alt2koi, koi2alt);
	}
	else
	if(!strcmp(bname, "port_koi2alt")) {
		maketab(koi2alt, alt2koi);
	}
	else
	if(!strcmp(bname, "port_alt2win")) {
		maketab(alt2win, win2alt);
	}
	else
	if(!strcmp(bname, "port_win2alt")) {
		maketab(win2alt, alt2win);
	}
	else
	if(!strcmp(bname, "port_alt2iso")) {
		maketab(alt2iso, iso2alt);
	}
	else
	if(!strcmp(bname, "port_iso2alt")) {
		maketab(iso2alt, alt2iso);
	}
	else
	if(!strcmp(bname, "port_koi2win")) {
		maketab(koi2alt, win2alt);
		maketab(alt2win, alt2koi);
	}
	else
	if(!strcmp(bname, "port_win2koi")) {
		maketab(win2alt, koi2alt);
		maketab(alt2koi, alt2win);
	}
	else
	if(!strcmp(bname, "port_koi2iso")) {
		maketab(koi2alt, iso2alt);
		maketab(alt2iso, alt2koi);
	}
	else
	if(!strcmp(bname, "port_iso2koi")) {
		maketab(iso2alt, koi2alt);
		maketab(alt2koi, alt2iso);
	}
	else
	if(!strcmp(bname, "port_win2iso")) {
		maketab(win2alt, iso2alt);
		maketab(alt2iso, alt2win);
	}
	else
	if(!strcmp(bname, "port_iso2win")) {
		maketab(iso2alt, win2alt);
		maketab(alt2win, alt2iso);
	}

	if((fd = sockcon(host_name, serv_name, proto_name, fl_resv)) == -1)
		err(3, "can't connect", NULL);

	if(timeout > 0)
		ptv = &tv;
	else
		ptv = NULL;

	while(fl_while) {
		FD_ZERO(&fdset);
		FD_SET(0, &fdset);
		FD_SET(fd, &fdset);

		if(ptv) {
			tv.tv_sec = timeout;
			tv.tv_usec = 0;
		}

		sret = select(fd + 1, &fdset, NULL, NULL, ptv);
		if(sret < 0) {
			if(errno == EWOULDBLOCK) continue;
			if(errno == EAGAIN) continue;
			if(errno == EINTR) continue;
			err(4, "socket failure", NULL);
		}
		if(sret == 0) {
			close(fd);
			err(5, "timeout", NULL);
		}
		if(FD_ISSET(fd, &fdset)) {
			bread = read(fd, buf, BUFLEN);
			if(bread < 0) err(6, "read error", NULL);
			if(bread == 0) { fl_while = 0; break; }

			for(i = 0; i < bread; i++)
				if(buf[i] & 0x80)
					buf[i] = tabrecv[buf[i] & 0x7f];

			if(ld > 0) {
				write(ld, toclient, sizeof(toclient));
				write(ld, buf, bread);
			}

			if(write(0, buf, bread) <= 0) err(7, "write error", NULL);
		}
		if(FD_ISSET(0, &fdset)) {
			bread = read(0, buf, BUFLEN);
			if(bread < 0) err(8, "read error", NULL);
			if(bread == 0) { fl_while = 0; break; }

			for(i = 0; i < bread; i++)
				if(buf[i] & 0x80)
					buf[i] = tabsend[buf[i] & 0x7f];

			if(ld > 0) {
				write(ld, toserver, sizeof(toserver));
				write(ld, buf, bread);
			}

			if(write(fd, buf, bread) <= 0) err(9, "write error", NULL);
		}
	}

	close(fd);
	close(0);
	if(ld > 0) close(ld);
	return(0);
}