Merge "Add permission flags persistence and drop invalid entries."

8 files changed, 185 insertions, 67 deletions

diff --git a/services/permission/java/com/android/server/permission/access/AccessPersistence.kt b/services/permission/java/com/android/server/permission/access/AccessPersistence.kt
index 022f09a028db..91239c692505 100644
--- a/services/permission/java/com/android/server/permission/access/AccessPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/AccessPersistence.kt
@@ -33,24 +33,23 @@ class AccessPersistence(
     private val policy: AccessPolicy
 ) {
     fun read(state: AccessState) {
-        readSystemState(state.systemState)
-        val userStates = state.userStates
+        readSystemState(state)
         state.systemState.userIds.forEachIndexed { _, userId ->
-            readUserState(userId, userStates[userId])
+            readUserState(state, userId)
         }
     }
 
-    private fun readSystemState(systemState: SystemState) {
+    private fun readSystemState(state: AccessState) {
         systemFile.parse {
             // This is the canonical way to call an extension function in a different class.
             // TODO(b/259469752): Use context receiver for this when it becomes stable.
-            with(policy) { parseSystemState(systemState) }
+            with(policy) { parseSystemState(state) }
         }
     }
 
-    private fun readUserState(userId: Int, userState: UserState) {
+    private fun readUserState(state: AccessState, userId: Int) {
         getUserFile(userId).parse {
-            with(policy) { parseUserState(userId, userState) }
+            with(policy) { parseUserState(state, userId) }
         }
     }
 
@@ -65,30 +64,30 @@ class AccessPersistence(
     }
 
     fun write(state: AccessState) {
-        writeState(state.systemState, ::writeSystemState)
+        writeState(state.systemState) { writeSystemState(state) }
         state.userStates.forEachIndexed { _, userId, userState ->
-            writeState(userState) { writeUserState(userId, it) }
+            writeState(userState) { writeUserState(state, userId) }
         }
     }
 
-    private inline fun <T : WritableState> writeState(state: T, write: (T) -> Unit) {
+    private inline fun <T : WritableState> writeState(state: T, write: () -> Unit) {
         when (val writeMode = state.writeMode) {
             WriteMode.NONE -> {}
-            WriteMode.SYNC -> write(state)
+            WriteMode.SYNC -> write()
             WriteMode.ASYNC -> TODO()
             else -> error(writeMode)
         }
     }
 
-    private fun writeSystemState(systemState: SystemState) {
+    private fun writeSystemState(state: AccessState) {
         systemFile.serialize {
-            with(policy) { serializeSystemState(systemState) }
+            with(policy) { serializeSystemState(state) }
         }
     }
 
-    private fun writeUserState(userId: Int, userState: UserState) {
+    private fun writeUserState(state: AccessState, userId: Int) {
         getUserFile(userId).serialize {
-            with(policy) { serializeUserState(userId, userState) }
+            with(policy) { serializeUserState(state, userId) }
         }
     }
 
diff --git a/services/permission/java/com/android/server/permission/access/AccessPolicy.kt b/services/permission/java/com/android/server/permission/access/AccessPolicy.kt
index 89316c2812dd..8027b50fe254 100644
--- a/services/permission/java/com/android/server/permission/access/AccessPolicy.kt
+++ b/services/permission/java/com/android/server/permission/access/AccessPolicy.kt
@@ -202,13 +202,13 @@ class AccessPolicy private constructor(
         }
     }
 
-    fun BinaryXmlPullParser.parseSystemState(systemState: SystemState) {
+    fun BinaryXmlPullParser.parseSystemState(state: AccessState) {
         forEachTag {
             when (tagName) {
                 TAG_ACCESS -> {
                     forEachTag {
                         forEachSchemePolicy {
-                            with(it) { parseSystemState(systemState) }
+                            with(it) { parseSystemState(state) }
                         }
                     }
                 }
@@ -217,21 +217,21 @@ class AccessPolicy private constructor(
         }
     }
 
-    fun BinaryXmlSerializer.serializeSystemState(systemState: SystemState) {
+    fun BinaryXmlSerializer.serializeSystemState(state: AccessState) {
         tag(TAG_ACCESS) {
             forEachSchemePolicy {
-                with(it) { serializeSystemState(systemState) }
+                with(it) { serializeSystemState(state) }
             }
         }
     }
 
-    fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {
+    fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
         forEachTag {
             when (tagName) {
                 TAG_ACCESS -> {
                     forEachTag {
                         forEachSchemePolicy {
-                            with(it) { parseUserState(userId, userState) }
+                            with(it) { parseUserState(state, userId) }
                         }
                     }
                 }
@@ -245,10 +245,10 @@ class AccessPolicy private constructor(
         }
     }
 
-    fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {
+    fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
         tag(TAG_ACCESS) {
             forEachSchemePolicy {
-                with(it) { serializeUserState(userId, userState) }
+                with(it) { serializeUserState(state, userId) }
             }
         }
     }
@@ -305,11 +305,11 @@ abstract class SchemePolicy {
 
     open fun MutateStateScope.onPackageUninstalled(packageName: String, appId: Int, userId: Int) {}
 
-    open fun BinaryXmlPullParser.parseSystemState(systemState: SystemState) {}
+    open fun BinaryXmlPullParser.parseSystemState(state: AccessState) {}
 
-    open fun BinaryXmlSerializer.serializeSystemState(systemState: SystemState) {}
+    open fun BinaryXmlSerializer.serializeSystemState(state: AccessState) {}
 
-    open fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {}
+    open fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {}
 
-    open fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {}
+    open fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {}
 }
diff --git a/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPersistence.kt b/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPersistence.kt
index 031c9287a9a4..5faf96fecfd4 100644
--- a/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPersistence.kt
@@ -19,7 +19,7 @@ package com.android.server.permission.access.appop
 import android.util.Log
 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
-import com.android.server.permission.access.UserState
+import com.android.server.permission.access.AccessState
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.attributeInt
 import com.android.server.permission.access.util.attributeInterned
@@ -30,9 +30,9 @@ import com.android.server.permission.access.util.tag
 import com.android.server.permission.access.util.tagName
 
 abstract class BaseAppOpPersistence {
-    abstract fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState)
+    abstract fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int)
 
-    abstract fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState)
+    abstract fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int)
 
     protected fun BinaryXmlPullParser.parseAppOps(appOpModes: IndexedMap<String, Int>) {
         forEachTag {
@@ -67,7 +67,7 @@ abstract class BaseAppOpPersistence {
 
         private const val TAG_APP_OP = "app-op"
 
-        private const val ATTR_NAME = "name"
         private const val ATTR_MODE = "mode"
+        private const val ATTR_NAME = "name"
     }
 }
diff --git a/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPolicy.kt b/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPolicy.kt
index 7f4e0f72537e..9c8c0ce3bde0 100644
--- a/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPolicy.kt
+++ b/services/permission/java/com/android/server/permission/access/appop/BaseAppOpPolicy.kt
@@ -18,9 +18,9 @@ package com.android.server.permission.access.appop
 
 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
+import com.android.server.permission.access.AccessState
 import com.android.server.permission.access.AppOpUri
 import com.android.server.permission.access.SchemePolicy
-import com.android.server.permission.access.UserState
 
 abstract class BaseAppOpPolicy(
     private val persistence: BaseAppOpPersistence
@@ -28,11 +28,11 @@ abstract class BaseAppOpPolicy(
     override val objectScheme: String
         get() = AppOpUri.SCHEME
 
-    override fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {
-        with(persistence) { this@parseUserState.parseUserState(userId, userState) }
+    override fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
+        with(persistence) { this@parseUserState.parseUserState(state, userId) }
     }
 
-    override fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {
-        with(persistence) { this@serializeUserState.serializeUserState(userId, userState) }
+    override fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        with(persistence) { this@serializeUserState.serializeUserState(state, userId) }
     }
 }
diff --git a/services/permission/java/com/android/server/permission/access/appop/PackageAppOpPersistence.kt b/services/permission/java/com/android/server/permission/access/appop/PackageAppOpPersistence.kt
index 183a352b9acd..6ef117a44b2a 100644
--- a/services/permission/java/com/android/server/permission/access/appop/PackageAppOpPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/appop/PackageAppOpPersistence.kt
@@ -19,6 +19,7 @@ package com.android.server.permission.access.appop
 import android.util.Log
 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
+import com.android.server.permission.access.AccessState
 import com.android.server.permission.access.UserState
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.attributeInterned
@@ -28,20 +29,28 @@ import com.android.server.permission.access.util.tag
 import com.android.server.permission.access.util.tagName
 
 class PackageAppOpPersistence : BaseAppOpPersistence() {
-    override fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {
+    override fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
         when (tagName) {
-            TAG_PACKAGE_APP_OPS -> parsePackageAppOps(userState)
+            TAG_PACKAGE_APP_OPS -> parsePackageAppOps(state, userId)
             else -> {}
         }
     }
 
-    private fun BinaryXmlPullParser.parsePackageAppOps(userState: UserState) {
+    private fun BinaryXmlPullParser.parsePackageAppOps(state: AccessState, userId: Int) {
+        val userState = state.userStates[userId]
         forEachTag {
             when (tagName) {
                 TAG_PACKAGE -> parsePackage(userState)
                 else -> Log.w(LOG_TAG, "Ignoring unknown tag $name when parsing app-op state")
             }
         }
+        userState.packageAppOpModes.retainAllIndexed { _, packageName, _ ->
+            val hasPackage = packageName in state.systemState.packageStates
+            if (!hasPackage) {
+                Log.w(LOG_TAG, "Dropping unknown package $packageName when parsing app-op state")
+            }
+            hasPackage
+        }
     }
 
     private fun BinaryXmlPullParser.parsePackage(userState: UserState) {
@@ -51,8 +60,8 @@ class PackageAppOpPersistence : BaseAppOpPersistence() {
         parseAppOps(appOpModes)
     }
 
-    override fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {
-        serializePackageAppOps(userState)
+    override fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        serializePackageAppOps(state.userStates[userId])
     }
 
     private fun BinaryXmlSerializer.serializePackageAppOps(userState: UserState) {
@@ -76,8 +85,8 @@ class PackageAppOpPersistence : BaseAppOpPersistence() {
     companion object {
         private val LOG_TAG = PackageAppOpPersistence::class.java.simpleName
 
-        private const val TAG_PACKAGE_APP_OPS = "package-app-ops"
         private const val TAG_PACKAGE = "package"
+        private const val TAG_PACKAGE_APP_OPS = "package-app-ops"
 
         private const val ATTR_NAME = "name"
     }
diff --git a/services/permission/java/com/android/server/permission/access/appop/UidAppOpPersistence.kt b/services/permission/java/com/android/server/permission/access/appop/UidAppOpPersistence.kt
index 3c3a9d18926a..7a965d470bb0 100644
--- a/services/permission/java/com/android/server/permission/access/appop/UidAppOpPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/appop/UidAppOpPersistence.kt
@@ -19,6 +19,7 @@ package com.android.server.permission.access.appop
 import android.util.Log
 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
+import com.android.server.permission.access.AccessState
 import com.android.server.permission.access.UserState
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.attributeInt
@@ -28,44 +29,55 @@ import com.android.server.permission.access.util.tag
 import com.android.server.permission.access.util.tagName
 
 class UidAppOpPersistence : BaseAppOpPersistence() {
-    override fun BinaryXmlPullParser.parseUserState(userId: Int, userState: UserState) {
+    override fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
         when (tagName) {
-            TAG_UID_APP_OPS -> parseUidAppOps(userState)
+            TAG_UID_APP_OPS -> parseUidAppOps(state, userId)
             else -> {}
         }
     }
 
-    private fun BinaryXmlPullParser.parseUidAppOps(userState: UserState) {
+    private fun BinaryXmlPullParser.parseUidAppOps(state: AccessState, userId: Int) {
+        val userState = state.userStates[userId]
         forEachTag {
             when (tagName) {
-                TAG_UID -> parseUid(userState)
+                TAG_APP_ID -> parseAppId(userState)
                 else -> Log.w(LOG_TAG, "Ignoring unknown tag $name when parsing app-op state")
             }
         }
+        userState.uidAppOpModes.retainAllIndexed { _, appId, _ ->
+            val hasAppId = appId in state.systemState.appIds
+            if (!hasAppId) {
+                Log.w(LOG_TAG, "Dropping unknown app ID $appId when parsing app-op state")
+            }
+            hasAppId
+        }
     }
 
-    private fun BinaryXmlPullParser.parseUid(userState: UserState) {
-        val uid = getAttributeIntOrThrow(ATTR_UID)
+    private fun BinaryXmlPullParser.parseAppId(userState: UserState) {
+        val appId = getAttributeIntOrThrow(ATTR_ID)
         val appOpModes = IndexedMap<String, Int>()
-        userState.uidAppOpModes[uid] = appOpModes
+        userState.uidAppOpModes[appId] = appOpModes
         parseAppOps(appOpModes)
     }
 
-    override fun BinaryXmlSerializer.serializeUserState(userId: Int, userState: UserState) {
-        serializeUidAppOps(userState)
+    override fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        serializeUidAppOps(state.userStates[userId])
     }
 
     private fun BinaryXmlSerializer.serializeUidAppOps(userState: UserState) {
         tag(TAG_UID_APP_OPS) {
-            userState.uidAppOpModes.forEachIndexed { _, uid, appOpModes ->
-                serializeUid(uid, appOpModes)
+            userState.uidAppOpModes.forEachIndexed { _, appId, appOpModes ->
+                serializeAppId(appId, appOpModes)
             }
         }
     }
 
-    private fun BinaryXmlSerializer.serializeUid(uid: Int, appOpModes: IndexedMap<String, Int>) {
-        tag(TAG_UID) {
-            attributeInt(ATTR_UID, uid)
+    private fun BinaryXmlSerializer.serializeAppId(
+        appId: Int,
+        appOpModes: IndexedMap<String, Int>
+    ) {
+        tag(TAG_APP_ID) {
+            attributeInt(ATTR_ID, appId)
             serializeAppOps(appOpModes)
         }
     }
@@ -73,9 +85,9 @@ class UidAppOpPersistence : BaseAppOpPersistence() {
     companion object {
         private val LOG_TAG = UidAppOpPersistence::class.java.simpleName
 
+        private const val TAG_APP_ID = "app-id"
         private const val TAG_UID_APP_OPS = "uid-app-ops"
-        private const val TAG_UID = "uid"
 
-        private const val ATTR_UID = "uid"
+        private const val ATTR_ID = "id"
     }
 }
diff --git a/services/permission/java/com/android/server/permission/access/permission/UidPermissionPersistence.kt b/services/permission/java/com/android/server/permission/access/permission/UidPermissionPersistence.kt
index 061933a13fb4..35cdbce01128 100644
--- a/services/permission/java/com/android/server/permission/access/permission/UidPermissionPersistence.kt
+++ b/services/permission/java/com/android/server/permission/access/permission/UidPermissionPersistence.kt
@@ -20,7 +20,8 @@ import android.content.pm.PermissionInfo
 import android.util.Log
 import com.android.modules.utils.BinaryXmlPullParser
 import com.android.modules.utils.BinaryXmlSerializer
-import com.android.server.permission.access.SystemState
+import com.android.server.permission.access.AccessState
+import com.android.server.permission.access.UserState
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.attribute
 import com.android.server.permission.access.util.attributeInt
@@ -37,7 +38,8 @@ import com.android.server.permission.access.util.tag
 import com.android.server.permission.access.util.tagName
 
 class UidPermissionPersistence {
-    fun BinaryXmlPullParser.parseSystemState(systemState: SystemState) {
+    fun BinaryXmlPullParser.parseSystemState(state: AccessState) {
+        val systemState = state.systemState
         when (tagName) {
             TAG_PERMISSION_TREES -> parsePermissions(systemState.permissionTrees)
             TAG_PERMISSIONS -> parsePermissions(systemState.permissions)
@@ -84,7 +86,8 @@ class UidPermissionPersistence {
         permissions[name] = permission
     }
 
-    fun BinaryXmlSerializer.serializeSystemState(systemState: SystemState) {
+    fun BinaryXmlSerializer.serializeSystemState(state: AccessState) {
+        val systemState = state.systemState
         serializePermissions(TAG_PERMISSION_TREES, systemState.permissionTrees)
         serializePermissions(TAG_PERMISSIONS, systemState.permissions)
     }
@@ -121,14 +124,102 @@ class UidPermissionPersistence {
         }
     }
 
+    fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
+        when (tagName) {
+            TAG_PERMISSIONS -> parsePermissionFlags(state, userId)
+            else -> {}
+        }
+    }
+
+    private fun BinaryXmlPullParser.parsePermissionFlags(state: AccessState, userId: Int) {
+        val userState = state.userStates[userId]
+        forEachTag {
+            when (tagName) {
+                TAG_APP_ID -> parseAppId(userState)
+                else -> Log.w(LOG_TAG, "Ignoring unknown tag $name when parsing permission state")
+            }
+        }
+        userState.uidPermissionFlags.retainAllIndexed { _, appId, _ ->
+            val hasAppId = appId in state.systemState.appIds
+            if (!hasAppId) {
+                Log.w(LOG_TAG, "Dropping unknown app ID $appId when parsing permission state")
+            }
+            hasAppId
+        }
+    }
+
+    private fun BinaryXmlPullParser.parseAppId(userState: UserState) {
+        val appId = getAttributeIntOrThrow(ATTR_ID)
+        val permissionFlags = IndexedMap<String, Int>()
+        userState.uidPermissionFlags[appId] = permissionFlags
+        parseAppIdPermissions(permissionFlags)
+    }
+
+    private fun BinaryXmlPullParser.parseAppIdPermissions(
+        permissionFlags: IndexedMap<String, Int>
+    ) {
+        forEachTag {
+            when (tagName) {
+                TAG_PERMISSION -> parseAppIdPermission(permissionFlags)
+                else -> Log.w(LOG_TAG, "Ignoring unknown tag $name when parsing permission state")
+            }
+        }
+    }
+
+    private fun BinaryXmlPullParser.parseAppIdPermission(permissionFlags: IndexedMap<String, Int>) {
+        val name = getAttributeValueOrThrow(ATTR_NAME).intern()
+        val flags = getAttributeIntOrThrow(ATTR_FLAGS)
+        permissionFlags[name] = flags
+    }
+
+    fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        serializePermissionFlags(state.userStates[userId])
+    }
+
+    private fun BinaryXmlSerializer.serializePermissionFlags(userState: UserState) {
+        tag(TAG_PERMISSIONS) {
+            userState.uidPermissionFlags.forEachIndexed { _, appId, permissionFlags ->
+                serializeAppId(appId, permissionFlags)
+            }
+        }
+    }
+
+    private fun BinaryXmlSerializer.serializeAppId(
+        appId: Int,
+        permissionFlags: IndexedMap<String, Int>
+    ) {
+        tag(TAG_APP_ID) {
+            attributeInt(ATTR_ID, appId)
+            serializeAppIdPermissions(permissionFlags)
+        }
+    }
+
+    private fun BinaryXmlSerializer.serializeAppIdPermissions(
+        permissionFlags: IndexedMap<String, Int>
+    ) {
+        permissionFlags.forEachIndexed { _, name, flags ->
+            serializeAppIdPermission(name, flags)
+        }
+    }
+
+    private fun BinaryXmlSerializer.serializeAppIdPermission(name: String, flags: Int) {
+        tag(TAG_PERMISSION) {
+            attributeInterned(ATTR_NAME, name)
+            attributeInt(ATTR_FLAGS, flags)
+        }
+    }
+
     companion object {
         private val LOG_TAG = UidPermissionPersistence::class.java.simpleName
 
+        private const val TAG_APP_ID = "app-id"
         private const val TAG_PERMISSION = "permission"
-        private const val TAG_PERMISSION_TREES = "permission-trees"
         private const val TAG_PERMISSIONS = "permissions"
+        private const val TAG_PERMISSION_TREES = "permission-trees"
 
+        private const val ATTR_FLAGS = "flags"
         private const val ATTR_ICON = "icon"
+        private const val ATTR_ID = "id"
         private const val ATTR_LABEL = "label"
         private const val ATTR_NAME = "name"
         private const val ATTR_PACKAGE_NAME = "packageName"
diff --git a/services/permission/java/com/android/server/permission/access/permission/UidPermissionPolicy.kt b/services/permission/java/com/android/server/permission/access/permission/UidPermissionPolicy.kt
index b2f52cc814cb..76d5ab0d3a85 100644
--- a/services/permission/java/com/android/server/permission/access/permission/UidPermissionPolicy.kt
+++ b/services/permission/java/com/android/server/permission/access/permission/UidPermissionPolicy.kt
@@ -33,7 +33,6 @@ import com.android.server.permission.access.GetStateScope
 import com.android.server.permission.access.MutateStateScope
 import com.android.server.permission.access.PermissionUri
 import com.android.server.permission.access.SchemePolicy
-import com.android.server.permission.access.SystemState
 import com.android.server.permission.access.UidUri
 import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports
 import com.android.server.permission.access.util.andInv
@@ -821,12 +820,20 @@ class UidPermissionPolicy : SchemePolicy() {
         }
     }
 
-    override fun BinaryXmlPullParser.parseSystemState(systemState: SystemState) {
-        with(persistence) { this@parseSystemState.parseSystemState(systemState) }
+    override fun BinaryXmlPullParser.parseSystemState(state: AccessState) {
+        with(persistence) { this@parseSystemState.parseSystemState(state) }
     }
 
-    override fun BinaryXmlSerializer.serializeSystemState(systemState: SystemState) {
-        with(persistence) { this@serializeSystemState.serializeSystemState(systemState) }
+    override fun BinaryXmlSerializer.serializeSystemState(state: AccessState) {
+        with(persistence) { this@serializeSystemState.serializeSystemState(state) }
+    }
+
+    override fun BinaryXmlPullParser.parseUserState(state: AccessState, userId: Int) {
+        with(persistence) { this@parseUserState.parseUserState(state, userId) }
+    }
+
+    override fun BinaryXmlSerializer.serializeUserState(state: AccessState, userId: Int) {
+        with(persistence) { this@serializeUserState.serializeUserState(state, userId) }
     }
 
     fun GetStateScope.getPermissionGroup(permissionGroupName: String): PermissionGroupInfo? =