package main

import (
        "encoding/json"
        "flag"
        "fmt"
        "log"
        "net"

        "github.com/mikioh/tcp"
        "github.com/mikioh/tcpinfo"
)

func handleConnection(conn net.Conn, monitor bool) {
        fmt.Println("new connection:", conn.RemoteAddr())
        tc, err := tcp.NewConn(conn)
        if err != nil {
                conn.Close()
                log.Printf("tcp.NewConn failed:", err)
                return
        }

        var o tcpinfo.Info
        var b [256]byte
        for {
                i, err := tc.Option(o.Level(), o.Name(), b[:])
                if err != nil {
                        log.Println(err)
                        return
                }
                txt, err := json.Marshal(i)
                if err != nil {
                        log.Println(err)
                        return
                }
                fmt.Println(string(txt))
                if !monitor {
                        break
                }
        }
}

func main() {
        listen := flag.String("listen", ":8081", "listen adddress")
        monitor := flag.Bool("monitor", false, "monitor options")
        flag.Parse()

        ln, err := net.Listen("tcp", *listen)
        if err != nil {
                log.Printf("listen failed: %s", err)
                return
        }

        log.Println("listen:", *listen)
        for {
                conn, err := ln.Accept()
                if err != nil {
                        // handle error
                        log.Println("accept failed:", err)
                        break
                }
                go handleConnection(conn, *monitor)
        }
}