uuuuuuuuuuuuuuuuuuuuuuuuuuuuugh"
Change-Id: I5567ec3b708a28f35e807407afdaec0795f9a77e
diff --git a/examples/secure-tcp/client/.client.go.swp b/examples/secure-tcp/client/.client.go.swp
index 1fd0ba4..3fb46c7 100644
--- a/examples/secure-tcp/client/.client.go.swp
+++ b/examples/secure-tcp/client/.client.go.swp
Binary files differ
diff --git a/examples/secure-tcp/client/client.go b/examples/secure-tcp/client/client.go
index 4fb6f99..9ef9d98 100644
--- a/examples/secure-tcp/client/client.go
+++ b/examples/secure-tcp/client/client.go
@@ -29,4 +29,10 @@
fmt.Fprintf(conn, "Hello.")
status, err := bufio.NewReader(conn).ReadString('\n')
log.Printf("Client received: %s\n", status)
+
+ time.Sleep(5 * time.Second)
+
+ fmt.Fprintf(conn, "World.")
+ status, err = bufio.NewReader(conn).ReadString('\n')
+ log.Printf("Client received: %s\n", status)
}
diff --git a/examples/secure-tcp/server/.server.go.swp b/examples/secure-tcp/server/.server.go.swp
index 12e89fb..bfec12f 100644
--- a/examples/secure-tcp/server/.server.go.swp
+++ b/examples/secure-tcp/server/.server.go.swp
Binary files differ
diff --git a/examples/secure-tcp/server/server.go b/examples/secure-tcp/server/server.go
index db23317..3989888 100644
--- a/examples/secure-tcp/server/server.go
+++ b/examples/secure-tcp/server/server.go
@@ -33,5 +33,9 @@
status, err := bufio.NewReader(conn).ReadString('.')
// log.Printf("Server received: %s\n", status)
fmt.Fprintf(conn, "I heard: '%s'\n", status)
+
+ status, err = bufio.NewReader(conn).ReadString('.')
+ // log.Printf("Server received: %s\n", status)
+ fmt.Fprintf(conn, "I heard: '%s'\n", status)
}
}
diff --git a/runtime/internal/flow/conn/grpc/conn.go b/runtime/internal/flow/conn/grpc/conn.go
index 28834f8..67a1f6e 100644
--- a/runtime/internal/flow/conn/grpc/conn.go
+++ b/runtime/internal/flow/conn/grpc/conn.go
@@ -39,31 +39,41 @@
mu sync.Mutex
}
+// TODO: what if bytesRead < 3? = 3?
func (c *conn) Read(b []byte) (n int, err error) {
c.mu.Lock()
defer c.mu.Unlock()
log.Printf("Beginning to Read.\n")
- resBuf := make([]byte, 4096*4096) // TODO better (dynamic) size or way of reading?
+ frame := [3]byte{}
+ frameCopied, err := c.rawConn.Read(frame[:])
+ if frameCopied != 3 {
+ return -1, errors.New("Did not copy 3 frame bytes.")
+ }
+ msgSize := read3ByteUint(frame)
+
+ resBuf := make([]byte, msgSize) // TODO better (dynamic) size or way of reading?
bytesRead, err := c.rawConn.Read(resBuf)
- log.Printf("Read %d bytes: %v\n", bytesRead, resBuf[:bytesRead])
+ // log.Printf("Read %d bytes: %v\n", bytesRead, resBuf)
if err != nil {
- log.Printf("Failed to read.\n")
+ // log.Printf("Failed to read.\n")
log.Fatal(err)
return bytesRead, err
}
// tmp := make([]byte, 0, bytesRead-box.Overhead) // TODO: is this enough? Also, why do we need both of tmp and out?
- out, ok := box.OpenAfterPrecomputation(nil, resBuf[:bytesRead], c.currentNonce(), c.sharedKey)
+ out, ok := box.OpenAfterPrecomputation(nil, resBuf, c.currentNonce(), c.sharedKey)
+ log.Printf("%d bytes after opening: %v\n", len(out), out)
+ log.Printf("%d bytes after opening: %v\n", len(out), string(out))
c.advanceNonce() // TODO: defer? Is there harm in advancing often than necessary (i.e. on error)?
if !ok {
- log.Printf("Failed to decrypt.\n")
+ // log.Printf("Failed to decrypt.\n")
//log.Fatal(err)
return 0, err
}
copy(b, out)
// should we return bytesRead or len(b)?
- log.Printf("cap(b): %d, len(b) %d, \ncap(out): %d, len(out): %d\n", cap(b), len(b), cap(out), len(out))
+ // log.Printf("cap(b): %d, len(b) %d, \ncap(out): %d, len(out): %d\n", cap(b), len(b), cap(out), len(out))
log.Printf("Succeeded in reading.\n\n")
// return bytesRead, nil
return len(b), nil
@@ -75,20 +85,18 @@
c.mu.Lock()
defer c.mu.Unlock()
log.Printf("Beginning to write.\n")
+ log.Printf("%d bytes before sealing: %v\n", len(b), b)
tmp := make([]byte, 3, 3+len(b)+box.Overhead) // TODO: is this enough? Also, why do we need both of tmp and out?
- tmp[0] = 5
- tmp[1] = 7
- tmp[2] = 14
+ err = write3ByteUint(tmp[:3], len(b)+box.Overhead)
+ if err != nil {
+ return -1, err
+ }
out := box.SealAfterPrecomputation(tmp, b, c.currentNonce(), c.sharedKey)
- log.Printf("tmp: %v", tmp)
- log.Printf("out: %v", out)
- log.Printf("tmp[0]: %p", &tmp[0])
- log.Printf("tmp[1]: %p", &tmp[1])
- log.Printf("tmp[2]: %p", &tmp[2])
- log.Printf("out[0]: %p", &out[0])
+ // log.Printf("tmp: %v", tmp)
+ // log.Printf("out: %v", out)
c.advanceNonce()
bytesCopied, err := io.Copy(c.rawConn, bytes.NewReader(out))
- log.Printf("Wrote %d bytes.\n", bytesCopied)
+ // log.Printf("Wrote %d bytes.\n", bytesCopied)
if err != nil {
log.Printf("Failed to copy to rawConn.\n")
log.Fatal(err)
@@ -101,7 +109,7 @@
log.Fatal(err)
return -1, errors.New(errMsg)
}
- log.Printf("cap(b): %d, len(b) %d, cap(out): %d, len(out): %d\n", cap(b), len(b), cap(out), len(out))
+ // log.Printf("cap(b): %d, len(b) %d, cap(out): %d, len(out): %d\n", cap(b), len(b), cap(out), len(out))
log.Printf("Succeeded in writing!\n\n")
// return int(bytesCopied), nil
return len(b), nil
