/*
** Copyright (c) 2009 Herbert Poetzl

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
Version 2 as published by the Free Software Foundation.

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.


** V0.01	initial prototype
**
*/

#include <sys/types.h>        
#include <sys/socket.h>        
#include <netdb.h>            
#include <string.h>            

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>


#define VERSION "V0.01"


#define MAXSOCK 10            


typedef long long int (stoll_t)(const char *, char **, int);

long long int argtoll(const char *str, stoll_t stoll)
{
	int bit, inv = 0, nbo = 0;
	long long int val = 0;
	char *eptr;

	if (!str)
	    return -1;
	if (!stoll)
	    stoll = strtoll;
	
	switch (*str) {
	case '~':
	case '!':
	    inv = 1;	/* invert */
	    str++;
	default:
	    break;
	}

	while (*str) {
	    switch (*str) {
	    case '^':
		bit = strtol(str+1, &eptr, 0);
		val ^= (1LL << bit);
		break;
	    case '&':
		val &= stoll(str+1, &eptr, 0);
		break;
	    case '|':
		val |= stoll(str+1, &eptr, 0);
		break;
	    case '.':
		val = (val << 8) | (strtol(str+1, &eptr, 0) & 0xff);
		nbo++;
		break;
	    default:
		val = stoll(str, &eptr, 0);
		break;
	    }
	    if (eptr == str)
	    	break;
	    str = eptr;
	}
	if (nbo>2)
	    val = htonl(val);
	else if (nbo>0)
	    val = htons(val);
	return (inv)?~(val):(val);
}

static char *ip6_addr_string(char *buf, char *end, u8 *addr,
                                struct printf_spec spec)
{
        char ip6_addr[8 * 5]; /* (8 * 4 hex digits), 7 colons and trailing zero */
        char *p = ip6_addr;
        int i;

        for (i = 0; i < 8; i++) {
                p = pack_hex_byte(p, addr[2 * i]);
                p = pack_hex_byte(p, addr[2 * i + 1]);
                if (!(spec.flags & SPECIAL) && i != 7)
                        *p++ = ':';
        }
        *p = '\0';
        spec.flags &= ~SPECIAL;

        return string(buf, end, ip6_addr, spec);
}

static char *ip4_addr_string(char *buf, char *end, u8 *addr,
                                struct printf_spec spec)
{
        char ip4_addr[4 * 4]; /* (4 * 3 decimal digits), 3 dots and trailing zero */
        char temp[3];   /* hold each IP quad in reverse order */
        char *p = ip4_addr;
        int i, digits;

        for (i = 0; i < 4; i++) {
                digits = put_dec_trunc(temp, addr[i]) - temp;
                /* reverse the digits in the quad */
                while (digits--)
                        *p++ = temp[digits];
                if (i != 3)
                        *p++ = '.';
        }
        *p = '\0';
        spec.flags &= ~SPECIAL;

        return string(buf, end, ip4_addr, spec);
}


#define NIPQUAD(addr) \
	((unsigned char *)&addr)[0], \
	((unsigned char *)&addr)[1], \
	((unsigned char *)&addr)[2], \
	((unsigned char *)&addr)[3]
#define NIPQUAD_FMT "%u.%u.%u.%u"

#define NIP6(addr) \
	ntohs((addr).s6_addr16[0]), \
	ntohs((addr).s6_addr16[1]), \
	ntohs((addr).s6_addr16[2]), \
	ntohs((addr).s6_addr16[3]), \
	ntohs((addr).s6_addr16[4]), \
	ntohs((addr).s6_addr16[5]), \
	ntohs((addr).s6_addr16[6]), \
	ntohs((addr).s6_addr16[7])
#define NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"


#define	ENTRY(x)	[x].str = #x

struct entry {
	char *str;
};

static struct entry ai_family[AF_MAX] = {
	ENTRY(AF_UNSPEC),
	ENTRY(AF_LOCAL),
	ENTRY(AF_UNIX),
	ENTRY(AF_FILE),
	ENTRY(AF_INET),
	ENTRY(AF_AX25),
	ENTRY(AF_IPX),
	ENTRY(AF_APPLETALK),
	ENTRY(AF_NETROM),
	ENTRY(AF_BRIDGE),
	ENTRY(AF_ATMPVC),
	ENTRY(AF_X25),
	ENTRY(AF_INET6),
	ENTRY(AF_ROSE),
	ENTRY(AF_DECnet),
	ENTRY(AF_NETBEUI),
	ENTRY(AF_SECURITY),
	ENTRY(AF_KEY),
	ENTRY(AF_NETLINK),
	ENTRY(AF_ROUTE),
	ENTRY(AF_PACKET),
	ENTRY(AF_ASH),
	ENTRY(AF_ECONET),
	ENTRY(AF_ATMSVC),
	ENTRY(AF_SNA),
	ENTRY(AF_IRDA),
	ENTRY(AF_PPPOX),
	ENTRY(AF_WANPIPE),
	ENTRY(AF_BLUETOOTH),
};

static struct entry ai_type[16] = {
	ENTRY(SOCK_STREAM),
	ENTRY(SOCK_DGRAM),
	ENTRY(SOCK_RAW),
	ENTRY(SOCK_RDM),
	ENTRY(SOCK_SEQPACKET),
	ENTRY(SOCK_PACKET),
};


char * ai_family_str(int family) {
	if ((family < 0) || (family >= AF_MAX))
		return NULL;
	return ai_family[family].str;
}

char * ai_type_str(int type) {
	if ((type < 0) || (type >= 16))
		return NULL;
	return ai_type[type].str;
}

char * ai_proto_str(int proto) {
	struct protoent *pe = getprotobynumber(proto);	
	return pe->p_name;
}


static	char	opt_ipv4only = 0;
static	char	opt_ipv6only = 0;
static	char	opt_listen = 0;
static	char	opt_reverse = 0;
static	char	opt_quiet = 0;
static	char	opt_abort = 0;

static	char *	cmd_name = NULL;
static	char *	exec_name = NULL;

static uint32_t	num_timeout = 0;

static	char *	addr = NULL;
static	char *	port = NULL;


#define OPTIONS "h146lrt:"

int	main(int argc, char *argv[])
{
	extern int optind;
	extern char *optarg;
	char c, errflg = 0;

	cmd_name = argv[0];
	while ((c = getopt(argc, argv, "+" OPTIONS)) != EOF) {
	    switch (c) {
	    case 'h':
		fprintf(stderr,
		    "This is %s " VERSION "\n"
		    "options are:\n"
		    "  -h        print this help message\n"
		    "  -1        abort on first error\n"
		    "  -4        ipv4 address only\n"
		    "  -6        ipv6 address only\n"
		    "  -l        create a listen socket\n"
		    "  -r        reverse socket order\n"
		    "  -t <sec>  timeout for socket\n"
		    "  --        end of options\n"
		    ,cmd_name);
		exit(0);
		break;
	    case '1':
		opt_abort = 1;
		break;
	    case '4':
		opt_ipv4only = 1;
		opt_ipv6only = 0;
		break;
	    case '6':
		opt_ipv4only = 0;
		opt_ipv6only = 1;
		break;
	    case 'l':
		opt_listen = 1;
		break;
	    case 'r':
		opt_reverse = 1;
		break;
	    case 't':
		num_timeout = atoi(optarg);
		break;
	    case '?':
	    default:
		errflg++;
		break;
	    }
	}
	if (errflg) {
	    fprintf(stderr, 
		"Usage: %s [-" OPTIONS "] [<addr> [port]]\n"
		"%s -h for help.\n",
		cmd_name, cmd_name);
	    exit(1);
	}

	if (optind < argc)
	    addr = argv[optind++];
	if (optind < argc)
	    port = argv[optind++];

	struct addrinfo hints, *res, *res0;
	struct addrinfo *arry[MAXSOCK];
	int sock[MAXSOCK];
	int nsock, error;

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;

	if (opt_ipv4only)
	    hints.ai_family = AF_INET;
	if (opt_ipv6only)
	    hints.ai_family = AF_INET6;

	error = getaddrinfo(addr, port, &hints, &res0);
	if (error) {
	    fprintf(stderr,
		"getaddrinfo: %s\n", gai_strerror(error));
	    exit(2);
	}

	nsock = 0;
	for (res = res0; res && nsock < MAXSOCK; res = res->ai_next) {
	    sock[nsock] = 0;
	    arry[nsock] = res;	
	    nsock++;
	}

	if (!nsock) {
	    fprintf(stderr, "no address for %s %s\n", addr, port);
	    exit(3);
	}

	int idx, start, delta, end;

	if (opt_reverse) {
		start = nsock - 1; delta = -1; end = -1;
	} else {
		start = 0; delta = 1; end = nsock;
	}

	for (idx = start; idx != end; idx += delta) {
		res = arry[idx];
		printf("[%d] %12s[%d]\t%16s[%d]\t%8s[%d]\t",
			idx,
			ai_family_str(res->ai_family), res->ai_family,
			ai_type_str(res->ai_socktype), res->ai_socktype,
			ai_proto_str(res->ai_protocol), res->ai_protocol);

		sock[nsock] = socket(res->ai_family, res->ai_socktype,
			res->ai_protocol);
		if (sock[nsock] < 0) {
			printf("socket[%d]\t%s\n", errno, strerror(errno));
			if (opt_abort)
				exit(11);
			continue;
		}

		if (bind(sock[nsock], res->ai_addr, res->ai_addrlen) < 0) {
			printf("bind[%d]\t%s\n", errno, strerror(errno));
			close(sock[nsock]);
			if (opt_abort)
				exit(12);
			continue;
		}
		
		if (opt_listen && listen(sock[nsock], 5)) {
			printf("listen[%d]\t%s\n", errno, strerror(errno));
			close(sock[nsock]);
			if (opt_abort)
				exit(13);
			continue;
		}

		printf("ok[0]\n");
	}

	if (num_timeout)
		sleep(num_timeout);

	for (idx = start; idx != end; idx += delta) {
		if (sock[idx] > 0)
			close(sock[idx]);
	}

	freeaddrinfo(res0);
	exit(0);
}