Hochwasser/main.go

149 lines
3.3 KiB
Go
Raw Normal View History

2019-01-06 22:00:43 +01:00
package main
import (
"flag"
2019-01-11 17:29:00 +01:00
"fmt"
"image"
_ "image/gif"
_ "image/jpeg"
_ "image/png"
"log"
2019-01-11 18:27:29 +01:00
"math/rand"
2019-01-06 22:00:43 +01:00
"net"
2019-01-11 17:29:00 +01:00
_ "net/http/pprof"
"os"
2019-01-06 22:00:43 +01:00
"runtime/pprof"
2019-01-11 17:29:00 +01:00
"strconv"
2019-01-06 22:00:43 +01:00
"time"
)
var err error
var cpuprofile = flag.String("cpuprofile", "", "Destination file for CPU Profile")
2019-01-11 17:31:14 +01:00
var image_path = flag.String("image", "", "Absolute Path to image")
2019-01-06 22:00:43 +01:00
var image_offsetx = flag.Int("xoffset", 0, "Offset of posted image from left border")
var image_offsety = flag.Int("yoffset", 0, "Offset of posted image from top border")
var connections = flag.Int("connections", 4, "Number of simultaneous connections. Each connection posts a subimage")
2019-01-06 22:00:43 +01:00
var address = flag.String("host", "127.0.0.1:1337", "Server address")
var runtime = flag.String("runtime", "1", "Runtime in Minutes")
2019-01-11 18:27:29 +01:00
var shuffle = flag.Bool("shuffle", false, "pixel send ordering")
2019-01-06 22:00:43 +01:00
func main() {
flag.Parse()
2019-01-11 17:31:14 +01:00
if *image_path == "" {
log.Fatal("No image provided")
2019-01-06 22:00:43 +01:00
}
2019-01-11 17:22:51 +01:00
// check connectivity by opening one test connection
conn, err := net.Dial("tcp", *address)
if err != nil {
log.Fatal(err)
}
conn.Close()
2019-01-06 22:00:43 +01:00
// Start cpu profiling if wanted
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
2019-01-11 17:31:14 +01:00
2019-01-06 22:00:43 +01:00
// Generate and split messages into equal chunks
2019-01-11 17:31:14 +01:00
commands := genCommands(readImage(*image_path), *image_offsetx, *image_offsety)
2019-01-11 18:27:29 +01:00
if *shuffle {
shuffleCommands(commands)
}
2019-01-11 17:31:14 +01:00
commandGroups := chunkCommands(commands, *connections)
for _, messages := range commandGroups {
go bomb(messages)
2019-01-06 22:00:43 +01:00
}
// Terminate after 1 Minute to save resources
timer, err := time.ParseDuration(*runtime + "m")
if err != nil {
log.Fatal("Invalid runtime specified: " + err.Error())
}
time.Sleep(time.Minute * timer)
}
func bomb(messages []byte) {
2019-01-06 22:00:43 +01:00
conn, err := net.Dial("tcp", *address)
if err != nil {
2019-01-11 17:22:51 +01:00
log.Fatal(err)
2019-01-06 22:00:43 +01:00
}
2019-01-11 17:31:14 +01:00
2019-01-06 22:00:43 +01:00
defer conn.Close()
// Start bombardement
for {
_, err := conn.Write(messages)
if err != nil {
log.Fatal(err)
2019-01-06 22:00:43 +01:00
}
}
}
2019-01-11 17:31:14 +01:00
func readImage(path string) (img image.Image) {
reader, err := os.Open(path)
2019-01-06 22:00:43 +01:00
if err != nil {
log.Fatal(err)
}
2019-01-11 17:31:14 +01:00
img, _, err2 := image.Decode(reader)
2019-01-06 22:00:43 +01:00
if err2 != nil {
log.Fatal(err2)
}
2019-01-11 17:31:14 +01:00
return img
}
2019-01-06 22:00:43 +01:00
2019-01-11 17:31:14 +01:00
func intToHex(x uint32) string {
str := strconv.FormatInt(int64(x), 16)
if len(str) == 1 {
str = "0" + str
}
return str[0:2]
}
2019-01-06 22:00:43 +01:00
2019-01-11 17:31:14 +01:00
// Creates message based on given image
func genCommands(img image.Image, offset_x, offset_y int) (commands [][]byte) {
max_x := img.Bounds().Max.X
max_y := img.Bounds().Max.Y
commands = make([][]byte, max_x*max_y)
for x := 0; x < max_x; x++ {
for y := 0; y < max_y; y++ {
r, g, b, _ := img.At(x, y).RGBA()
colStr := intToHex(r) + intToHex(g) + intToHex(b)
cmd := fmt.Sprintf("PX %d %d %s\n", x+offset_x, y+offset_y, colStr)
commands[x*max_y+y] = []byte(cmd)
2019-01-06 22:00:43 +01:00
}
}
2019-01-11 17:31:14 +01:00
return commands
2019-01-06 22:00:43 +01:00
}
2019-01-11 17:31:14 +01:00
// Splits messages into equally sized chunks
func chunkCommands(commands [][]byte, numChunks int) [][]byte {
chunks := make([][]byte, numChunks)
2019-01-06 22:00:43 +01:00
2019-01-11 17:31:14 +01:00
chunkLength := len(commands) / numChunks
for i := 0; i < numChunks; i++ {
cmdOffset := i * chunkLength
for j := 0; j < chunkLength; j++ {
chunks[i] = append(chunks[i], commands[cmdOffset+j]...)
2019-01-06 22:00:43 +01:00
}
}
2019-01-11 17:31:14 +01:00
return chunks
2019-01-06 22:00:43 +01:00
}
2019-01-11 18:27:29 +01:00
func shuffleCommands(slice [][]byte) {
for i := range slice {
j := rand.Intn(i + 1)
slice[i], slice[j] = slice[j], slice[i]
}
}