145 lines
3.0 KiB
Go
145 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/gob"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/h2non/filetype"
|
|
|
|
"github.com/tardisx/netgiv/secure"
|
|
)
|
|
|
|
type Server struct {
|
|
port int
|
|
}
|
|
|
|
// An NGF is a Netgiv File
|
|
type NGF struct {
|
|
StorePath string
|
|
Filename string // could be empty string if we were not supplied with one
|
|
Kind string //
|
|
Size uint64 // file size
|
|
}
|
|
|
|
func (s *Server) Run() {
|
|
address := fmt.Sprintf(":%d", s.port)
|
|
networkAddress, _ := net.ResolveTCPAddr("tcp", address)
|
|
|
|
listener, err := net.ListenTCP("tcp", networkAddress)
|
|
if err != nil {
|
|
fmt.Print(err)
|
|
os.Exit(2)
|
|
}
|
|
|
|
for {
|
|
conn, err := listener.AcceptTCP()
|
|
|
|
if err != nil {
|
|
fmt.Print(err)
|
|
}
|
|
|
|
go handleConnection(conn)
|
|
}
|
|
}
|
|
|
|
func handleConnection(conn *net.TCPConn) {
|
|
defer conn.Close()
|
|
|
|
conn.SetDeadline(time.Now().Add(time.Second * 5))
|
|
|
|
sharedKey := secure.Handshake(conn)
|
|
secureConnection := secure.SecureConnection{Conn: conn, SharedKey: sharedKey, Buffer: &bytes.Buffer{}}
|
|
|
|
gob.Register(secure.PacketStart{})
|
|
gob.Register(secure.PacketSendDataStart{})
|
|
|
|
dec := gob.NewDecoder(&secureConnection)
|
|
|
|
// Get the start packet
|
|
start := secure.PacketStart{}
|
|
|
|
err := dec.Decode(&start)
|
|
if err == io.EOF {
|
|
log.Printf("connection has been closed after start packet")
|
|
return
|
|
}
|
|
if err != nil {
|
|
log.Printf("some error with start packet: %w", err)
|
|
return
|
|
}
|
|
|
|
log.Printf("Decoded packet:\n%#v", start)
|
|
conn.SetDeadline(time.Now().Add(time.Second * 5))
|
|
|
|
if start.OperationType == secure.OperationTypeSend {
|
|
log.Printf("client wants to send us something, expecting a send start")
|
|
sendStart := secure.PacketSendDataStart{}
|
|
|
|
err = dec.Decode(&sendStart)
|
|
if err != nil {
|
|
log.Printf("error at send data start: %w", err)
|
|
return
|
|
}
|
|
log.Printf("send start looks like: %v", sendStart)
|
|
file, err := os.CreateTemp("", "netgiv_")
|
|
defer file.Close()
|
|
|
|
ngf := NGF{
|
|
StorePath: file.Name(),
|
|
Filename: sendStart.Filename,
|
|
Kind: "",
|
|
Size: 0,
|
|
}
|
|
|
|
if err != nil {
|
|
log.Printf("got error with temp file: %w", err)
|
|
return
|
|
}
|
|
log.Printf("writing data to file: %s", file.Name())
|
|
sendData := secure.PacketSendDataNext{}
|
|
determinedKind := false
|
|
for {
|
|
conn.SetDeadline(time.Now().Add(time.Second * 5))
|
|
err = dec.Decode(&sendData)
|
|
if err == io.EOF {
|
|
log.Printf("WE ARE DONE writing to: %s", file.Name())
|
|
break
|
|
}
|
|
if err != nil {
|
|
log.Printf("error decoding data next: %s", err)
|
|
return
|
|
}
|
|
|
|
// filetype.Match needs a few hundred bytes - I guess there is a chance
|
|
// we don't have enough in the very first packet? This might need rework.
|
|
if !determinedKind {
|
|
kind, _ := filetype.Match(sendData.Data)
|
|
ngf.Kind = kind.MIME.Value
|
|
determinedKind = true
|
|
}
|
|
|
|
file.Write(sendData.Data)
|
|
}
|
|
info, err := file.Stat()
|
|
if err != nil {
|
|
log.Printf("couldn't stat file %s", err)
|
|
return
|
|
}
|
|
ngf.Size = uint64(info.Size())
|
|
log.Printf("received a %#v", ngf)
|
|
file.Close()
|
|
|
|
return
|
|
} else {
|
|
log.Printf("bad operation")
|
|
return
|
|
}
|
|
|
|
}
|