Fix key encoding to be null terminated

service/datastore/serialize/serialize.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package serialize
 
 import (
         "bytes"
         "errors"
         "fmt"
@@ skipping 16 matching lines @@
 var WritePropertyMapDeterministic = false
 
 // ReadPropertyMapReasonableLimit sets a limit on the number of rows and
 // number of properties per row which can be read by ReadPropertyMap. The
 // total number of Property objects readable by this method is this number
 // squared (e.g. Limit rows * Limit properties)
 const ReadPropertyMapReasonableLimit uint64 = 30000
 
 // ReadKeyNumToksReasonableLimit is the maximum number of Key tokens that
 // ReadKey is willing to read for a single key.
-const ReadKeyNumToksReasonableLimit uint64 = 50
+const ReadKeyNumToksReasonableLimit = 50
 
 // KeyContext controls whether the various Write and Read serializtion
 // routines should encode the context of Keys (read: the appid and namespace).
 // Frequently the appid and namespace of keys are known in advance and so there's
 // no reason to redundantly encode them.
 type KeyContext bool
 
 // With- and WithoutContext indicate if the serialization method should include
 // context for Keys. See KeyContext for more information.
 const (
         WithContext    KeyContext = true
         WithoutContext            = false
 )
 
 // WriteKey encodes a key to the buffer. If context is WithContext, then this
 // encoded value will include the appid and namespace of the key.
 func WriteKey(buf Buffer, context KeyContext, k ds.Key) (err error) {
-        // [appid ++ namespace]? ++ #tokens ++ tokens*
+        // [appid ++ namespace]? ++ [1 ++ token]* ++ NULL
         defer recoverTo(&err)
         appid, namespace, toks := dskey.Split(k)
         if context == WithContext {
                 panicIf(buf.WriteByte(1))
                 _, e := cmpbin.WriteString(buf, appid)
                 panicIf(e)
                 _, e = cmpbin.WriteString(buf, namespace)
                 panicIf(e)
         } else {
                 panicIf(buf.WriteByte(0))
         }
-        _, e := cmpbin.WriteUint(buf, uint64(len(toks)))
-        panicIf(e)
         for _, tok := range toks {
+                panicIf(buf.WriteByte(1))
                 panicIf(WriteKeyTok(buf, tok))
         }
-        return nil
+        return buf.WriteByte(0)
 }
 
 // ReadKey deserializes a key from the buffer. The value of context must match
 // the value of context that was passed to WriteKey when the key was encoded.
 // If context == WithoutContext, then the appid and namespace parameters are
 // used in the decoded Key. Otherwise they're ignored.
 func ReadKey(buf Buffer, context KeyContext, appid, namespace string) (ret ds.Key, err error) {
         defer recoverTo(&err)
         actualCtx, e := buf.ReadByte()
         panicIf(e)
 
         actualAid, actualNS := "", ""
         if actualCtx == 1 {
                 actualAid, _, e = cmpbin.ReadString(buf)
                 panicIf(e)
                 actualNS, _, e = cmpbin.ReadString(buf)
                 panicIf(e)
         } else if actualCtx != 0 {
                 err = fmt.Errorf("helper: expected actualCtx to be 0 or 1, got %d", actualCtx)
                 return
         }
 
         if context == WithoutContext {
                 // overrwrite with the supplied ones
                 actualAid = appid
                 actualNS = namespace
         }
 
-        numToks, _, e := cmpbin.ReadUint(buf)
-        panicIf(e)
-        if numToks > ReadKeyNumToksReasonableLimit {
-                err = fmt.Errorf("helper: tried to decode huge key of length %d", numToks)
-                return
-        }
+        toks := []ds.KeyTok{}
+        for {
+                ctrlByte, e := buf.ReadByte()
+                panicIf(e)
+                if ctrlByte == 0 {
+                        break
+                }
+                if len(toks)+1 >= ReadKeyNumToksReasonableLimit {

[dnj (Google), 2015/08/15 19:06:55]

nit: Why greater-than-or-equal and not greater-than?

If I say, "your limit is 10 cookies", you would expect to be able to eat 10
cookies, not 9 :)

+                        err = fmt.Errorf(
+                                "helper: tried to decode huge key with >= %d tokens",
+                                ReadKeyNumToksReasonableLimit)
+                        return
+                }
 
-        toks := make([]ds.KeyTok, numToks)
-        for i := uint64(0); i < numToks; i++ {
-                toks[i], e = ReadKeyTok(buf)
+                tok, e := ReadKeyTok(buf)
                 panicIf(e)
+
+                toks = append(toks, tok)
         }
 
         return dskey.NewToks(actualAid, actualNS, toks), nil
 }
 
 // WriteKeyTok writes a KeyTok to the buffer. You usually want WriteKey
 // instead of this.
 func WriteKeyTok(buf Buffer, tok ds.KeyTok) (err error) {
         // tok.kind ++ typ ++ [tok.stringID || tok.intID]
         defer recoverTo(&err)
@@ skipping 429 matching lines @@
         }
 }
 
 func recoverTo(err *error) {
         if r := recover(); r != nil {
                 if rerr := r.(parseError); rerr != nil {
                         *err = error(rerr)
                 }
         }
 }