#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <iostream.h>

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <arpa/inet.h>
#include <errno.h>

#define socklen_t int

#define IP_Header_Size sizeof(struct ip)
#define UDP_Header_Size sizeof(struct udphdr)
#define Data_Size strlen(DATA)
#define DATA "Hello World!"

#define Total_Size 40
// this needs to be set to the actual number, not more constants
// use cout << IP_Header_Size+UDP_Header_Size+Data_Size << endl;
// to figure it out

#define Sender_IP "192.168.1.100"
#define Sender_Port "0"
#define Receiver_IP "192.168.1.100"
#define Receiver_Port "0"

#pragma mark -
#pragma mark -
#pragma mark -


struct psuedohdr  {
   struct in_addr source_address;
   struct in_addr dest_address;
   unsigned char place_holder;
   unsigned char protocol;
   unsigned short length;
 } psuedohdr;

void setupSocket(void);
void setupHeaders(void);

unsigned short in_cksum(unsigned short *addr,int len);
unsigned short trans_check(unsigned char proto, char *packet, int length, struct in_addr source_address, struct in_addr dest_address);


int sockfd;

char	 	datapacket[Total_Size];
struct ip *	IP_Header	= (struct ip *)		datapacket;
struct udphdr *	UDP_Header	= (struct udphdr *)	datapacket+IP_Header_Size;
struct sockaddr_in remote;
#pragma mark -
#pragma mark -
#pragma mark -

main () {
    setupSocket();
    setupHeaders();
    
    strcpy(datapacket+IP_Header_Size+UDP_Header_Size, DATA); // copy data over to packet
    
    
    /*if (write(sockfd, datapacket, Total_Size) < 0) {
        perror("write");
        exit(1);
    }*/
    
    if(bind(sockfd,(struct sockaddr *)&remote,(socklen_t)sizeof(remote)) < 0 ) {
        perror("Bind");
        exit(1);
    }
    
    if (write(sockfd, datapacket, Total_Size) < 0) {
        perror("write");
        exit(1);
    }
    
    if (sendto(sockfd, datapacket, Total_Size, 0, (struct sockaddr *)&remote, sizeof(remote)) < 0) {
        perror("sendto");
        exit(1);
    }
    
}




void setupSocket(void)
{
    int yes=1;
    
    if( (sockfd=socket(AF_INET,SOCK_RAW,IPPROTO_UDP)) < 0 ) {
        perror("sock");
        exit(1);
    }
    
    if (setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) < 0) {
        perror("setsockopt");
        exit(1);
    }
    
    if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &yes,sizeof(yes)) < 0 ) {
        perror("setsockopt:");
        exit(errno);
    }
}


void setupHeaders(void)
{
    bzero(datapacket, Total_Size);
    struct in_addr saddr, daddr;
    unsigned int sport, dport;
    
    saddr.s_addr = inet_addr(Sender_IP);
    daddr.s_addr = inet_addr(Receiver_IP);
    sport = atoi(Sender_Port);
    dport = atoi(Receiver_Port);
    
    remote.sin_family = AF_INET;
    remote.sin_port = htons(dport);
    remote.sin_addr = daddr;
    
    UDP_Header->uh_sport=htons(sport);
    UDP_Header->uh_dport=htons(dport);
    UDP_Header->uh_ulen=htons(UDP_Header_Size+Data_Size);
    UDP_Header->uh_sum= trans_check(IPPROTO_UDP, (char *)UDP_Header, UDP_Header_Size, saddr, daddr);
    
    IP_Header->ip_hl = 5;
    IP_Header->ip_v = 4;
    IP_Header->ip_tos = 0;
    IP_Header->ip_len = htons(IP_Header_Size);
    IP_Header->ip_off = htons(IP_DF);
    IP_Header->ip_ttl = 255;
    IP_Header->ip_p = htons(17);
    IP_Header->ip_sum = htons((unsigned short)in_cksum((unsigned short *)IP_Header, IP_Header_Size));
    IP_Header->ip_src.s_addr = inet_addr(Sender_IP);
    IP_Header->ip_dst.s_addr = inet_addr(Receiver_IP);
}


unsigned short in_cksum(unsigned short *addr,int len)
 {
         register int sum = 0;
         u_short answer = 0;
         register u_short *w = addr;
         register int nleft = len;
 
         /*
          * Our algorithm is simple, using a 32 bit accumulator (sum), we add
          * sequential 16 bit words to it, and at the end, fold back all the
          * carry bits from the top 16 bits into the lower 16 bits.
          */
         while (nleft > 1)  {
                 sum += *w++;
                 nleft -= 2;
         }
 
         /* mop up an odd byte, if necessary */
         if (nleft == 1) {
                 *(u_char *)(&answer) = *(u_char *)w;
                 sum += answer;
         }
 
         /* add back carry outs from top 16 bits to low 16 bits */
         sum = (sum >> 16) + (sum & 0xffff);     /* add hi 16 to low 16 */
         sum += (sum >> 16);                     /* add carry */
         answer = ~sum;                          /* truncate to 16 bits */
         return(answer);
 }
 
 unsigned short trans_check(unsigned char proto, char *packet, int length, struct in_addr source_address, struct in_addr dest_address)
 {
   char *psuedo_packet;
   unsigned short answer;
   
   psuedohdr.protocol = proto;
   psuedohdr.length = htons(length);
   psuedohdr.place_holder = 0;
 
   psuedohdr.source_address = source_address;
   psuedohdr.dest_address = dest_address;
   
   if((psuedo_packet = (char *)malloc(sizeof(psuedohdr) + length)) == NULL)  {
     perror("malloc");
     exit(1);
   }
   
   memcpy(psuedo_packet,&psuedohdr,sizeof(psuedohdr));
   memcpy((psuedo_packet + sizeof(psuedohdr)), packet,length);
   
   answer = (unsigned short)in_cksum((unsigned short *)psuedo_packet, (length + sizeof(psuedohdr)));
   free(psuedo_packet);
   return answer;
 }