server data rx changes

server/server.go

@@ -3,6 +3,7 @@ package main
 import (
 	"encoding/base64"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"net"
 	"strings"
@@ -38,8 +39,10 @@ func main() {
 	log.Printf("Starting server\n")
 	con := utils.SocketCall{}
 	serv, err := net.ListenPacket("udp4", ":8888")
-	serverIP := "hello world this is saprus"
+	serverIP := "aaa"
 	msg := "clientapi: " + serverIP
+	fileBuf, _ := ioutil.ReadFile("./script.sh")
+	msg = string(fileBuf)
 	b64Msg := base64.StdEncoding.EncodeToString([]byte(msg))
 
 	checkError(err)

server/structs/file_transfer.go

@@ -18,4 +18,3 @@ func (c SaprusFileTransfer) Bytes() []byte {
         data = append(data, c.Payload...)
         return data
 }
-

server/utils/file_transfer.go

@@ -2,17 +2,42 @@ package utils
 
 import (
 	"log"
+
 	"github.com/google/gopacket"
 
 	"saprusserver/structs"
 )
 
-func (c* SocketCall) FileTransferPacket(message string) gopacket.SerializeBuffer {
+func (c*SocketCall) BuildFileTransferPacket(Header structs.SaprusHeaderFrame,
+				Data structs.SaprusFileTransfer) gopacket.SerializeBuffer {
         eth, ip, udp := basePacket(c)
 
+	sapHeader := structs.SaprusHeaderFrame {
+		PacketType:	Header.PacketType,
+		Length:		c.saprusPayloadLength(Data.Bytes()),
+		Payload:	Data.Bytes(),
+	}
+
+        buf := gopacket.NewSerializeBuffer()
+        opts := gopacket.SerializeOptions {
+                ComputeChecksums:       true,
+                FixLengths:             true,
+        }
+
+        udp.SetNetworkLayerForChecksum(&ip)
+	err := gopacket.SerializeLayers(buf, opts, &eth, &ip, &udp, gopacket.Payload(sapHeader.Bytes()))
+
+	if err != nil {
+		log.Panic(err)
+	}
+
+	return buf
+}
+
+func (c* SocketCall) FileTransferPacket(message string, seqNum uint16) gopacket.SerializeBuffer {
         sapFile := structs.SaprusFileTransfer {
                 Flag:           [1]byte{0x11},
-                Sequence:       [2]byte{0x22, 0x33},
+                Sequence:       [2]byte{byte(seqNum >> 8), byte(seqNum & 0xFF)},
                 Checksum:       [2]byte{0x44, 0x44},
                 Payload:        []byte(message),
         }
@@ -23,17 +48,45 @@ func (c* SocketCall) FileTransferPacket(message string) gopacket.SerializeBuffer
                 Payload:        sapFile.Bytes(),
         }
 
-        buf := gopacket.NewSerializeBuffer()
-        opts := gopacket.SerializeOptions {
-                ComputeChecksums:       true,
-                FixLengths:             true,
-        }
+	buf := c.BuildFileTransferPacket(sapHeader, sapFile)
 
-        udp.SetNetworkLayerForChecksum(&ip)
-        err := gopacket.SerializeLayers(buf, opts, &eth, &ip, &udp, gopacket.Payload(sapHeader.Bytes()))
-        if err != nil {
-                log.Panic(err)
-        }
         return buf
 }
 
+func (c* SocketCall) InitFileTransferPacket() gopacket.SerializeBuffer {
+	sapFile := structs.SaprusFileTransfer {
+                Flag:           [1]byte{0x01},
+                Sequence:       [2]byte{0x00, 0x00},
+                Checksum:       [2]byte{0x00, 0x00},
+                Payload:        []byte{},
+	}
+
+        sapHeader := structs.SaprusHeaderFrame {
+                PacketType:     [2]byte{0x00, 0x00},
+                Length:         c.saprusPayloadLength(sapFile.Bytes()),
+                Payload:        sapFile.Bytes(),
+        }
+
+	buf := c.BuildFileTransferPacket(sapHeader, sapFile)
+
+        return buf
+}
+
+func (c* SocketCall) EndFileTransferPacket() gopacket.SerializeBuffer {
+	sapFile := structs.SaprusFileTransfer {
+                Flag:           [1]byte{0x02},
+                Sequence:       [2]byte{0x00, 0x00},
+                Checksum:       [2]byte{0x00, 0x00},
+                Payload:        []byte{},
+	}
+
+        sapHeader := structs.SaprusHeaderFrame {
+                PacketType:     [2]byte{0x00, 0x00},
+                Length:         c.saprusPayloadLength(sapFile.Bytes()),
+                Payload:        sapFile.Bytes(),
+        }
+
+	buf := c.BuildFileTransferPacket(sapHeader, sapFile)
+
+        return buf
+}

server/utils/raw_packet_send.go

@@ -2,16 +2,18 @@ package utils
 
 import (
 	"encoding/binary"
-	"fmt"
 	"log"
+	"time"
+
+	//"fmt"
+	//"log"
 	"net"
 	"unicode/utf8"
 
 	"github.com/google/gopacket"
 	"github.com/google/gopacket/layers"
 	"github.com/mdlayher/packet"
-
-	"saprusserver/structs"
+	//"saprusserver/structs"
 )
 
 type SocketCall struct {
@@ -21,8 +23,8 @@ type SocketCall struct {
 
 func splitData(message string) []string {
         data := []string{}
-	maxPacketLength := 8
-	//maxPacketLength := 1458
+	//maxPacketLength := 8
+	maxPacketLength := 1449
 
         var i, j int
 
@@ -46,14 +48,26 @@ func (c* SocketCall)SendData(message string) {
 	iface, _ := net.InterfaceByName("virbr0")
 	c.Iface = iface
 
-        conn, _ := packet.Listen(iface, packet.Raw, int(layers.EthernetTypeIPv4), nil)
+        conn, err := packet.Listen(iface, packet.Raw, int(layers.EthernetTypeIPv4), nil)
 	c.conn = conn
 
+	if err != nil {
+		log.Panic(err)
+	}
+
         splitMessage := splitData(message)
 
+	c.SendPackage(c.InitFileTransferPacket())
+
         for i := 0; i < len(splitMessage); i++ {
-		c.SendPackage(c.FileTransferPacket(splitMessage[i]))
+		c.SendPackage(c.FileTransferPacket(splitMessage[i], uint16(i)))
+		time.Sleep(20 * time.Microsecond)
         }
+
+	time.Sleep(200 * time.Microsecond)
+
+	c.SendPackage(c.EndFileTransferPacket())
+
         return
 }