diff --git a/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp b/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp
index 07799948ce562cb3f8ec95fb82d83b790a37a70d..5d7edbdd276b5e20ac3d56381cf20ae85e844fd1 100644
--- a/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp
+++ b/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp
@@ -20,6 +20,7 @@
 #include "log_print.h"
 #include "softbus_adapter.h"
 #include "process_communicator_impl.h"
+#include "utils/anonymous.h"
 namespace OHOS {
 namespace AppDistributedKv {
 using namespace DistributedDB;
@@ -250,10 +251,8 @@ std::shared_ptr<ExtendHeaderHandle> ProcessCommunicatorImpl::GetExtendHeaderHand
     return {};
 }
 
-DBStatus ProcessCommunicatorImpl::CheckAndGetDataHeadInfo(
-    const uint8_t *data, uint32_t dataLen, uint32_t &headLen, std::vector<std::string> &users)
+DBStatus ProcessCommunicatorImpl::GetDataHeadInfo(const uint8_t *data, uint32_t totalLen, uint32_t &headLength)
 {
-    ZLOGD("begin");
     if (routeHeadHandlerCreator_ == nullptr) {
         ZLOGE("header handler creator not registered");
         return DBStatus::DB_ERROR;
@@ -263,16 +262,36 @@ DBStatus ProcessCommunicatorImpl::CheckAndGetDataHeadInfo(
         ZLOGE("failed to get header handler");
         return DBStatus::DB_ERROR;
     }
-    auto ret = handler->ParseHeadData(data, dataLen, headLen, users);
+    auto ret = handler->ParseHeadDataLen(data, totalLen, headLength);
     if (!ret) {
-        ZLOGD("illegal head format");
+        ZLOGE("illegal head format, dataLen:%{public}u, headLength:%{public}u", totalLen, headLength);
         return DBStatus::INVALID_FORMAT;
     }
-    if (users.empty()) {
+    return DBStatus::OK;
+}
+
+DBStatus ProcessCommunicatorImpl::GetDataUserInfo(const uint8_t *data, uint32_t totalLen, const std::string &label,
+    std::vector<UserInfo> &userInfos)
+{
+    if (routeHeadHandlerCreator_ == nullptr) {
+        ZLOGE("header handler creator not registered");
+        return DBStatus::DB_ERROR;
+    }
+    auto handler = routeHeadHandlerCreator_({});
+    if (handler == nullptr) {
+        ZLOGE("failed to get header handler");
+        return DBStatus::DB_ERROR;
+    }
+    auto ret = handler->ParseHeadDataUser(data, totalLen, label, userInfos);
+    if (!ret) {
+        ZLOGD("illegal head format, dataLen:%{public}u, label:%{public}s", totalLen, Anonymous::Change(label).c_str());
+        return DBStatus::INVALID_FORMAT;
+    }
+    if (userInfos.empty()) {
         ZLOGW("no valid user");
         return DBStatus::NO_PERMISSION;
     }
-    ZLOGD("ok, result:%{public}zu, user:%{public}s", users.size(), users.front().c_str());
+    ZLOGD("ok, userInfos.size:%{public}zu", userInfos.size());
     return DBStatus::OK;
 }
 
diff --git a/services/distributeddataservice/adapter/include/communicator/process_communicator_impl.h b/services/distributeddataservice/adapter/include/communicator/process_communicator_impl.h
index a196c69b0d427501ab360f6fb77a34917392f3e3..41df2779ca613a79431125ec807a3954320a9ba6 100644
--- a/services/distributeddataservice/adapter/include/communicator/process_communicator_impl.h
+++ b/services/distributeddataservice/adapter/include/communicator/process_communicator_impl.h
@@ -33,6 +33,7 @@ public:
     using OnDataReceive = DistributedDB::OnDataReceive;
     using OnSendAble = DistributedDB::OnSendAble;
     using DeviceInfos = DistributedDB::DeviceInfos;
+    using UserInfo = DistributedDB::UserInfo;
     using RouteHeadHandlerCreator =
         std::function<std::shared_ptr<DistributedData::RouteHeadHandler>(const DistributedDB::ExtendInfo &info)>;
 
@@ -61,8 +62,9 @@ public:
 
     API_EXPORT std::shared_ptr<DistributedDB::ExtendHeaderHandle> GetExtendHeaderHandle(
         const DistributedDB::ExtendInfo &info) override;
-    API_EXPORT DBStatus CheckAndGetDataHeadInfo(
-        const uint8_t *data, uint32_t dataLen, uint32_t &headLen, std::vector<std::string> &users) override;
+    API_EXPORT DBStatus GetDataHeadInfo(const uint8_t *data, uint32_t totalLen, uint32_t &headLength) override;
+    API_EXPORT DBStatus GetDataUserInfo(const uint8_t *data, uint32_t totalLen, const std::string &label,
+        std::vector<UserInfo> &userInfos) override;
 
     Status ReuseConnect(const DeviceId &deviceId);
 
diff --git a/services/distributeddataservice/adapter/include/communicator/route_head_handler.h b/services/distributeddataservice/adapter/include/communicator/route_head_handler.h
index f31eea2db267e3d48b87bed4d392c7cc38bb9408..47596818d46374ad76acf0cdc8b2ac703e2d5d3d 100644
--- a/services/distributeddataservice/adapter/include/communicator/route_head_handler.h
+++ b/services/distributeddataservice/adapter/include/communicator/route_head_handler.h
@@ -24,9 +24,11 @@ class RouteHeadHandler : public DistributedDB::ExtendHeaderHandle {
 public:
     using ExtendInfo = DistributedDB::ExtendInfo;
     using DBStatus = DistributedDB::DBStatus;
+    using UserInfo = DistributedDB::UserInfo;
 
-    virtual bool ParseHeadData(
-        const uint8_t *data, uint32_t totalLen, uint32_t &headSize, std::vector<std::string> &users) = 0;
+    virtual bool ParseHeadDataLen(const uint8_t *data, uint32_t totalLen, uint32_t &headSize) = 0;
+    virtual bool ParseHeadDataUser(const uint8_t *data, uint32_t totalLen, const std::string &label,
+        std::vector<UserInfo> &userInfos) = 0;
 };
 } // namespace OHOS::DistributedData
 #endif // DISTRIBUTEDDATAMGR_EXTEND_HEAD_HANDLER_H
diff --git a/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp b/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp
index d602b206c82f3f0824c67076fef43e23fad95ba6..f52cde722d9237a3e8c28bf215cee5d9ca0bdb2e 100644
--- a/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp
+++ b/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp
@@ -17,6 +17,7 @@
 #define LOG_TAG "RouteHeadHandler"
 #include <chrono>
 #include <cinttypes>
+#include "account/account_delegate.h"
 #include "auth_delegate.h"
 #include "device_manager_adapter.h"
 #include "kvstore_meta_manager.h"
@@ -33,6 +34,7 @@ namespace OHOS::DistributedData {
 using namespace OHOS::DistributedKv;
 using namespace std::chrono;
 using DmAdapter = DistributedData::DeviceManagerAdapter;
+using DBManager = DistributedDB::KvStoreDelegateManager;
 constexpr const int ALIGN_WIDTH = 8;
 constexpr const char *DEFAULT_USERID = "0";
 std::shared_ptr<RouteHeadHandler> RouteHeadHandlerImpl::Create(const ExtendInfo &info)
@@ -59,8 +61,19 @@ void RouteHeadHandlerImpl::Init()
     if (deviceId_.empty()) {
         return;
     }
-    if (!DmAdapter::GetInstance().IsOHOSType(deviceId_) && userId_ != DEFAULT_USERID) {
-        userId_ = DEFAULT_USERID;
+    if (userId_ != DEFAULT_USERID) {
+        if (!DmAdapter::GetInstance().IsOHOSType(deviceId_)) {
+            userId_ = DEFAULT_USERID;
+        } else {
+            StoreMetaData metaData;
+            metaData.deviceId = deviceId_;
+            metaData.user = DEFAULT_USERID;
+            metaData.bundleName = appId_;
+            metaData.storeId = storeId_;
+            if (MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData)) {
+                userId_ = DEFAULT_USERID;
+            }
+        }
     }
     SessionPoint localPoint { DmAdapter::GetInstance().GetLocalDevice().uuid,
         static_cast<uint32_t>(atoi(userId_.c_str())), appId_, storeId_ };
@@ -194,17 +207,65 @@ bool RouteHeadHandlerImpl::PackDataBody(uint8_t *data, uint32_t totalLen)
     return true;
 }
 
-bool RouteHeadHandlerImpl::ParseHeadData(
-    const uint8_t *data, uint32_t len, uint32_t &headSize, std::vector<std::string> &users)
+bool RouteHeadHandlerImpl::ParseHeadDataLen(const uint8_t *data, uint32_t totalLen, uint32_t &headSize)
+{
+    if (data == nullptr) {
+        ZLOGE("invalid input data, totalLen:%{public}d", totalLen);
+        return false;
+    }
+    RouteHead head = { 0 };
+    auto ret = UnPackDataHead(data, totalLen, head);
+    headSize = ret ? sizeof(RouteHead) + head.dataLen : 0;
+    ZLOGI("unpacked data size:%{public}u, ret:%{public}d", headSize, ret);
+    return ret;
+}
+
+std::string RouteHeadHandlerImpl::ParseStoreId(const std::string &deviceId, const std::string &label)
+{
+    std::vector<StoreMetaData> metaData;
+    auto prefix = StoreMetaData::GetPrefix({ deviceId });
+    if (!MetaDataManager::GetInstance().LoadMeta(prefix, metaData)) {
+        return "";
+    }
+    for (const auto &storeMeta : metaData) {
+        auto labelTag = DBManager::GetKvStoreIdentifier("", storeMeta.appId, storeMeta.storeId, true);
+        if (labelTag != label) {
+            continue;
+        }
+        return storeMeta.storeId;
+    }
+    return "";
+}
+
+bool RouteHeadHandlerImpl::ParseHeadDataUser(const uint8_t *data, uint32_t totalLen, const std::string &label,
+    std::vector<UserInfo> &userInfos)
 {
-    auto ret = UnPackData(data, len, headSize);
+    uint32_t headSize = 0;
+    auto ret = UnPackData(data, totalLen, headSize);
     if (!ret) {
-        headSize = 0;
         return false;
     }
-    auto time =
-        static_cast<uint64_t>(duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count());
+    auto time = static_cast<uint64_t>(duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count());
     ZLOGI("unpacked size:%{public}u times %{public}" PRIu64 ".", headSize, time);
+
+    if (DmAdapter::GetInstance().IsOHOSType(session_.sourceDeviceId)) {
+        auto storeId = ParseStoreId(session_.targetDeviceId, label);
+        if (!storeId.empty() && std::to_string(session_.sourceUserId) == DEFAULT_USERID) {
+            StoreMetaData metaData;
+            metaData.deviceId = session_.targetDeviceId;
+            metaData.user = DEFAULT_USERID;
+            metaData.bundleName = session_.appId;
+            metaData.storeId = storeId;
+            if (!MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData)) {
+                int foregroundUserId = 0;
+                AccountDelegate::GetInstance()->QueryForegroundUserId(foregroundUserId);
+                UserInfo userInfo = { .receiveUser = std::to_string(foregroundUserId) };
+                userInfos.emplace_back(userInfo);
+                return true;
+            }
+        }
+    }
+
     // flip the local and peer ends
     SessionPoint local { .deviceId = session_.targetDeviceId, .appId = session_.appId };
     SessionPoint peer { .deviceId = session_.sourceDeviceId, .userId = session_.sourceUserId, .appId = session_.appId };
@@ -214,7 +275,8 @@ bool RouteHeadHandlerImpl::ParseHeadData(
     for (const auto &item : session_.targetUserIds) {
         local.userId = item;
         if (SessionManager::GetInstance().CheckSession(local, peer)) {
-            users.emplace_back(std::to_string(item));
+            UserInfo userInfo = { .receiveUser = std::to_string(item) };
+            userInfos.emplace_back(userInfo);
         }
     }
     return true;
diff --git a/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.h b/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.h
index 4cc31add514b633d59ceaf8438f49d952f4c2368..f23360dd7341b4a6430c6d6a30099122b5c0ffc0 100644
--- a/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.h
+++ b/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.h
@@ -61,7 +61,9 @@ public:
     explicit RouteHeadHandlerImpl(const ExtendInfo &info);
     DBStatus GetHeadDataSize(uint32_t &headSize) override;
     DBStatus FillHeadData(uint8_t *data, uint32_t headSize, uint32_t totalLen) override;
-    bool ParseHeadData(const uint8_t *data, uint32_t len, uint32_t &headSize, std::vector<std::string> &users) override;
+    bool ParseHeadDataLen(const uint8_t *data, uint32_t totalLen, uint32_t &headSize) override;
+    bool ParseHeadDataUser(const uint8_t *data, uint32_t totalLen, const std::string &label,
+        std::vector<UserInfo> &userInfos) override;
 
 private:
     void Init();
@@ -71,6 +73,7 @@ private:
     bool UnPackData(const uint8_t *data, uint32_t totalLen, uint32_t &unpackedSize);
     bool UnPackDataHead(const uint8_t *data, uint32_t totalLen, RouteHead &routeHead);
     bool UnPackDataBody(const uint8_t *data, uint32_t totalLen);
+    std::string ParseStoreId(const std::string &deviceId, const std::string &label);
 
     std::string userId_;
     std::string appId_;
diff --git a/services/distributeddataservice/app/src/session_manager/session_manager.cpp b/services/distributeddataservice/app/src/session_manager/session_manager.cpp
index 3fd3f6a520bd7f128d0a34bde258bd0b82bf8fa3..d8a68efa63db19d6f583fe7c53f8672cad809729 100644
--- a/services/distributeddataservice/app/src/session_manager/session_manager.cpp
+++ b/services/distributeddataservice/app/src/session_manager/session_manager.cpp
@@ -49,15 +49,7 @@ Session SessionManager::GetSession(const SessionPoint &from, const std::string &
     auto users = UserDelegate::GetInstance().GetRemoteUserStatus(targetDeviceId);
     // system service
     if (from.userId == UserDelegate::SYSTEM_USER) {
-        StoreMetaData metaData;
-        metaData.deviceId = from.deviceId;
-        metaData.user = std::to_string(from.userId);
-        metaData.bundleName = from.appId;
-        metaData.storeId = from.storeId;
-        if (MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData) &&
-            CheckerManager::GetInstance().GetAppId(Converter::ConvertToStoreInfo(metaData)) == from.appId) {
-            session.targetUserIds.push_back(UserDelegate::SYSTEM_USER);
-        }
+        session.targetUserIds.push_back(UserDelegate::SYSTEM_USER);
     }
     
     AclParams aclParams;
diff --git a/services/distributeddataservice/app/test/unittest/session_manager_test.cpp b/services/distributeddataservice/app/test/unittest/session_manager_test.cpp
index 96fa8ca77c257a42bb9749b9b1ccc184992b25ec..8031dc6c64107682bd434dfcaadd6fa5064d5933 100644
--- a/services/distributeddataservice/app/test/unittest/session_manager_test.cpp
+++ b/services/distributeddataservice/app/test/unittest/session_manager_test.cpp
@@ -148,12 +148,13 @@ HWTEST_F(SessionManagerTest, PackAndUnPack01, TestSize.Level2)
     std::unique_ptr<uint8_t[]> data = std::make_unique<uint8_t[]>(routeHeadSize);
     sendHandler->FillHeadData(data.get(), routeHeadSize, routeHeadSize);
 
-    std::vector<std::string> users;
+    std::vector<DistributedDB::UserInfo> users;
     auto recvHandler = RouteHeadHandlerImpl::Create({});
     ASSERT_NE(recvHandler, nullptr);
     uint32_t parseSize = 1;
-    recvHandler->ParseHeadData(data.get(), routeHeadSize, parseSize, users);
+    recvHandler->ParseHeadDataLen(data.get(), routeHeadSize, parseSize);
     EXPECT_EQ(routeHeadSize, parseSize);
+    recvHandler->ParseHeadDataUser(data.get(), routeHeadSize, "", users);
     ASSERT_EQ(users.size(), 0);
 }
 } // namespace
\ No newline at end of file