Handle nil pointers when unmarshaling to struct

Author: oschwald

decoder.go

@@ -39,9 +39,8 @@ func (d *decoder) decode(offset uint, result reflect.Value) (uint, error) {
 	if typeNum != _Pointer && result.Kind() == reflect.Uintptr {
 		result.Set(reflect.ValueOf(uintptr(offset)))
 		return d.nextValueOffset(offset, 1), nil
-	} else {
-		return d.decodeFromType(typeNum, size, newOffset, result)
 	}
+	return d.decodeFromType(typeNum, size, newOffset, result)
 }
 
 func (d *decoder) decodeCtrlData(offset uint) (dataType, uint, uint) {
@@ -86,7 +85,10 @@ func (d *decoder) sizeFromCtrlByte(ctrlByte byte, offset uint, typeNum dataType)
 
 func (d *decoder) decodeFromType(dtype dataType, size uint, offset uint, result reflect.Value) (uint, error) {
 	if result.Kind() == reflect.Ptr {
-		result = reflect.Indirect(result)
+		if result.IsNil() {
+			result.Set(reflect.New(result.Type().Elem()))
+		}
+		result = result.Elem()
 	}
 
 	switch dtype {

reader.go

@@ -9,7 +9,8 @@ import (
 )
 
 const (
-	// Returned by LookupOffset when a matched root record offset cannot be found.
+	// NotFound is returned by LookupOffset when a matched root record offset
+	// cannot be found.
 	NotFound = ^uintptr(0)
 
 	dataSectionSeparatorSize = 16
@@ -106,11 +107,11 @@ func (r *Reader) startNode() (uint, error) {
 // Lookup takes an IP address as a net.IP structure and a pointer to the
 // result value to Decode into.
 func (r *Reader) Lookup(ipAddress net.IP, result interface{}) error {
-	if pointer, err := r.lookupPointer(ipAddress); pointer == 0 {
+	pointer, err := r.lookupPointer(ipAddress)
+	if pointer == 0 || err != nil {
 		return err
-	} else {
-		return r.retrieveData(pointer, result)
 	}
+	return r.retrieveData(pointer, result)
 }
 
 // LookupOffset maps an argument net.IP to a corresponding record offset in the
@@ -119,14 +120,14 @@ func (r *Reader) Lookup(ipAddress net.IP, result interface{}) error {
 // is an advanced API, which exists to provide clients with a means to cache
 // previously-decoded records.
 func (r *Reader) LookupOffset(ipAddress net.IP) (uintptr, error) {
-	if pointer, err := r.lookupPointer(ipAddress); pointer == 0 {
+	pointer, err := r.lookupPointer(ipAddress)
+	if pointer == 0 || err != nil {
 		return NotFound, err
-	} else {
-		return r.resolveDataPointer(pointer)
 	}
+	return r.resolveDataPointer(pointer)
 }
 
-// Decodes the record at |offset| into |result|. The result value pointed to
+// Decode the record at |offset| into |result|. The result value pointed to
 // must be a data value that corresponds to a record in the database. This may
 // include a struct representation of the data, a map capable of holding the
 // data or an empty interface{} value.

reader_test.go

@@ -162,6 +162,59 @@ func (s *MySuite) TestDecoder(c *C) {
 	c.Assert(reader.Close(), IsNil)
 }
 
+type PointerMap struct {
+	MapX map[string]interface{} `maxminddb:"mapX"`
+}
+
+type TestPointerType struct {
+	Array      *[]uint     `maxminddb:"array"`
+	Boolean    *bool       `maxminddb:"boolean"`
+	Bytes      *[]byte     `maxminddb:"bytes"`
+	Double     *float64    `maxminddb:"double"`
+	Float      *float32    `maxminddb:"float"`
+	Int32      *int32      `maxminddb:"int32"`
+	Map        *PointerMap `maxminddb:"map"`
+	Uint16     *uint16     `maxminddb:"uint16"`
+	Uint32     *uint32     `maxminddb:"uint32"`
+	Uint64     *uint64     `maxminddb:"uint64"`
+	Uint128    *big.Int    `maxminddb:"uint128"`
+	Utf8String *string     `maxminddb:"utf8_string"`
+}
+
+func (s *MySuite) TestStructWithPointer(c *C) {
+	reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
+	c.Assert(err, IsNil)
+
+	var result TestPointerType
+
+	c.Log("Before")
+	reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
+	c.Assert(err, IsNil)
+
+	c.Assert(*result.Array, DeepEquals, []uint{uint(1), uint(2), uint(3)})
+	c.Assert(*result.Boolean, Equals, true)
+	c.Assert(*result.Bytes, DeepEquals, []byte{0x00, 0x00, 0x00, 0x2a})
+	c.Assert(*result.Double, Equals, 42.123456)
+	c.Assert(*result.Float, Equals, float32(1.1))
+	c.Assert(*result.Int32, Equals, int32(-268435456))
+
+	c.Assert(result.Map.MapX, DeepEquals,
+		map[string]interface{}{
+			"arrayX":       []interface{}{uint64(7), uint64(8), uint64(9)},
+			"utf8_stringX": "hello",
+		})
+
+	c.Assert(*result.Uint16, Equals, uint16(100))
+	c.Assert(*result.Uint32, Equals, uint32(268435456))
+	c.Assert(*result.Uint64, Equals, uint64(1152921504606846976))
+	c.Assert(*result.Utf8String, Equals, "unicode! ☯ - ♫")
+	bigInt := new(big.Int)
+	bigInt.SetString("1329227995784915872903807060280344576", 10)
+	c.Assert(result.Uint128, DeepEquals, bigInt)
+
+	c.Assert(reader.Close(), IsNil)
+}
+
 func (s *MySuite) TestNestedOffsetDecode(c *C) {
 	db, err := Open("test-data/test-data/GeoIP2-City-Test.mmdb")
 	c.Assert(err, IsNil)