1) Decode objects with Serializable interface and store its raw data; 2) You can have your own decode function for object with custom serialize function ; 3) Improve NULL decoding

Author: Maksim Naumov

common.go

@@ -8,13 +8,16 @@ const VALUE_NAME_SEPARATOR = '|'
 const TYPE_VALUE_SEPARATOR = ':'
 const VALUES_SEPARATOR = ';'
 
+type SerializableDecodeFunc func(string) (PhpSessionData, error)
+
 type PhpValue interface{}
 
 type PhpSessionData map[string]PhpValue
 
 type PhpObject struct {
-	members   PhpSessionData
-	className string
+	RawData		string
+	members		PhpSessionData
+	className	string
 }
 
 func NewPhpObject() *PhpObject {

data/test.session

@@ -6,18 +6,22 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
+	"log"
 )
 
 type PhpDecoder struct {
-	source *strings.Reader
-	data   PhpSessionData
+	DecodeFunc	SerializableDecodeFunc
+	RawData		string
+	source		*strings.Reader
+	data		PhpSessionData
 }
 
 func NewPhpDecoder(phpSession string) *PhpDecoder {
 	sessionData := make(PhpSessionData)
 	d := &PhpDecoder{
-		source: strings.NewReader(phpSession),
-		data:   sessionData,
+		RawData:	phpSession,
+		source:		strings.NewReader(phpSession),
+		data:		sessionData,
 	}
 	return d
 }
@@ -50,7 +54,6 @@ func (decoder *PhpDecoder) DecodeValue() (PhpValue, error) {
 		switch token {
 		case 'N':
 			value = nil
-			decoder.expect(VALUES_SEPARATOR)
 		case 'b':
 			if rawValue, _, _err := decoder.source.ReadRune(); _err == nil {
 				value = rawValue == '1'
@@ -82,8 +85,12 @@ func (decoder *PhpDecoder) DecodeValue() (PhpValue, error) {
 		case 'a':
 			value, err = decoder.decodeArray()
 			decoder.allow(VALUES_SEPARATOR)
-		case 'O', 'C':
+		case 'O':
 			value, err = decoder.decodeObject()
+		case 'C':
+			value, err = decoder.decodeSerializableObject()
+		default:
+			log.Fatalf("Undefined token: %v [%#U]", token, token)
 		}
 	}
 	return value, err
@@ -100,6 +107,22 @@ func (decoder *PhpDecoder) decodeObject() (*PhpObject, error) {
 	return value, err
 }
 
+func (decoder *PhpDecoder) decodeSerializableObject() (*PhpObject, error) {
+	value := &PhpObject{}
+	var err error
+
+	if value.className, err = decoder.decodeString(); err == nil {
+		decoder.expect(TYPE_VALUE_SEPARATOR)
+		value.RawData, err = decoder.decodeString()
+	}
+
+	if decoder.DecodeFunc != nil {
+		value.members, err = decoder.DecodeFunc(value.RawData)
+	}
+
+	return value, err
+}
+
 func (decoder *PhpDecoder) decodeArray() (PhpSessionData, error) {
 	value := make(PhpSessionData)
 	var err error
@@ -194,3 +217,22 @@ func (decoder *PhpDecoder) allow(expectRune rune) error {
 	}
 	return err
 }
+
+func SerializableDecode(s string) (valueData PhpSessionData, err error) {
+	var (
+		value		PhpValue
+		ok			bool
+	)
+
+	decoder := NewPhpDecoder(s)
+	decoder.DecodeFunc = SerializableDecode
+
+	if value, err = decoder.DecodeValue(); err == nil {
+		valueData, ok = value.(PhpSessionData)
+		if !ok {
+			err = errors.New("Error casting to PhpSessionData")
+		}
+	}
+
+	return
+}

decoder.go

@@ -252,13 +252,64 @@ func TestDecodeMultipleArraysWithoutSemicolons(t *testing.T) {
 	}
 }
 
+const SERIALIZABLE_OBJECT_VALUE_NO_FUNC_ENCODED = "obj|C:10:\"TestObject\":49:{a:3:{s:1:\"a\";i:5;s:1:\"b\";s:4:\"priv\";s:1:\"c\";i:8;}}"
+
+func TestDecodeSerializableObjectValueNoFunc(t *testing.T) {
+	decoder := NewPhpDecoder(SERIALIZABLE_OBJECT_VALUE_NO_FUNC_ENCODED)
+	if result, err := decoder.Decode(); err != nil {
+		t.Errorf("Can not decode object value %#v \n", err)
+	} else {
+		if v, ok := (result)["obj"]; !ok {
+			t.Errorf("Object value was not decoded \n")
+		} else if objValue, ok := v.(*PhpObject); ok != true {
+			t.Errorf("Object value was decoded incorrectly: %#v \n", v)
+		} else if objValue.GetClassName() != "TestObject" {
+			t.Errorf("Object name was decoded incorrectly: %#v\n", objValue.GetClassName())
+		} else if objValue.RawData != "a:3:{s:1:\"a\";i:5;s:1:\"b\";s:4:\"priv\";s:1:\"c\";i:8;}" {
+			t.Errorf("RawData of object was decoded incorrectly: %#v\n", objValue.RawData)
+		}
+	}
+}
+
+const SERIALIZABLE_OBJECT_VALUE_ENCODED = "object|C:10:\"TestObject\":96:{a:1:{s:4:\"item\";O:8:\"AbcClass\":3:{s:1:\"a\";i:5;s:11:\"\x00AbcClass\x00b\";s:7:\"private\";s:4:\"\x00*\x00c\";i:8;}}}"
+
+func TestDecodeSerializableObjectValue(t *testing.T) {
+	decoder := NewPhpDecoder(SERIALIZABLE_OBJECT_VALUE_ENCODED)
+	decoder.DecodeFunc = SerializableDecode
+	if result, err := decoder.Decode(); err != nil {
+		t.Errorf("Can not decode object value %#v \n", err)
+	} else {
+		if v, ok := (result)["object"]; !ok {
+			t.Errorf("Object value was not decoded \n")
+		} else if objValue, ok := v.(*PhpObject); ok != true {
+			t.Errorf("Object value was decoded incorrectly: %#v \n", v)
+		} else if objValue.GetClassName() != "TestObject" {
+			t.Errorf("Object name was decoded incorrectly: %#v\n", objValue.GetClassName())
+		} else if objValue.RawData != "a:1:{s:4:\"item\";O:8:\"AbcClass\":3:{s:1:\"a\";i:5;s:11:\"\x00AbcClass\x00b\";s:7:\"private\";s:4:\"\x00*\x00c\";i:8;}}" {
+			t.Errorf("RawData of object was decoded incorrectly: %#v\n", objValue.RawData)
+		} else if itemValue, ok := objValue.GetPublicMemberValue("item"); !ok {
+			t.Errorf("Public member of object was decoded incorrectly: %#v\n", objValue.GetMembers())
+		} else if itemObjValue, ok := itemValue.(*PhpObject); ok != true {
+			t.Errorf("Object value was decoded incorrectly: %#v \n", v)
+		} else if itemObjValue.GetClassName() != "AbcClass" {
+			t.Errorf("Object name was decoded incorrectly: %#v\n", itemObjValue.GetClassName())
+		} else if value1, ok := itemObjValue.GetPublicMemberValue("a"); !ok || value1 != 5 {
+			t.Errorf("Public member of object was decoded incorrectly: %#v\n", objValue.GetMembers())
+		} else if value2, ok := itemObjValue.GetPrivateMemberValue("b"); !ok || value2 != "private" {
+			t.Errorf("Private member of object was decoded incorrectly: %#v\n", objValue.GetMembers())
+		} else if value3, ok := itemObjValue.GetProtectedMemberValue("c"); !ok || value3 != 8 {
+			t.Errorf("Protected member of object was decoded incorrectly: %#v\n", objValue.GetMembers())
+		}
+	}
+}
+
 func TestDecodeRealData(t *testing.T) {
 	testData, _ := ioutil.ReadFile("./data/test.session")
 	decoder := NewPhpDecoder(string(testData))
 	if result, err := decoder.Decode(); err != nil {
 		t.Errorf("Can not decode array value %#v \n", err)
 	} else {
-		rootKeys := []string{"product_last_viewed", "core", "customer", "checkout", "store_default", "catalog"}
+		rootKeys := []string{"product_last_viewed", "core", "customer", "checkout", "store_default", "catalog", "object"}
 		for _, v := range rootKeys {
 			if _, ok := result[v]; !ok {
 				t.Errorf("Can not find %v key\n", v)

decoder_test.go

@@ -0,0 +1 @@
+session*

php/.gitignore

@@ -0,0 +1,75 @@
+<?php
+
+class TestSessionHandler implements SessionHandlerInterface
+{
+    private $dir;
+
+    public function __construct()
+    {
+        $this->dir = dirname(__FILE__) . '/';
+    }
+
+    public function getFileName($id)
+    {
+        return $this->dir . 'session_' . $id;
+    }
+
+    function open($savePath, $sessionName)
+    {
+        return true;
+    }
+
+    function close()
+    {
+        return true;
+    }
+
+    function read($id)
+    {
+        $data = @file_get_contents($this->getFileName($id));
+        return false === $data ? '' : $data;
+    }
+
+    function write($id, $data)
+    {
+        echo json_encode($data).PHP_EOL;
+        return file_put_contents($this->getFileName($id), $data) === false ? false : true;
+    }
+
+    function destroy($id)
+    {
+        return true;
+    }
+
+    function gc($maxlifetime)
+    {
+        return true;
+    }
+}
+
+class AbcClass {
+    public $a = 5;
+    private $b = 'private';
+    protected $c = 8;
+}
+
+class TestObject implements Serializable {
+    public $item;
+    public function serialize() {
+        return serialize(array('item' => $this->item));
+    }
+    public function unserialize($serialized) {
+        return unserialize($serialized);
+    }
+}
+
+$object = new TestObject();
+$object->item = new AbcClass();
+
+$handler = new TestSessionHandler();
+session_set_save_handler($handler, true);
+session_start();
+
+$_SESSION['object'] = $object;
+
+echo $handler->getFileName(session_id()) . PHP_EOL;