141 lines
3.0 KiB
Go
141 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
//"encoding/base64"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
|
|
//"strings"
|
|
"time"
|
|
|
|
"github.com/google/gopacket"
|
|
"github.com/google/gopacket/pcap"
|
|
)
|
|
|
|
type SaprusHeaderPacket struct {
|
|
Type uint16
|
|
Length uint16
|
|
}
|
|
|
|
type SaprusFileTransfer struct {
|
|
Header SaprusHeaderPacket
|
|
Flag uint8
|
|
Sequence uint16
|
|
Checksum uint16
|
|
Payload []byte
|
|
}
|
|
|
|
func errCheck(err error) {
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return
|
|
}
|
|
|
|
func createSaprusFileTransferPacket(payload []byte) SaprusFileTransfer {
|
|
var packet SaprusFileTransfer
|
|
|
|
packet.Header.Type = binary.BigEndian.Uint16([]byte{payload[0], payload[1]})
|
|
packet.Header.Length = binary.BigEndian.Uint16([]byte{payload[2], payload[3]})
|
|
|
|
packet.Flag = uint8(payload[4])
|
|
packet.Sequence = binary.BigEndian.Uint16([]byte{payload[5], payload[6]})
|
|
packet.Checksum = binary.BigEndian.Uint16([]byte{payload[7], payload[8]})
|
|
|
|
for i := uint16(0); i < packet.Header.Length - 5; i++ {
|
|
packet.Payload = append(packet.Payload, payload[i+9])
|
|
}
|
|
|
|
return packet
|
|
}
|
|
|
|
func listenDiscoverResponse(addrChan chan string, readyFlag chan int) {
|
|
finalMessage := ""
|
|
var pkt_data SaprusFileTransfer
|
|
handle, err := pcap.OpenLive("any", int32(1600), true, pcap.BlockForever)
|
|
errCheck(err)
|
|
|
|
err = handle.SetBPFFilter("udp and port 6767")
|
|
errCheck(err)
|
|
|
|
packets := gopacket.NewPacketSource(handle, handle.LinkType()).Packets()
|
|
|
|
readyFlag <- 1
|
|
|
|
for pkt := range packets {
|
|
pkt_data = createSaprusFileTransferPacket(pkt.ApplicationLayer().Payload())
|
|
finalMessage += string(pkt_data.Payload)
|
|
if pkt_data.Flag == 2 {
|
|
addrChan <- finalMessage
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func toMaxHost(n *net.IPNet) (net.IP, error) {
|
|
if n.IP.To4() == nil {
|
|
return net.IP{}, errors.New("IP address is not IPv4")
|
|
}
|
|
|
|
ip := make(net.IP, len(n.IP.To4()))
|
|
binary.BigEndian.PutUint32(ip,
|
|
binary.BigEndian.Uint32(n.IP.To4())|^binary.BigEndian.Uint32(net.IP(n.Mask).To4()))
|
|
|
|
return ip, nil
|
|
}
|
|
|
|
func bcastAddresses() []string {
|
|
var addrs []string = nil
|
|
interfaceInfo, _ := net.Interfaces()
|
|
for i := 0; i < len(interfaceInfo); i++ {
|
|
addr, err := interfaceInfo[i].Addrs()
|
|
errCheck(err)
|
|
for j := 0; j < len(addr); j++ {
|
|
_, ipNet, _ := net.ParseCIDR(addr[j].String())
|
|
bcast, err := toMaxHost(ipNet)
|
|
|
|
if err != nil {
|
|
} else {
|
|
addrs = append(addrs, bcast.String())
|
|
}
|
|
}
|
|
}
|
|
|
|
return addrs
|
|
}
|
|
|
|
func main() {
|
|
sendAddrs := bcastAddresses()
|
|
|
|
addrChan := make(chan string)
|
|
readyFlag := make(chan int)
|
|
|
|
go listenDiscoverResponse(addrChan, readyFlag)
|
|
|
|
// Wait for device to listen
|
|
<- readyFlag
|
|
|
|
for i := 0; i < len(sendAddrs); i++ {
|
|
remoteAddr := sendAddrs[i] + ":8888"
|
|
remote, err := net.ResolveUDPAddr("udp4", remoteAddr)
|
|
errCheck(err)
|
|
conn, err := net.DialUDP("udp4", nil, remote)
|
|
errCheck(err)
|
|
defer conn.Close()
|
|
|
|
_, err = conn.Write([]byte(conn.LocalAddr().String() + "here"))
|
|
errCheck(err)
|
|
}
|
|
|
|
// Listen timeout
|
|
select {
|
|
case returnMSG := <- addrChan:
|
|
fmt.Printf("%s\n", returnMSG)
|
|
case <- time.After(60 * time.Second):
|
|
fmt.Printf("error\n")
|
|
}
|
|
}
|