#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<features.h>
#include<linux/if_packet.h>
#include<linux/if_ether.h>
#include<errno.h>
#include<sys/ioctl.h>
#include<net/if.h>
#include<linux/ip.h>
#include<arpa/inet.h>
#include<linux/tcp.h>
#include<netinet/in.h>

char* getService(int port) {
    switch (port) {
        case 20: return "FTP (C)";
        case 21: return "FTP (D)";
        case 22: return "SSH";
        case 23: return "Telnet";
        case 53: return "DNS";
        case 80: return "HTTP";
        case 110: return "POP3";
        case 143: return "IMAP";
        case 443: return "HTTPS";
        case 465: return "SMTPS";
    }
    return "N/A";
}

void showTCPInfo(struct ethhdr *ethernet_header, struct iphdr *ip_header, struct tcphdr *tcp_header) {
    //providing 'lower' structs for eventual usage
    int windowSize = tcp_header->window;
    char str[INET_ADDRSTRLEN];
    char* sender;
    int i = 1;
    sender = inet_ntop(AF_INET, &ip;_header->saddr, str, sizeof (str));
    if (tcp_header->syn == 1 && tcp_header->ack == 0) {
        char* os;
        switch (windowSize) {
            case 32: os = "Windows Vista/7";
                break;
            case 64: os = "Windows XP";
                break;
            case 65535: os = "Mac OS X";
                break;
            case 53270: os = "Linux";
                break;
            default: os = "N/A";
                break;
        }

        printf("TCP SYN t Sender %s t service: %s t OS: %s (WindowSize: %i)n", sender,


                getService(ntohs(tcp_header->dest)), os, ntohs(tcp_header->window));
    }
}

void parseHeader(unsigned char *packet, int len) {
    /* FIXME:
     * implement a check, whether the packet was really recieved and not
     * sent by host
     */
    // short type = 0; //1=Ethernet, 2=IP, 3=TCP
    struct ethhdr *ethernet_header;
    struct iphdr *ip_header;
    struct tcphdr *tcp_header;
    //printf("Recieved a packet of size %i t type: n",len);
    //Checking the size of packet to verify whether it COULD be a TCP packet
    if (len >= (sizeof (struct ethhdr))) {
        ethernet_header = (struct ethhdr *) packet;
        if (len >= (sizeof (struct ethhdr) + sizeof (struct iphdr)) && ntohs(ethernet_header->
                h_proto) == ETH_P_IP) {
            ip_header = (struct iphdr *) (packet + sizeof (struct ethhdr));
            if (len >= (sizeof (struct ethhdr) + sizeof (struct iphdr) + sizeof (struct tcphdr))
                    && (ip_header->protocol == IPPROTO_TCP)) {
                tcp_header = (struct tcphdr *) (packet + sizeof (struct ethhdr) + ip_header->
                        ihl * 4);
                showTCPInfo(ethernet_header, ip_header, tcp_header);


            }
        }
    }
}

int main(int argc, char * argv []) {
    struct sockaddr packetS; //the final packet struct
    unsigned char packet[2048]; //content of packet
    int len; //length of packet
    //unsigned int foo = sizeof (packetS);
    int sd;
    struct sockaddr_in sa;
    int i = 1;
    char * test1 ="Dies ist ein Test";

    //creating raw socket

    int rawsock;
    if ((rawsock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP))) == -1) {
        perror("Error creating raw socket: ");
        exit(-1);
    }
    while ((len = recvfrom(rawsock, packet, sizeof (packet) - 1, 0, (struct sockaddr*) & packetS, sizeof (packetS)))) {
        parseHeader(packet, len);
        
        break;
    }


    

    if (argc != 2) {
        printf(" Usage : %s ipv4 - address n ", argv [0]);
        exit(EXIT_FAILURE);
    }

    if ((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        printf(" socket () failed : % s n ", strerror(errno));
        exit(EXIT_FAILURE);
    }

    /* Initialisierung der Socket - Adreßstruktur */
    memset(& sa, 0, sizeof ( sa)); /* erst alles auf 0 */

    sa . sin_family = AF_INET; /* IPv4 */
    sa . sin_port = htons(33333);
    /* IPv4 - Adresse in Netzwerkdarstellung einsetzen */
    if (inet_pton(AF_INET, argv [1], & sa . sin_addr) != 1) {
        printf(" inet_pton () failed . n ");
        close(sd);
        exit(EXIT_FAILURE);
    }

    /* Leeres Datagramm als Anforderung an Server schicken */

    if (sendto(sd, test1, 0, 0, (struct sockaddr *) & sa,
            sizeof ( sa)) < 0) {
        printf(" sendto () failed : % s  n ", strerror(errno));
        close(sd);
        exit(EXIT_FAILURE);
    }

    printf(" Anfrage an % s verschickt . n ", argv [1]);

    /* Ausgabe des Servers lesen 
    if (recvfrom(sd, & stime, sizeof ( stime), 0, NULL,
            NULL) < 0) {
        printf(" recvfrom () failed : % s  n ", strerror(errno));
        close(sd);
        exit(EXIT_FAILURE);
    }*/
    printf(" Antwort von % s erhalten . n ", argv [1]);


    return 0;
}