justin/netgiv
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases 6 Wiki Activity

Cleanup logging

Browse Source
This commit is contained in:
Justin Hawkins 2022-01-16 20:35:35 +10:30
parent d8672139f5
commit 739aca19e7
5 changed files with 43 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.vscode/settings.json vendored
View File

@ -1,5 +1,7 @@
{ {
"cSpell.words": [ "cSpell.words": [
"Debugf",
"Infof",
"isatty", "isatty",
"netgiv", "netgiv",
"pflag" "pflag"

25
client.go
View File

@ -32,19 +32,12 @@ func (c *Client) Connect() error {
d := net.Dialer{Timeout: 5 * time.Second} d := net.Dialer{Timeout: 5 * time.Second}
conn, err := d.Dial("tcp", address) conn, err := d.Dial("tcp", address)
// serverAddress, err := net.ResolveTCPAddr("tcp", address)
// if err != nil {
// return err
// }
// conn, err := d.Dial("tcp", serverAddress)
if err != nil { if err != nil {
return fmt.Errorf("problem connecting to server, is it running?: %v", err) return fmt.Errorf("problem connecting to server, is it running?: %v", err)
} }
defer conn.Close() defer conn.Close()
log.Printf("Connection on %s\n", address) log.Debugf("established connection on %s", address)
tcpConn, ok := conn.(*net.TCPConn) tcpConn, ok := conn.(*net.TCPConn)
if !ok { if !ok {
@ -58,7 +51,7 @@ func (c *Client) Connect() error {
dec := gob.NewDecoder(&secureConnection) dec := gob.NewDecoder(&secureConnection)
if c.list { if c.list {
log.Printf("requesting file list") log.Debugf("requesting file list")
err := c.connectToServer(secure.OperationTypeList, enc, dec) err := c.connectToServer(secure.OperationTypeList, enc, dec)
if err != nil { if err != nil {
@ -75,13 +68,13 @@ func (c *Client) Connect() error {
if err != nil { if err != nil {
panic(err) panic(err)
} }
log.Printf("%d: %s (%s)", listPacket.Id, listPacket.Kind, humanize.Bytes(uint64(listPacket.FileSize))) fmt.Printf("%d: %s (%s)\n", listPacket.Id, listPacket.Kind, humanize.Bytes(uint64(listPacket.FileSize)))
} }
conn.Close() conn.Close()
log.Printf("done listing") log.Debugf("done listing")
} else if c.receive { } else if c.receive {
log.Printf("receiving a file") log.Debugf("receiving a file")
err := c.connectToServer(secure.OperationTypeReceive, enc, dec) err := c.connectToServer(secure.OperationTypeReceive, enc, dec)
if err != nil { if err != nil {
@ -114,9 +107,9 @@ func (c *Client) Connect() error {
break break
} }
} }
log.Printf("finished") log.Debugf("finished")
} else if res.Status == secure.ReceiveDataStartResponseNotFound { } else if res.Status == secure.ReceiveDataStartResponseNotFound {
log.Printf("ngf not found") log.Error("ngf not found")
} else { } else {
panic("unknown status") panic("unknown status")
} }
@ -164,13 +157,13 @@ func (c *Client) Connect() error {
Size: 5000, Size: 5000,
Data: buf, Data: buf,
} }
enc.Encode(send) err = enc.Encode(send)
// time.Sleep(time.Second) // time.Sleep(time.Second)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
} }
log.Println("Bytes:", nBytes, "Chunks:", nChunks) log.Debugf("Sent %s in %d chunks", humanize.Bytes(uint64(nBytes)), nChunks)
conn.Close() conn.Close()

8
main.go
View File

@ -13,15 +13,13 @@ import (
) )
func main() { func main() {
// log.SetFlags(log.Lshortfile)
// flag.Int("port", 4912, "Port to run server/client on.")
// addr := flag.String("a", "127.0.0.1", "address to connect to.")
isServer := flag.Bool("s", false, "Run netgiv in server mode") isServer := flag.Bool("s", false, "Run netgiv in server mode")
// client mode flags // client mode flags
isList := flag.Bool("l", false, "Set if requesting a list") isList := flag.Bool("l", false, "Set if requesting a list")
isSend := flag.Bool("c", false, "sending stdin to netgiv server (copy)") isSend := flag.Bool("c", false, "sending stdin to netgiv server (copy)")
isReceive := flag.Bool("p", false, "receive file from netgiv server to stdout (paste)") isReceive := flag.Bool("p", false, "receive file from netgiv server to stdout (paste)")
debug := flag.Bool("debug", false, "turn on debug logging")
flag.String("address", "", "IP address/hostname of the netgiv server") flag.String("address", "", "IP address/hostname of the netgiv server")
helpConfig := flag.Bool("help-config", false, "Show help on netgiv configuration") helpConfig := flag.Bool("help-config", false, "Show help on netgiv configuration")
@ -102,6 +100,10 @@ environment variable. This may be preferable in some environments.
} }
if *debug {
log.SetLevel(log.DebugLevel)
}
if *isServer { if *isServer {
s := Server{port: port, authToken: authtoken} s := Server{port: port, authToken: authtoken}
s.Run() s.Run()

35
secure/secure.go
View File

@ -6,9 +6,10 @@ import (
"encoding/binary" "encoding/binary"
"errors" "errors"
"io" "io"
"log"
"net" "net"
log "github.com/sirupsen/logrus"
"golang.org/x/crypto/nacl/box" "golang.org/x/crypto/nacl/box"
) )
@ -62,32 +63,16 @@ func (s *SecureConnection) Read(p []byte) (int, error) {
outputBytes := make([]byte, 0) outputBytes := make([]byte, 0)
// log.Printf("READ: start, p %d/%d, buffer contains currently contains %d bytes", len(p), cap(p), s.Buffer.Len())
n, err := s.Conn.Read(message) n, err := s.Conn.Read(message)
if err != nil && err != io.EOF { if err != nil && err != io.EOF {
log.Printf("read: error in connection read %v", err) log.Errorf("read: error in connection read %v", err)
return 0, err return 0, err
} }
if err == io.EOF { if err == io.EOF {
eof = true eof = true
} }
// if n == 0 && bytes.Buffer.{
// return 0, io.EOF
// }
// log.Printf("read: got %d bytes on the wire, error is %v", n, err)
// log.Printf("looks like %v", message[:n])
// if eof {
// log.Printf("eof is true - this is our final read!")
// }
// log.Printf("writing n=%d", n)
// log.Printf("writing buffersize=%v", s.Buffer)
// log.Printf("writing n=%d buffersize=%d this: %v", n, s.Buffer.Len(), s.Buffer.Bytes()[:n])
s.Buffer.Write(message[:n]) s.Buffer.Write(message[:n])
// log.Printf("read: appended them to the buffer which is now %d bytes", len(s.Buffer.Bytes()))
for { for {
@ -104,11 +89,11 @@ func (s *SecureConnection) Read(p []byte) (int, error) {
encryptedBytes := make([]byte, actualPacketEnd) encryptedBytes := make([]byte, actualPacketEnd)
n, err := s.Buffer.Read(encryptedBytes) n, err := s.Buffer.Read(encryptedBytes)
if err != nil && err != io.EOF { if err != nil && err != io.EOF {
log.Printf("failed to get encrypted bytes from buffer?") log.Errorf("failed to get encrypted bytes from buffer?")
return 0, errors.New("failed to get encrypted bytes from buffer") return 0, errors.New("failed to get encrypted bytes from buffer")
} }
if n != int(actualPacketEnd) { if n != int(actualPacketEnd) {
log.Printf("failed to get right number of encrypted bytes from buffer") log.Errorf("failed to get right number of encrypted bytes from buffer")
return 0, errors.New("failed to get right number of encrypted bytes from buffer") return 0, errors.New("failed to get right number of encrypted bytes from buffer")
} }
@ -123,7 +108,7 @@ func (s *SecureConnection) Read(p []byte) (int, error) {
outputBytes = append(outputBytes, decryptedMessage...) outputBytes = append(outputBytes, decryptedMessage...)
if eof && s.Buffer.Len() == 0 { if eof && s.Buffer.Len() == 0 {
log.Printf("returning the final packet") log.Debugf("returning the final packet")
break break
} }
@ -136,25 +121,21 @@ func (s *SecureConnection) Read(p []byte) (int, error) {
copy(p, outputBytes) copy(p, outputBytes)
// log.Printf("returning %d decrypted bytes with err: %w", len(outputBytes), err)
// log.Printf("READ: end, p %d/%d, buffer contains currently contains %d bytes", len(p), cap(p), s.Buffer.Len())
return len(outputBytes), err return len(outputBytes), err
} }
func (s *SecureConnection) Write(p []byte) (int, error) { func (s *SecureConnection) Write(p []byte) (int, error) {
// func (s *SecureConnection) Write(o encoding.BinaryMarshaler) (int, error) {
var nonce [24]byte var nonce [24]byte
// Create a new nonce for each message sent // Create a new nonce for each message sent
rand.Read(nonce[:]) rand.Read(nonce[:])
// log.Printf("before encryption it is %d bytes", len(p))
encryptedMessage := box.SealAfterPrecomputation(nil, p, &nonce, s.SharedKey) encryptedMessage := box.SealAfterPrecomputation(nil, p, &nonce, s.SharedKey)
sm := SecureMessage{Msg: encryptedMessage, Nonce: nonce} sm := SecureMessage{Msg: encryptedMessage, Nonce: nonce}
// Write it to the connection // Write it to the connection
wireBytes := sm.toByteArray() wireBytes := sm.toByteArray()
// log.Printf("putting %d bytes on the wire\n nonce: %v\n bytes: %v", len(wireBytes), nonce, wireBytes)
return s.Conn.Write(wireBytes) return s.Conn.Write(wireBytes)
} }

37
server.go
View File

@ -38,6 +38,7 @@ var ngfs []NGF
var globalId uint32 var globalId uint32
func (s *Server) Run() { func (s *Server) Run() {
log.Debugf("starting server on :%d", s.port)
address := fmt.Sprintf(":%d", s.port) address := fmt.Sprintf(":%d", s.port)
networkAddress, _ := net.ResolveTCPAddr("tcp", address) networkAddress, _ := net.ResolveTCPAddr("tcp", address)
@ -95,12 +96,12 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
err := dec.Decode(&start) err := dec.Decode(&start)
if err == io.EOF { if err == io.EOF {
log.Printf("connection has been closed prematurely") log.Errorf("connection has been closed prematurely")
return return
} }
if err != nil { if err != nil {
log.Printf("error while expecting PacketStart: %v", err) log.Errorf("error while expecting PacketStart: %v", err)
return return
} }
@ -108,14 +109,14 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
startResponse := secure.PacketStartResponse{} startResponse := secure.PacketStartResponse{}
if start.ProtocolVersion != "1.0" { if start.ProtocolVersion != "1.0" {
log.Printf("bad protocol version") log.Errorf("bad protocol version")
startResponse.Response = secure.PacketStartResponseEnumWrongProtocol startResponse.Response = secure.PacketStartResponseEnumWrongProtocol
enc.Encode(startResponse) enc.Encode(startResponse)
return return
} }
if start.AuthToken != s.authToken { if start.AuthToken != s.authToken {
log.Print("bad authtoken") log.Errorf("bad authtoken")
startResponse.Response = secure.PacketStartResponseEnumBadAuthToken startResponse.Response = secure.PacketStartResponseEnumBadAuthToken
enc.Encode(startResponse) enc.Encode(startResponse)
return return
@ -128,13 +129,13 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
conn.SetDeadline(time.Now().Add(time.Second * 5)) conn.SetDeadline(time.Now().Add(time.Second * 5))
if start.OperationType == secure.OperationTypeSend { if start.OperationType == secure.OperationTypeSend {
log.Printf("file incoming") log.Debugf("file incoming")
sendStart := secure.PacketSendDataStart{} sendStart := secure.PacketSendDataStart{}
err = dec.Decode(&sendStart) err = dec.Decode(&sendStart)
if err != nil { if err != nil {
log.Printf("error - expecting PacketSendDataStart: %v", err) log.Errorf("error - expecting PacketSendDataStart: %v", err)
return return
} }
file, err := os.CreateTemp("", "netgiv_") file, err := os.CreateTemp("", "netgiv_")
@ -153,7 +154,7 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
} }
if err != nil { if err != nil {
log.Printf("got error with temp file: %v", err) log.Errorf("got error with temp file: %v", err)
return return
} }
sendData := secure.PacketSendDataNext{} sendData := secure.PacketSendDataNext{}
@ -165,7 +166,7 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
break break
} }
if err != nil { if err != nil {
log.Printf("error while expecting PacketSendDataNext: %s", err) log.Errorf("error while expecting PacketSendDataNext: %s", err)
return return
} }
@ -193,7 +194,7 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
} }
info, err := file.Stat() info, err := file.Stat()
if err != nil { if err != nil {
log.Printf("couldn't stat file %s", err) log.Errorf("couldn't stat file %s", err)
return return
} }
ngf.Size = uint64(info.Size()) ngf.Size = uint64(info.Size())
@ -233,7 +234,7 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
if requestedNGF == nil { if requestedNGF == nil {
// not found // not found
log.Printf("user requested %d, not found", req.Id) log.Errorf("user requested %d, not found", req.Id)
res := secure.PacketReceiveDataStartResponse{ res := secure.PacketReceiveDataStartResponse{
Status: secure.ReceiveDataStartResponseNotFound, Status: secure.ReceiveDataStartResponseNotFound,
} }
@ -253,16 +254,16 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
} }
err = enc.Encode(res) err = enc.Encode(res)
if err != nil { if err != nil {
log.Printf("error sending PacketReceiveDataStartResponse: %v", err) log.Errorf("error sending PacketReceiveDataStartResponse: %v", err)
return return
} }
// now just start sending the file in batches // now just start sending the file in batches
buf := make([]byte, 2048) buf := make([]byte, 2048)
filename := requestedNGF.StorePath filename := requestedNGF.StorePath
log.Printf("opening %s", filename) log.Debugf("opening %s", filename)
f, err := os.Open(filename) f, err := os.Open(filename)
if err != nil { if err != nil {
log.Printf("could not find file %s: %v", filename, err) log.Errorf("could not find file %s: %v", filename, err)
return return
} }
@ -271,7 +272,7 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
eof := false eof := false
if err != nil && err != io.EOF { if err != nil && err != io.EOF {
log.Printf("error reading data: %v", err) log.Errorf("error reading data: %v", err)
break break
} }
if err == io.EOF { if err == io.EOF {
@ -285,7 +286,7 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
} }
err = enc.Encode(chunk) err = enc.Encode(chunk)
if err != nil { if err != nil {
log.Printf("error sending chunk: %v", err) log.Errorf("error sending chunk: %v", err)
} }
if eof { if eof {
@ -296,7 +297,7 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
return return
} else if start.OperationType == secure.OperationTypeList { } else if start.OperationType == secure.OperationTypeList {
log.Printf("client requesting file list") log.Debugf("client requesting file list")
for _, ngf := range ngfs { for _, ngf := range ngfs {
p := secure.PacketListData{} p := secure.PacketListData{}
@ -306,12 +307,12 @@ func (s *Server) handleConnection(conn *net.TCPConn) {
p.Filename = ngf.Filename p.Filename = ngf.Filename
enc.Encode(p) enc.Encode(p)
} }
log.Printf("done sending list, closing connection") log.Debugf("done sending list, closing connection")
return return
} else { } else {
log.Printf("bad operation") log.Errorf("bad operation")
return return
} }