refactoring

src/main-conf.c

@@ -2303,7 +2303,7 @@ masscan_load_database_files(struct Masscan *masscan)
     filename = masscan->payloads.pcap_payloads_filename;
     if (filename) {
         if (masscan->payloads.udp == NULL)
-            masscan->payloads.udp = payloads_create();
+            masscan->payloads.udp = payloads_udp_create();
 
         payloads_read_pcap(filename, masscan->payloads.udp);
     }
@@ -2322,9 +2322,9 @@ masscan_load_database_files(struct Masscan *masscan)
             perror(filename);
         } else {
             if (masscan->payloads.udp == NULL)
-                masscan->payloads.udp = payloads_create();
+                masscan->payloads.udp = payloads_udp_create();
 
-            payloads_read_file(fp, filename, masscan->payloads.udp);
+            payloads_udp_readfile(fp, filename, masscan->payloads.udp);
 
             fclose(fp);
         }

src/main.c

@@ -37,7 +37,7 @@
 #include "output.h"             /* for outputing results */
 #include "rte-ring.h"           /* producer/consumer ring buffer */
 #include "rawsock-pcapfile.h"   /* for saving pcap files w/ raw packets */
-#include "rawsock-pcap.h"       /* dynamically load libpcap library */
+#include "stub-pcap.h"       /* dynamically load libpcap library */
 #include "smack.h"              /* Aho-corasick state-machine pattern-matcher */
 #include "pixie-timer.h"        /* portable time functions */
 #include "pixie-threads.h"      /* portable threads */
@@ -1149,7 +1149,7 @@ main_scan(struct Masscan *masscan)
      * trim the nmap UDP payloads down to only those ports we are using. This
      * makes lookups faster at high packet rates.
      */
-    payloads_trim(masscan->payloads.udp, &masscan->ports);
+    payloads_udp_trim(masscan->payloads.udp, &masscan->ports);
 
     /* Optimize target selection so it's a quick binary search instead
      * of walking large memory tables. When we scan the entire Internet
@@ -1514,7 +1514,7 @@ int main(int argc, char *argv[])
     masscan->shard.one = 1;
     masscan->shard.of = 1;
     masscan->min_packet_size = 60;
-    masscan->payloads.udp = payloads_create();
+    masscan->payloads.udp = payloads_udp_create();
     strcpy_s(   masscan->output.rotate.directory,
                 sizeof(masscan->output.rotate.directory),
                 ".");
@@ -1684,7 +1684,7 @@ int main(int argc, char *argv[])
             x += siphash24_selftest();
             x += ntp_selftest();
             x += snmp_selftest();
-            x += payloads_selftest();
+            x += payloads_udp_selftest();
             x += blackrock_selftest();
             x += rawsock_selftest();
             x += lcg_selftest();

src/masscan.h

@@ -371,7 +371,7 @@ struct Masscan
         char *nmap_payloads_filename;
         char *nmap_service_probes_filename;
 
-        struct NmapPayloads *udp;
+        struct PayloadsUDP *udp;
         struct TcpCfgPayloads *tcp;
         struct NmapServiceProbeList *probes;
     } payloads;

src/rawsock.c

@@ -9,11 +9,11 @@
 #include "logger.h"
 #include "main-ptrace.h"
 #include "string_s.h"
-#include "rawsock-pfring.h"
+#include "stub-pcap.h"
+#include "stub-pfring.h"
 #include "pixie-timer.h"
 #include "main-globals.h"
 
-#include "rawsock-pcap.h"
 #include "unusedparm.h"
 #include <assert.h>
 #include <ctype.h>

src/rawsock-pcap.c → src/stub-pcap.c

@@ -31,7 +31,7 @@
 #pragma warning(disable:4115 4201)
 #include <winerror.h>
 #endif
-#include "rawsock-pcap.h"
+#include "stub-pcap.h"
 
 #ifdef WIN32
 #include <windows.h>

src/rawsock-pfring.c → src/stub-pfring.c

@@ -6,7 +6,7 @@
     BEFORE installing and building PF_RING.
 
 */
-#include "rawsock-pfring.h"
+#include "stub-pfring.h"
 #include "string_s.h"
 #include "logger.h"
 

src/templ-payloads.c

@@ -26,15 +26,16 @@
 #include <ctype.h>
 #include <stdlib.h>
 
-struct Payload {
+struct PayloadUDP_Item {
     unsigned port;
     unsigned source_port; /* not used yet */
     unsigned length;
     unsigned xsum;
+    unsigned rarity;
     SET_COOKIE set_cookie;
     unsigned char buf[1];
 };
-struct Payload2 {
+struct PayloadUDP_Default {
     unsigned port;
     unsigned source_port;
     unsigned length;
@@ -44,14 +45,14 @@ struct Payload2 {
 
 };
 
-struct NmapPayloads {
+struct PayloadsUDP {
     unsigned count;
     size_t max;
-    struct Payload **list;
+    struct PayloadUDP_Item **list;
 };
 
 
-struct Payload2 hard_coded_payloads[] = {
+struct PayloadUDP_Default hard_coded_payloads[] = {
     /* ECHO protocol - echoes back whatever we send */
     {7, 65536, 12, 0, 0, "masscan-test 0x00000000"},
 
@@ -178,8 +179,8 @@ partial_checksum(const unsigned char *px, size_t icmp_length)
  * If we have the port, return the payload
  ***************************************************************************/
 int
-payloads_lookup(
-        const struct NmapPayloads *payloads,
+payloads_udp_lookup(
+        const struct PayloadsUDP *payloads,
         unsigned port,
         const unsigned char **px,
         unsigned *length,
@@ -210,7 +211,7 @@ payloads_lookup(
 /***************************************************************************
  ***************************************************************************/
 void
-payloads_destroy(struct NmapPayloads *payloads)
+payloads_udp_destroy(struct PayloadsUDP *payloads)
 {
     unsigned i;
     if (payloads == NULL)
@@ -232,17 +233,17 @@ payloads_destroy(struct NmapPayloads *payloads)
  * faster, ideally looking up only zero or one rather than twenty.
  ***************************************************************************/
 void
-payloads_trim(struct NmapPayloads *payloads, const struct RangeList *target_ports)
+payloads_udp_trim(struct PayloadsUDP *payloads, const struct RangeList *target_ports)
 {
     unsigned i;
-    struct Payload **list2;
+    struct PayloadUDP_Item **list2;
     unsigned count2 = 0;
 
     /* Create a new list */
     if (payloads->max >= SIZE_MAX/sizeof(list2[0]))
         exit(1); /* integer overflow */
     else
-    list2 = (struct Payload **)malloc(payloads->max * sizeof(list2[0]));
+    list2 = (struct PayloadUDP_Item **)malloc(payloads->max * sizeof(list2[0]));
     if (list2 == NULL)
         exit(1); /* out of memory */
 
@@ -443,26 +444,26 @@ get_next_line(FILE *fp, unsigned *line_number, char *line, size_t sizeof_line)
 
 /***************************************************************************
  ***************************************************************************/
-static unsigned
-payload_add(struct NmapPayloads *payloads,
+unsigned
+payloads_udp_add(struct PayloadsUDP *payloads,
             const unsigned char *buf, size_t length,
             struct RangeList *ports, unsigned source_port,
             SET_COOKIE set_cookie)
 {
     unsigned count = 1;
-    struct Payload *p;
+    struct PayloadUDP_Item *p;
     uint64_t port_count = rangelist_count(ports);
     uint64_t i;
 
     for (i=0; i<port_count; i++) {
         /* grow the list if we need to */
         if (payloads->count + 1 > payloads->max) {
             size_t new_max = payloads->max*2 + 1;
-            struct Payload **new_list;
+            struct PayloadUDP_Item **new_list;
 
             if (new_max >= SIZE_MAX/sizeof(new_list[0]))
                 exit(1); /* integer overflow */
-            new_list = (struct Payload**)malloc(new_max * sizeof(new_list[0]));
+            new_list = (struct PayloadUDP_Item**)malloc(new_max * sizeof(new_list[0]));
             if (new_list == NULL)
                 exit(1); /* out of memory */
 
@@ -473,7 +474,7 @@ payload_add(struct NmapPayloads *payloads,
         }
 
         /* allocate space for this record */
-        p = (struct Payload *)malloc(sizeof(p[0]) + length);
+        p = (struct PayloadUDP_Item *)malloc(sizeof(p[0]) + length);
         if (p == NULL)
             exit(1); /* out of memory */
 
@@ -518,7 +519,7 @@ payload_add(struct NmapPayloads *payloads,
  ***************************************************************************/
 void
 payloads_read_pcap(const char *filename,
-                   struct NmapPayloads *payloads)
+                   struct PayloadsUDP *payloads)
 {
     struct PcapFile *pcap;
     unsigned count = 0;
@@ -592,7 +593,7 @@ payloads_read_pcap(const char *filename,
          * Now we've completely parsed the record, so add it to our
          * list of payloads
          */
-        count += payload_add(   payloads,
+        count += payloads_udp_add(   payloads,
                                 buf + parsed.app_offset,
                                 parsed.app_length,
                                 ports,
@@ -609,8 +610,8 @@ payloads_read_pcap(const char *filename,
  * Called during processing of the "--nmap-payloads <filename>" directive.
  ***************************************************************************/
 void
-payloads_read_file(FILE *fp, const char *filename,
-                   struct NmapPayloads *payloads)
+payloads_udp_readfile(FILE *fp, const char *filename,
+                   struct PayloadsUDP *payloads)
 {
     char line[16384];
     unsigned line_number = 0;
@@ -683,7 +684,7 @@ payloads_read_file(FILE *fp, const char *filename,
          * Now we've completely parsed the record, so add it to our
          * list of payloads
          */
-        payload_add(payloads, buf, buf_length, ports, source_port, 0);
+        payloads_udp_add(payloads, buf, buf_length, ports, source_port, 0);
 
         rangelist_remove_all(ports);
     }
@@ -719,12 +720,12 @@ payloads_read_file(FILE *fp, const char *filename,
 
 /***************************************************************************
  ***************************************************************************/
-struct NmapPayloads *
-payloads_create(void)
+struct PayloadsUDP *
+payloads_udp_create(void)
 {
     unsigned i;
-    struct NmapPayloads *payloads;
-    payloads = (struct NmapPayloads *)malloc(sizeof(*payloads));
+    struct PayloadsUDP *payloads;
+    payloads = (struct PayloadsUDP *)malloc(sizeof(*payloads));
     if (payloads == NULL)
         exit(1);
     memset(payloads, 0, sizeof(*payloads));
@@ -749,7 +750,7 @@ payloads_create(void)
 
         /* Add this to our real payloads. This will get overwritten
          * if the user adds their own with the same port */
-        payload_add(payloads,
+        payloads_udp_add(payloads,
                     (const unsigned char*)hard_coded_payloads[i].buf,
                     length,
                     &list,
@@ -763,7 +764,7 @@ payloads_create(void)
 /****************************************************************************
  ****************************************************************************/
 int
-payloads_selftest(void)
+payloads_udp_selftest(void)
 {
     unsigned char buf[1024];
     size_t buf_length;

src/templ-payloads.h

@@ -10,42 +10,42 @@ struct RangeList;
  *      0 on success, or postivie integer on failure.
  */
 int
-payloads_selftest(void);
+payloads_udp_selftest(void);
 
 /**
  * Create this module. Must be matched with the 'destroy()' function on exit
  */
-struct NmapPayloads *
-payloads_create(void);
+struct PayloadsUDP *
+payloads_udp_create(void);
 
 /**
  * Free the resources of an object created with a matching call to
  * 'payloads_create()'
  */
 void
-payloads_destroy(struct NmapPayloads *payloads);
+payloads_udp_destroy(struct PayloadsUDP *payloads);
 
 /**
  * Read payloads from an "nmap-payloads" formatted file. The caller is
  * responsible for opening/closing the file, but should passin the
  * filename so that we can print helpful error messages.
  */
 void
-payloads_read_file(FILE *fp, const char *filename,
-                   struct NmapPayloads *payloads);
+payloads_udp_readfile(FILE *fp, const char *filename,
+                   struct PayloadsUDP *payloads);
 
 /**
  * Read payloads from a libpcap formatted file.
  */
 void
-payloads_read_pcap(const char *filename, struct NmapPayloads *payloads);
+payloads_read_pcap(const char *filename, struct PayloadsUDP *payloads);
 
 /**
  * Called to remove any payloads that aren't be used in the scan. This makes
  * lookups faster when generating packets.
  */
 void
-payloads_trim(struct NmapPayloads *payloadsd, const struct RangeList *ports);
+payloads_udp_trim(struct PayloadsUDP *payloadsd, const struct RangeList *ports);
 
 
 /**
@@ -81,8 +81,8 @@ typedef unsigned (*SET_COOKIE)(unsigned char *px, size_t length,
  *      packet for each transmission
  */
 int
-payloads_lookup(
-                const struct NmapPayloads *payloads,
+payloads_udp_lookup(
+                const struct PayloadsUDP *payloads,
                 unsigned port,
                 const unsigned char **px,
                 unsigned *length,

src/templ-pkt.c

@@ -515,7 +515,7 @@ udp_payload_fixup(struct TemplatePacket *tmpl, unsigned port, unsigned seqno)
 
     UNUSEDPARM(seqno);
 
-    payloads_lookup(tmpl->payloads,
+    payloads_udp_lookup(tmpl->payloads,
                     port,
                     &px2,
                     &length2,
@@ -916,7 +916,7 @@ template_packet_init(
     struct TemplateSet *templset,
     const unsigned char *source_mac,
     const unsigned char *router_mac,
-    struct NmapPayloads *payloads,
+    struct PayloadsUDP *payloads,
     int data_link,
     uint64_t entropy)
 {

src/templ-pkt.h

@@ -2,7 +2,7 @@
 #define TCP_PACKET_H
 #include <stdio.h>
 #include <stdint.h>
-struct NmapPayloads;
+struct PayloadsUDP;
 struct MassVulnCheck;
 
 /**
@@ -51,7 +51,7 @@ struct TemplatePacket {
     unsigned checksum_tcp;
     unsigned ip_id;
     enum TemplateProtocol proto;
-    struct NmapPayloads *payloads;
+    struct PayloadsUDP *payloads;
 };
 
 /**
@@ -97,7 +97,7 @@ template_packet_init(
     struct TemplateSet *templset,
     const unsigned char *source_mac,
     const unsigned char *router_mac,
-    struct NmapPayloads *payloads,
+    struct PayloadsUDP *payloads,
     int data_link,
     uint64_t entropy);