Return an error if a closed reader is used

Previously, using a closed database could result in a segmentation
violation when the closed memory map was accessed. See
oschwald/geoip2-golang#35.

Author: oschwald

reader.go

@@ -107,6 +107,9 @@ 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 r.buffer == nil {
+		return errors.New("cannot call Lookup on a closed database")
+	}
 	pointer, err := r.lookupPointer(ipAddress)
 	if pointer == 0 || err != nil {
 		return err
@@ -120,6 +123,9 @@ 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 r.buffer == nil {
+		return 0, errors.New("cannot call LookupOffset on a closed database")
+	}
 	pointer, err := r.lookupPointer(ipAddress)
 	if pointer == 0 || err != nil {
 		return NotFound, err
@@ -144,6 +150,13 @@ func (r *Reader) LookupOffset(ipAddress net.IP) (uintptr, error) {
 // single representative record for that country. This uintptr behavior allows
 // clients to leverage this normalization in their own sub-record caching.
 func (r *Reader) Decode(offset uintptr, result interface{}) error {
+	if r.buffer == nil {
+		return errors.New("cannot call Decode on a closed database")
+	}
+	return r.decode(offset, result)
+}
+
+func (r *Reader) decode(offset uintptr, result interface{}) error {
 	rv := reflect.ValueOf(result)
 	if rv.Kind() != reflect.Ptr || rv.IsNil() {
 		return errors.New("result param must be a pointer")
@@ -233,7 +246,7 @@ func (r *Reader) retrieveData(pointer uint, result interface{}) error {
 	if err != nil {
 		return err
 	}
-	return r.Decode(offset, result)
+	return r.decode(offset, result)
 }
 
 func (r *Reader) resolveDataPointer(pointer uint) (uintptr, error) {

reader_appengine.go

@@ -20,7 +20,9 @@ func Open(file string) (*Reader, error) {
 
 // Close unmaps the database file from virtual memory and returns the
 // resources to the system. If called on a Reader opened using FromBytes
-// or Open on Google App Engine, this method does nothing.
+// or Open on Google App Engine, this method sets the underlying buffer
+// to nil, returning the resources to the system.
 func (r *Reader) Close() error {
+	r.buffer = nil
 	return nil
 }

reader_other.go

@@ -52,10 +52,12 @@ func Open(file string) (*Reader, error) {
 // resources to the system. If called on a Reader opened using FromBytes
 // or Open on Google App Engine, this method does nothing.
 func (r *Reader) Close() error {
-	if !r.hasMappedFile {
-		return nil
+	var err error
+	if r.hasMappedFile {
+		runtime.SetFinalizer(r, nil)
+		r.hasMappedFile = false
+		err = munmap(r.buffer)
 	}
-	runtime.SetFinalizer(r, nil)
-	r.hasMappedFile = false
-	return munmap(r.buffer)
+	r.buffer = nil
+	return err
 }

reader_test.go

@@ -396,6 +396,22 @@ func TestNilLookup(t *testing.T) {
 	assert.Nil(t, reader.Close(), "error on close")
 }
 
+func TestUsingClosedDatabase(t *testing.T) {
+	reader, _ := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
+	reader.Close()
+
+	var recordInterface interface{}
+
+	err := reader.Lookup(nil, recordInterface)
+	assert.Equal(t, err.Error(), "cannot call Lookup on a closed database")
+
+	_, err = reader.LookupOffset(nil)
+	assert.Equal(t, err.Error(), "cannot call LookupOffset on a closed database")
+
+	err = reader.Decode(0, recordInterface)
+	assert.Equal(t, err.Error(), "cannot call Decode on a closed database")
+}
+
 func checkMetadata(t *testing.T, reader *Reader, ipVersion uint, recordSize uint) {
 	metadata := reader.Metadata