WIP. Added some stuff for dhcpinform. (#4)

* WIP.  Added some stuff for dhcpinform.

* Removing stats that make no sense for dhcpinform.

* Moved the zero flags out for release and inform.

* Adding in some stats changes

* Adding config changes and handlers to allow rps option changes during run-time.

* Switched to httpway for graceful shutdown.

* Small http status change.

* Quick pass at auto-tuning.  Need changes in generator to really make this work right/well.

* Quick stats method rename, options check in generator, and switched to options loop in handler.

* Some small adjustments to wrap up. Not an amazing example, but a working one.

Author: ipchama

AutoTuner.py

@@ -0,0 +1,81 @@
+#!/usr/bin/python3
+
+import requests
+import json
+import logging
+import os
+import time
+import math
+
+class AutoTuner:
+    """A class for using the dhammer API to find the optimal rps rate."""
+
+    def __init__(self, options):
+        self._options = options
+        self._run = True
+        self._rps = 1
+        
+        self._previous_ramped_up_rps = 1
+
+    def _tune(self):
+        logging.debug("Going to tune...")
+
+        response = requests.get(f"http://{self._options.api_address}:{self._options.api_port}/stats")
+        response.raise_for_status()
+        stats = json.loads(response.text)
+        
+        target_stat = None
+        compare_stat = None
+        
+        for stat in stats:
+            if stat['stat_name'] == self._options.tune_stat_name:
+                target_stat = stat
+            elif stat['stat_name'] == self._options.tune_stat_compare_name:
+                compare_stat = stat
+        
+        diff_perc = target_stat['stat_rate_per_second'] / compare_stat['stat_rate_per_second']
+        
+        info = {}
+                
+        if  diff_perc >= self._options.tune_compare_min_percentage:
+            self._previous_ramped_up_rps = self._rps
+            self._rps = self._rps * self._options.ramp_up_factor             
+
+            response = requests.get(f"http://{self._options.api_address}:{self._options.api_port}/update/rps/{math.floor(self._rps)}")
+            response.raise_for_status()
+            
+            print(f"{target_stat['stat_name']} / {compare_stat['stat_name']} = {diff_perc}: ramped up. Target RPS is {self._rps}.")
+
+        else:
+            
+            self._options.ramp_up_factor = self._options.ramp_up_factor * self._options.ramp_down_factor
+
+            if self._options.ramp_up_factor <= 1:
+                 print(f"{target_stat['stat_name']} / {compare_stat['stat_name']} = {diff_perc}: Ramp down triggered, but next ramp-up difference too low.")
+                 print(f"Target reached. Optimal RPS is approximately {math.floor(self._previous_ramped_up_rps)}.")
+                 return(False)
+             
+            self._rps = self._previous_ramped_up_rps * self._options.ramp_up_factor
+            
+            response = requests.get(f"http://{self._options.api_address}:{self._options.api_port}/update/rps/{math.floor(self._rps)}")
+            response.raise_for_status()
+            print(f"{target_stat['stat_name']} / {compare_stat['stat_name']} = {diff_perc}: ramped down. Target RPS is {self._rps}.")
+
+        return(True)
+
+    def prepare(self):
+        response = requests.get(f"http://{self._options.api_address}:{self._options.api_port}/update/rps/1")
+        response.raise_for_status()
+        time.sleep(self._options.refresh_rate_seconds)
+  
+  
+    def stop(self): # GIL for now ;D
+        self._run = False
+        return(True)
+
+
+    def start(self):      
+        while self._run and self._tune(): # GIL for now ;D
+            time.sleep(self._options.refresh_rate_seconds)
+            
+

autotune.py

@@ -0,0 +1,82 @@
+#!/usr/bin/python3
+
+import argparse
+import signal
+import sys
+import AutoTuner
+
+"""
+	Example script for interacting with the dhammer API
+
+	Usage: autotune.py --tune-stat-name OfferReceived --tune-stat-compare-name DiscoverSent
+"""
+
+##### Install a signal handler for CTRL+C #####
+
+def signal_handler(signal, frame, tuner):
+    try:
+        # Try to shut things down gracefully.
+        print('Stopping...')
+        tuner.stop()
+    except BaseException as e:
+        print(str(e))
+        pass
+    
+    print('Shutting down...')
+    sys.exit(0) # Raise a SystemExit exception
+
+def main():
+
+    ##### Get command-line arguments
+    parser = argparse.ArgumentParser(description='Find the max request rate.')
+    
+    parser.add_argument('--api-address','-a', dest='api_address', default='localhost',
+                        help='Address for stats API.')
+
+    parser.add_argument('--api-port','-p', dest='api_port', default=8080,
+                        help='Port for stats API')
+    
+    parser.add_argument('--tune-stat-name','-t', dest='tune_stat_name', default=None, required=True,
+                        help='Stat field used to decide if ramp up or down is necessary.')
+
+    parser.add_argument('--tune-stat-compare-name','-c', dest='tune_stat_compare_name', default=None, required=True,
+                        help='Stat used for comparison to determine if goal is being reached.')
+
+    parser.add_argument('--tune-compare-min-percentage','-cp', dest='tune_compare_min_percentage', default=0.95,
+                        help='The maximum percentage difference between the tuning stat and the comparison stat.')
+
+    parser.add_argument('--ramp-up-factor','-ru', dest='ramp_up_factor', default=2, type=int,
+                        help='Factor by which to ramp up the target RPS.')
+
+    parser.add_argument('--ramp-down-factor','-rd', dest='ramp_down_factor', default=0.9, type=int,
+                        help='Factor by which to reduce the ramp-up factor.')
+    
+    parser.add_argument('--refresh-rate_seconds','-rr', dest='refresh_rate_seconds', default=6, type=int,
+                        help='Rate to check stats. Should be slightly longer than the dhammer refresh rate.')
+
+    args = parser.parse_args()
+    
+    
+    ##### Prep the result handler
+    tuner = AutoTuner.AutoTuner(args)
+
+    # Register our signal handler.
+    signal.signal(signal.SIGINT, lambda signal, frame: signal_handler(signal, frame, tuner))
+
+    try:
+        tuner.prepare()
+        tuner.start()
+    except SystemExit:
+        pass
+    except BaseException as e:
+        print("Tuner broke down: %s" % str(e))
+
+    try:
+        tuner.stop()
+    except:
+        pass
+    
+    return(0)
+
+if __name__ == "__main__":
+    main()

config/config.go

@@ -45,4 +45,7 @@ type Options struct {
 
 	InterfaceName *string
 	GatewayMAC    net.HardwareAddr
+
+	ApiPort    *int
+	ApiAddress *string
 }

dhammer.go

@@ -15,7 +15,7 @@ func main() {
 	options := &config.Options{}
 
 	options.Handshake = flag.Bool("handshake", true, "Attempt full handshakes")
-	options.DhcpInfo = flag.Bool("dhcpinfo", false, "Blast DHCPINFO packets, but don't complete the handshake. NOT YET IMPLEMENTED.")
+	options.DhcpInfo = flag.Bool("info", false, "Send DHCPINFO packets. This requires a full handshake.")
 	options.DhcpBroadcast = flag.Bool("dhcp-broadcast", true, "Set the broadcast bit.")
 	options.EthernetBroadcast = flag.Bool("ethernet-broadcast", true, "Use ethernet broadcasting.")
 	options.DhcpRelease = flag.Bool("release", false, "Release leases after acquiring them.")
@@ -38,6 +38,10 @@ func main() {
 
 	options.InterfaceName = flag.String("interface", "eth0", "Interface name for listening and sending.")
 	gatewayMAC := flag.String("gateway-mac", "de:ad:be:ef:f0:0d", "MAC of the gateway.")
+
+	options.ApiAddress = flag.String("api-address", "", "IP for the API server to listen on.")
+	options.ApiPort = flag.Int("api-port", 8080, "Port for the API server to listen on.")
+
 	flag.Parse()
 
 	var err error

generator/generator.go

@@ -24,6 +24,7 @@ type GeneratorV4 struct {
 	addStat       func(stats.StatValue) bool
 	finishChannel chan struct{}
 	doneChannel   chan struct{}
+	rpsChannel    chan int
 }
 
 func NewV4(o *config.Options, iface *net.Interface, logFunc func(string) bool, errFunc func(error) bool, payloadFunc func([]byte) bool, statFunc func(stats.StatValue) bool) *GeneratorV4 {
@@ -37,6 +38,7 @@ func NewV4(o *config.Options, iface *net.Interface, logFunc func(string) bool, e
 		addStat:       statFunc,
 		finishChannel: make(chan struct{}, 1),
 		doneChannel:   make(chan struct{}),
+		rpsChannel:    make(chan int, 1),
 	}
 
 	return &g
@@ -56,6 +58,23 @@ func (g *GeneratorV4) Stop() error {
 	return nil
 }
 
+func (g *GeneratorV4) Update(attr interface{}, val interface{}) error {
+
+	if a, ok := attr.(string); ok {
+		if a == "rps" {
+			if v, ok := val.(string); ok {
+				if vI, err := strconv.Atoi(v); err != nil {
+					return err
+				} else {
+					g.rpsChannel <- vI
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
 func (g *GeneratorV4) Run() {
 
 	macs := g.generateMacList()
@@ -93,6 +112,9 @@ func (g *GeneratorV4) Run() {
 		if err != nil {
 			g.addError(err)
 			continue
+		} else if aOption > 255 {
+			g.addLog("DHCP option codes greater than 255 are not supported. Skipping " + optionValCombo[0])
+			continue
 		}
 
 		aValue, err := base64.StdEncoding.DecodeString(optionValCombo[1])
@@ -166,11 +188,19 @@ func (g *GeneratorV4) Run() {
 		default:
 		}
 
+		select {
+		case mRps, _ = <-g.rpsChannel:
+			sent = 0
+			start = time.Now()
+			time.Sleep(1)
+		default:
+		}
+
 		t = time.Now()
 		elapsed = t.Sub(start).Seconds()
 		rps = int(float64(sent) / elapsed)
 
-		if rps > mRps {
+		if rps >= mRps {
 			runtime.Gosched()
 			continue
 		}