Merge pull request google#1302 from AlCutter/go_c_merkle_tree

Author: AlCutter

.travis.yml

@@ -126,6 +126,6 @@ script:
  - ${MAKE} -C python test
  - pushd ${GOPATH}
  - |
-   GODEBUG=cgocheck=0 CGO_CPPFLAGS="-I${INSTALL_DIR}/include" CGO_LDFLAGS="-L${INSTALL_DIR}/lib" go test -v ./src/github.com/google/certificate-transparency/go/...
+   CGO_CPPFLAGS="-I${INSTALL_DIR}/include" CGO_LDFLAGS="-L${INSTALL_DIR}/lib" go test -v ./src/github.com/google/certificate-transparency/go/...
  - popd
 

go/merkletree/merkle_tree.go

@@ -8,8 +8,8 @@ package merkletree
 */
 import "C"
 import (
-	"errors"
 	"fmt"
+	"unsafe"
 )
 
 // CPPMerkleTree provides an interface to the C++ CT MerkleTree library.
@@ -39,50 +39,56 @@ func (m *CPPMerkleTree) LevelCount() uint64 {
 // the tree structure, does not store the data itself.
 // Returns the position of the leaf in the tree.
 func (m *CPPMerkleTree) AddLeaf(leaf []byte) uint64 {
-	return uint64(C.AddLeaf(m.peer, C.BYTE_SLICE(&leaf)))
+	var leafPtr unsafe.Pointer
+	// Don't flake out if we're passed an empty leaf slice.
+	// We'll end up passing nullptr to the C++ code, but that's fine since we'll
+	// also be passing a size of 0.
+	if len(leaf) > 0 {
+		leafPtr = unsafe.Pointer(&leaf[0])
+	}
+	return uint64(C.AddLeaf(m.peer, leafPtr, C.size_t(len(leaf))))
 }
 
 // AddLeafHash adds a leaf hash directly to the tree. Returns the position of
 // the leaf in the tree.
 func (m *CPPMerkleTree) AddLeafHash(hash []byte) uint64 {
-	return uint64(C.AddLeafHash(m.peer, C.BYTE_SLICE(&hash)))
+	return uint64(C.AddLeafHash(m.peer, unsafe.Pointer(&hash[0]), C.size_t(len(hash))))
 }
 
 // LeafHash returns the leaf hash for the leaf at the requested index.
 func (m *CPPMerkleTree) LeafHash(leaf uint64) ([]byte, error) {
 	hash := make([]byte, m.nodeSize)
-	success := C.LeafHash(m.peer, C.BYTE_SLICE(&hash), C.size_t(leaf))
-	if !success {
-		return nil, fmt.Errorf("failed to get leafhash of leaf %d", leaf)
+	size := C.LeafHash(m.peer, C.size_t(leaf), unsafe.Pointer(&hash[0]), C.size_t(len(hash)))
+	if got, want := size, m.nodeSize; got != want {
+		return nil, fmt.Errorf("failed to get leafhash of leaf %d, got %d bytes expected %d", leaf, got, want)
 	}
 	return hash, nil
 }
 
 // CurrentRoot returns the current root of the tree.
 func (m *CPPMerkleTree) CurrentRoot() ([]byte, error) {
 	hash := make([]byte, m.nodeSize)
-	success := C.CurrentRoot(m.peer, C.BYTE_SLICE(&hash))
-	if !success {
-		return nil, errors.New("failed to get current root")
+	size := C.CurrentRoot(m.peer, unsafe.Pointer(&hash[0]), C.size_t(len(hash)))
+	if got, want := size, m.nodeSize; got != want {
+		return nil, fmt.Errorf("failed to get current root, got %d bytes, expected %d", got, want)
 	}
 	return hash, nil
 }
 
 // RootAtSnapshot returns the root at a given index.
 func (m *CPPMerkleTree) RootAtSnapshot(snapshot uint64) ([]byte, error) {
 	hash := make([]byte, m.nodeSize)
-	success := C.RootAtSnapshot(m.peer, C.BYTE_SLICE(&hash), C.size_t(snapshot))
-	if !success {
-		return nil, fmt.Errorf("failed to get root at snapshot %d", snapshot)
+	size := C.RootAtSnapshot(m.peer, C.size_t(snapshot), unsafe.Pointer(&hash[0]), C.size_t(len(hash)))
+	if got, want := size, m.nodeSize; got != want {
+		return nil, fmt.Errorf("failed to get root at snapshot %d, got %d bytes, expected %d", snapshot, got, want)
 	}
 	return hash, nil
 }
 
-func splitSlice(slice []byte, chunkSize int) ([][]byte, error) {
+func splitSlice(slice []byte, numEntries, chunkSize int) ([][]byte, error) {
 	if len(slice)%chunkSize != 0 {
 		return nil, fmt.Errorf("slice len %d is not a multiple of chunkSize %d", len(slice), chunkSize)
 	}
-	numEntries := len(slice) / chunkSize
 	ret := make([][]byte, numEntries)
 	for i := 0; i < numEntries; i++ {
 		start := i * chunkSize
@@ -96,33 +102,33 @@ func splitSlice(slice []byte, chunkSize int) ([][]byte, error) {
 func (m *CPPMerkleTree) PathToCurrentRoot(leaf uint64) ([][]byte, error) {
 	var numEntries C.size_t
 	entryBuffer := make([]byte, C.size_t(m.LevelCount())*m.nodeSize)
-	success := C.PathToCurrentRoot(m.peer, C.BYTE_SLICE(&entryBuffer), &numEntries, C.size_t(leaf))
+	success := C.PathToCurrentRoot(m.peer, C.size_t(leaf), unsafe.Pointer(&entryBuffer[0]), C.size_t(len(entryBuffer)), &numEntries)
 	if !success {
 		return nil, fmt.Errorf("failed to get path to current root from leaf %d", leaf)
 	}
-	return splitSlice(entryBuffer, int(m.nodeSize))
+	return splitSlice(entryBuffer, int(numEntries), int(m.nodeSize))
 }
 
 // PathToRootAtSnapshot returns an audit path to a given root for a given leaf.
 func (m *CPPMerkleTree) PathToRootAtSnapshot(leaf, snapshot uint64) ([][]byte, error) {
 	var numEntries C.size_t
 	entryBuffer := make([]byte, C.size_t(m.LevelCount())*m.nodeSize)
-	success := C.PathToRootAtSnapshot(m.peer, C.BYTE_SLICE(&entryBuffer), &numEntries, C.size_t(leaf), C.size_t(snapshot))
+	success := C.PathToRootAtSnapshot(m.peer, C.size_t(leaf), C.size_t(snapshot), unsafe.Pointer(&entryBuffer[0]), C.size_t(len(entryBuffer)), &numEntries)
 	if !success {
 		return nil, fmt.Errorf("failed to get path to root at snapshot %d from leaf %d", snapshot, leaf)
 	}
-	return splitSlice(entryBuffer, int(m.nodeSize))
+	return splitSlice(entryBuffer, int(numEntries), int(m.nodeSize))
 }
 
 // SnapshotConsistency returns a consistency proof between two given snapshots.
 func (m *CPPMerkleTree) SnapshotConsistency(snapshot1, snapshot2 uint64) ([][]byte, error) {
 	var numEntries C.size_t
 	entryBuffer := make([]byte, C.size_t(m.LevelCount())*m.nodeSize)
-	success := C.SnapshotConsistency(m.peer, C.BYTE_SLICE(&entryBuffer), &numEntries, C.size_t(snapshot1), C.size_t(snapshot2))
+	success := C.SnapshotConsistency(m.peer, C.size_t(snapshot1), C.size_t(snapshot2), unsafe.Pointer(&entryBuffer[0]), C.size_t(len(entryBuffer)), &numEntries)
 	if !success {
 		return nil, fmt.Errorf("failed to get path to snapshot consistency from %d to %d", snapshot1, snapshot2)
 	}
-	return splitSlice(entryBuffer, int(m.nodeSize))
+	return splitSlice(entryBuffer, int(numEntries), int(m.nodeSize))
 }
 
 // NewCPPMerkleTree returns a new wrapped C++ MerkleTree, using the

go/merkletree/merkle_tree_go.cc

@@ -6,7 +6,6 @@
 #include <memory>
 #include <vector>
 
-#include "_cgo_export.h"
 #include "merkle_tree_go.h"
 
 extern "C" {
@@ -22,10 +21,6 @@ static inline Sha256Hasher* H(HASHER hasher) {
   assert(hasher);
   return static_cast<Sha256Hasher*>(hasher);
 }
-static inline GoSlice* BS(BYTE_SLICE slice) {
-  assert(slice);
-  return static_cast<GoSlice*>(slice);
-}
 
 HASHER NewSha256Hasher() {
   return new Sha256Hasher;
@@ -47,109 +42,99 @@ size_t LeafCount(TREE tree) {
   return MT(tree)->LeafCount();
 }
 
-bool LeafHash(TREE tree, BYTE_SLICE out, size_t leaf) {
-  GoSlice* slice(BS(out));
+size_t LeafHash(TREE tree, size_t leaf, void* buf, size_t buf_len) {
   const MerkleTree* t(MT(tree));
   const size_t nodesize(t->NodeSize());
-  if (slice->data == NULL || slice->cap < nodesize) {
-    return false;
+  if (buf == NULL || buf_len < nodesize) {
+    return 0;
   }
   const std::string& hash = t->LeafHash(leaf);
   assert(nodesize == hash.size());
-  memcpy(slice->data, hash.data(), nodesize);
-  slice->len = nodesize;
-  return true;
+  memcpy(buf, hash.data(), nodesize);
+  return nodesize;
 }
 
 size_t LevelCount(TREE tree) {
   const MerkleTree* t(MT(tree));
   return t->LevelCount();
 }
 
-size_t AddLeaf(TREE tree, BYTE_SLICE leaf) {
-  GoSlice* slice(BS(leaf));
+size_t AddLeaf(TREE tree, void* leaf, size_t leaf_len) {
   MerkleTree* t(MT(tree));
-  return t->AddLeaf(std::string(static_cast<char*>(slice->data), slice->len));
+  return t->AddLeaf(std::string(static_cast<char*>(leaf), leaf_len));
 }
 
-size_t AddLeafHash(TREE tree, BYTE_SLICE hash) {
-  GoSlice* slice(BS(hash));
+size_t AddLeafHash(TREE tree, void* hash, size_t hash_len) {
   MerkleTree* t(MT(tree));
   return t->AddLeafHash(
-      std::string(static_cast<char*>(slice->data), slice->len));
+      std::string(static_cast<char*>(hash), hash_len));
 }
 
-bool CurrentRoot(TREE tree, BYTE_SLICE out) {
-  GoSlice* slice(BS(out));
+size_t CurrentRoot(TREE tree, void* buf, size_t buf_len) {
   MerkleTree* t(MT(tree));
   const size_t nodesize(t->NodeSize());
-  if (slice->data == NULL || slice->len != nodesize) {
-    return false;
+  if (buf == NULL || buf_len < nodesize) {
+    return 0;
   }
   const std::string& hash = t->CurrentRoot();
   assert(nodesize == hash.size());
-  memcpy(slice->data, hash.data(), nodesize);
-  slice->len = nodesize;
-  return true;
+  memcpy(buf, hash.data(), nodesize);
+  return nodesize;
 }
 
-bool RootAtSnapshot(TREE tree, BYTE_SLICE out, size_t snapshot) {
-  GoSlice* slice(BS(out));
+size_t RootAtSnapshot(TREE tree, size_t snapshot, void* buf, size_t buf_len) {
   MerkleTree* t(MT(tree));
   const size_t nodesize(t->NodeSize());
-  if (slice->data == NULL || slice->len != nodesize) {
-    return false;
+  if (buf == nullptr || buf_len < nodesize) {
+    return 0;
   }
   const std::string& hash = t->RootAtSnapshot(snapshot);
   assert(nodesize == hash.size());
-  memcpy(slice->data, hash.data(), nodesize);
-  slice->len = nodesize;
-  return true;
+  memcpy(buf, hash.data(), nodesize);
+  return nodesize;
 }
 
 // Copies the fixed-length entries from |path| into the GoSlice
 // pointed to by |dst|, one after the other in the same order.
 // |num_copied| is set to the number of entries copied.
-bool CopyNodesToSlice(const std::vector<std::string>& path, GoSlice* dst,
-                      size_t nodesize, size_t* num_copied) {
+bool CopyNodesToSlice(const std::vector<std::string>& path, void* dst,
+                      size_t dst_len, size_t nodesize, size_t* num_copied) {
   assert(dst);
   assert(num_copied);
-  if (dst->cap < path.size() * nodesize) {
+  if (dst_len < path.size() * nodesize) {
     *num_copied = 0;
     return false;
   }
-  char* e = static_cast<char*>(dst->data);
+  char *e(static_cast<char*>(dst));
   for (int i = 0; i < path.size(); ++i) {
     assert(nodesize == path[i].size());
     memcpy(e, path[i].data(), nodesize);
     e += nodesize;
   }
-  dst->len = path.size() * nodesize;
   *num_copied = path.size();
   return true;
 }
 
-bool PathToCurrentRoot(TREE tree, BYTE_SLICE out, size_t* num_entries,
-                       size_t leaf) {
+bool PathToCurrentRoot(TREE tree, size_t leaf, void* out, size_t out_len, size_t* num_entries) {
   MerkleTree* t(MT(tree));
   const std::vector<std::string> path = t->PathToCurrentRoot(leaf);
-  return CopyNodesToSlice(path, BS(out), t->NodeSize(), num_entries);
+  return CopyNodesToSlice(path, out, out_len, t->NodeSize(), num_entries);
 }
 
-bool PathToRootAtSnapshot(TREE tree, BYTE_SLICE out, size_t* num_entries,
-                          size_t leaf, size_t snapshot) {
+bool PathToRootAtSnapshot(TREE tree, size_t leaf, size_t snapshot, void *out,
+                            size_t out_len, size_t *num_entries) {
   MerkleTree* t(MT(tree));
   const std::vector<std::string> path =
       t->PathToRootAtSnapshot(leaf, snapshot);
-  return CopyNodesToSlice(path, BS(out), t->NodeSize(), num_entries);
+  return CopyNodesToSlice(path, out, out_len, t->NodeSize(), num_entries);
 }
 
-bool SnapshotConsistency(TREE tree, BYTE_SLICE out, size_t* num_entries,
-                         size_t snapshot1, size_t snapshot2) {
+bool SnapshotConsistency(TREE tree, size_t snapshot1, size_t snapshot2,
+                           void* out, size_t out_len, size_t* num_entries) {
   MerkleTree* t(MT(tree));
   const std::vector<std::string> path =
       t->SnapshotConsistency(snapshot1, snapshot2);
-  return CopyNodesToSlice(path, BS(out), t->NodeSize(), num_entries);
+  return CopyNodesToSlice(path, out, out_len, t->NodeSize(), num_entries);
 }
 
 }  // extern "C"

go/merkletree/merkle_tree_go.h

@@ -23,7 +23,6 @@ extern "C" {
 // Grumble grumble.
 typedef void* HASHER;
 typedef void* TREE;
-typedef void* BYTE_SLICE;
 
 // Allocators & deallocators:
 
@@ -42,30 +41,30 @@ void DeleteMerkleTree(TREE tree);
 
 size_t NodeSize(TREE tree);
 size_t LeafCount(TREE tree);
-bool LeafHash(TREE tree, BYTE_SLICE out, size_t leaf);
+size_t LeafHash(TREE tree, size_t leaf, void* buf, size_t buf_len);
 size_t LevelCount(TREE tree);
-size_t AddLeaf(TREE tree, BYTE_SLICE leaf);
-size_t AddLeafHash(TREE tree, BYTE_SLICE hash);
-bool CurrentRoot(TREE tree, BYTE_SLICE out);
-bool RootAtSnapshot(TREE tree, BYTE_SLICE out, size_t snapshot);
+size_t AddLeaf(TREE tree, void* leaf, size_t leaf_len);
+size_t AddLeafHash(TREE tree, void* hash, size_t hash_len);
+size_t CurrentRoot(TREE tree, void *buf, size_t buf_len);
+size_t RootAtSnapshot(TREE tree, size_t snapshot, void* buf, size_t buf_len);
 
 // |out| must contain sufficent space to hold all of the path elements
 // sequentially.
 // |num_entries| is set to the number of actual elements stored in |out|.
-bool PathToCurrentRoot(TREE tree, BYTE_SLICE out, size_t* num_entries,
-                       size_t leaf);
+bool PathToCurrentRoot(TREE tree, size_t leaf, void* out, size_t out_len,
+                       size_t* num_entries);
 
 // |out| must contain sufficent space to hold all of the path elements
 // sequentially.
 // |num_entries| is set to the number of actual elements stored in |out|.
-bool PathToRootAtSnapshot(TREE tree, BYTE_SLICE out, size_t* num_entries,
-                          size_t leaf, size_t snapshot);
+bool PathToRootAtSnapshot(TREE tree, size_t leaf, size_t snapshot, void* out,
+                            size_t out_len, size_t* num_entries);
 
 // |out| must contain sufficent space to hold all of the path elements
 // sequentially.
 // |num_entries| is set to the number of actual elements stored in |out|.
-bool SnapshotConsistency(TREE tree, BYTE_SLICE out, size_t* num_entries,
-                         size_t snapshot1, size_t snapshot2);
+bool SnapshotConsistency(TREE tree, size_t snapshot1, size_t snapshot2,
+                           void* out, size_t out_len, size_t* num_entries);
 
 #ifdef __cplusplus
 }