handle ack receival from separate thread

Author: eiger824

common.c

@@ -4,6 +4,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <regex.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
 
 #include "common.h"
 
@@ -124,3 +126,10 @@ int get_random_integer(int min, int max)
 {
     return rand() % ( max - min + 1) + min;
 }
+
+size_t get_win_size()
+{
+    struct winsize ws;
+    ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
+    return ws.ws_col;
+}

common.h

@@ -26,5 +26,7 @@ int get_verbose();
 void set_color(int color);
 int get_color();
 int get_random_integer(int min, int max);
+size_t get_win_size();
+
 
 #endif /* COMMON_H_ */

net/scan/tcphalfopen.c

@@ -13,6 +13,7 @@
 #include "tcphalfopen.h" 
 #include "net.h"
 #include "common.h"
+#include "threads.h"
 
 struct in_addr g_dest_ip;
 static int g_spoofing = 0;
@@ -34,11 +35,52 @@ static void get_random_ip(char* ip, size_t n)
     sprintf(ip, "%d.%d.%d.%d", a, b, c, d);
 }
 
-int half_open(const char* ip, port_t port)
+void* wait_for_syn_ack(void* data)
 {
-    int s;
-    socklen_t sl;
+    struct thread_retval* rv = (struct thread_retval*) data;
     ssize_t data_size;
+    int sniff_socket;
+    socklen_t sl;
+    struct sockaddr saddr;
+    uint8_t* recvbuff;
+
+    recvbuff = (uint8_t* ) malloc(USHRT_MAX);
+
+    // Open this socket
+    if ( (sniff_socket = socket(AF_INET, SOCK_RAW, IPPROTO_TCP) ) < 0)
+    {
+        perror("socket() failed");
+        free(recvbuff);
+        return NULL;
+    }
+
+    // Receive from buffer, await until done
+    while (1)
+    {
+        if ( (data_size = recvfrom(sniff_socket , recvbuff , USHRT_MAX, 0 , &saddr , &sl)) < 0 )
+        {
+            perror("recvfrom() error");
+            free(recvbuff);
+            close(sniff_socket);
+            return NULL;
+        }
+
+        rv->port_status = process_packet(recvbuff, data_size);
+        //Now process the packet
+        if ( rv->port_status == PHSCAN_PORT_OPEN || rv->port_status == PHSCAN_PORT_CLOSED)
+        {
+            free(recvbuff);
+            close(sniff_socket);
+            pthread_exit( (void*)rv );
+        }
+    }
+    free(recvbuff);
+    close(sniff_socket);
+    return (void*)rv;
+}
+int half_open(const char* ip, port_t port)
+{
+    int s, ret;
     //Datagram to represent the packet
     char datagram[4096];	
     //IP header
@@ -48,12 +90,8 @@ int half_open(const char* ip, port_t port)
     struct pseudo_header psh;
 
     struct sockaddr_in  dest;
-    struct sockaddr saddr;
-
     char source_ip[16];
 
-    unsigned char *buffer = (unsigned char *)malloc(65536); //Its Big!
-
     //Create a raw socket
     if ( (s = socket (AF_INET, SOCK_RAW , IPPROTO_TCP)) < 0)
     {
@@ -117,6 +155,19 @@ int half_open(const char* ip, port_t port)
         return 1;
     }
 
+    pthread_t rsp;
+    pthread_attr_t attrs;
+
+    pthread_attr_init(&attrs);
+    struct thread_retval rv;
+
+    // Start thread that will get the answer
+    if ( (ret = pthread_create(&rsp, &attrs, wait_for_syn_ack, (void*)&rv)) != 0)
+    {
+        perror ("pthread_create() failed");
+        return PHSCAN_ERROR;
+    }
+
     dest.sin_family = AF_INET;
     dest.sin_addr.s_addr = g_dest_ip.s_addr;
 
@@ -140,55 +191,88 @@ int half_open(const char* ip, port_t port)
         return 1;
     }
 
-    int ret;
-    // Receive from buffer, await until done
-    while (1)
+    // Receive from thread, await until done
+    void* retval;
+    pthread_join(rsp, &retval);
+
+    return ((struct thread_retval*)retval)->port_status;
+}
+
+
+void dump_packet(uint8_t* buffer, size_t size, size_t width)
+{
+    size_t i;
+    size_t current_width = 0;
+    for (i = 0; i < size; ++i)
     {
-        if ( (data_size = recvfrom(s , buffer , 65536 , 0 , &saddr , &sl)) < 0 )
+        if (current_width + 3 < width)
+            current_width += 3;
+        else
         {
-            perror("recvfrom() error");
-            fflush(stdout);
-            return 1;
+            current_width = 0;
+            printf("\n");
         }
 
-        ret = process_packet(buffer , data_size);
-        //Now process the packet
-        if ( ret == PHSCAN_PORT_OPEN || ret == PHSCAN_PORT_CLOSED)
-            break;
+        printf("%02x ", buffer[i]);
     }
-    return ret;
+    printf("\n");
+}
+void dump_ip_packet(struct iphdr* iph)
+{
+    if (!iph)
+        return;
+
+    printf("iph->ihl = %u\n", iph->ihl);
+    printf("iph->version = %u\n", iph->version);
+    printf("iph->tos = %u\n", iph->tos);
+    printf("iph->tot_len = %u\n", iph->tot_len); 
+    printf("iph->id = 0x%x\n", iph->id); 
+    printf("iph->frag_off = 0x%x\n", iph->frag_off); 
+    printf("iph->ttl = %u\n", iph->ttl);
+    printf("iph->protocol = %d\n", iph->protocol);
+    printf("iph->check = 0x%x\n", iph->check); 
+    printf("iph->saddr = %u\n", iph->saddr); 
+    printf("iph->daddr = %u\n", iph->daddr); 
 }
 
 /*
    Method to sniff incoming packets and look for Ack replies
    */
-int process_packet(unsigned char* buffer, int size)
+int process_packet(uint8_t* buffer, int size)
 {
     //Get the IP Header part of this packet
     struct iphdr *iph = (struct iphdr*)buffer;
+    struct tcphdr *tcph;
     struct sockaddr_in source,dest;
     unsigned short iphdrlen;
+
     if (size < 0 || !buffer)
         return PHSCAN_PKT_UNRELATED;
 
-    if (iph->protocol == 6)
+    if (iph->protocol == IPPROTO_TCP)
     {
-        struct iphdr *iph = (struct iphdr *)buffer;
         iphdrlen = iph->ihl*4;
 
-        struct tcphdr *tcph=(struct tcphdr*)(buffer + iphdrlen);
+        tcph = (struct tcphdr*)(buffer + iphdrlen);
+
+        // Dump this packet
+        // dump_packet(buffer, size, 30);
+        // dump_ip_packet(iph);
 
         memset(&source, 0, sizeof(source));
         source.sin_addr.s_addr = iph->saddr;
-
         memset(&dest, 0, sizeof(dest));
         dest.sin_addr.s_addr = iph->daddr;
 
         if (tcph->syn == 1 && tcph->ack == 1
                 && source.sin_addr.s_addr == g_dest_ip.s_addr )
+        {
             return PHSCAN_PORT_OPEN;
+        }
         else
+        {
             return PHSCAN_PORT_CLOSED;
+        }
     }
     return PHSCAN_PKT_UNRELATED;
 }

net/scan/tcphalfopen.h

@@ -22,7 +22,7 @@ struct pseudo_header    //needed for checksum calculation
     struct tcphdr tcp;
 };
 
-int process_packet(unsigned char* , int);
+int process_packet(uint8_t* , int);
 unsigned short csum(unsigned short * , int );
 void set_ip_spoofing(int spoof);
 

progress.c

@@ -1,6 +1,4 @@
-#include <sys/ioctl.h>
 #include <string.h>
-#include <unistd.h>
 
 #include "progress.h"
 #include "common.h"
@@ -11,10 +9,7 @@ const char* g_header;
 
 void set_bar_length()
 {
-    struct winsize ws;
-    ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
-    // Adjust width so we have space for other information
-    g_width = ws.ws_col;
+    g_width = get_win_size(); 
 }
 
 void set_bar_header(const char* text)

progress.h

@@ -3,6 +3,7 @@
 
 #include <stdio.h>
 
+size_t get_win_size();
 void set_bar_length();
 void set_bar_header(const char* text);
 void set_bar(size_t progress, const char* delim);

threads.h

@@ -19,6 +19,12 @@ struct thread_data
     int (*conn_hdlr)(const char*, port_t);
 };
 
+struct thread_retval 
+{
+    int id;
+    int port_status;
+};
+
 void* thread_run(void* data);
 
 #endif /* PHSCAN_THREADS_H_ */