diff --git a/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp b/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp
index 07799948ce562cb3f8ec95fb82d83b790a37a70d..1465eb3f3e8bdf07196ad7f99a7bb5b68a8956bd 100644
--- a/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp
+++ b/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp
@@ -17,6 +17,7 @@
 
 #include "communicator_context.h"
 #include "device_manager_adapter.h"
+#include "kv_store_delegate_manager.h"
 #include "log_print.h"
 #include "softbus_adapter.h"
 #include "process_communicator_impl.h"
@@ -276,6 +277,50 @@ DBStatus ProcessCommunicatorImpl::CheckAndGetDataHeadInfo(
     return DBStatus::OK;
 }
 
+//DBStatus ProcessCommunicatorImpl::GetDataHeadInfo(const uint8_t *data, uint32_t dataLen, uint32_t &headLen)
+//{
+//    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->ParseHeadDataLen(data, dataLen, headLen);
+//    if (!ret) {
+//        ZLOGE("illegal head format, dataLen:%{public}u, headLen:%{public}u", dataLen, headLen);
+//        return DBStatus::INVALID_FORMAT;
+//    }
+//    return DBStatus::OK;
+//}
+//
+//DBStatus ProcessCommunicatorImpl::GetDataUserInfo(const uint8_t *data, uint32_t dataLen, const std::string &label,
+//    std::string &userId)
+//{
+//    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, dataLen, label, userId);
+//    if (!ret) {
+//        ZLOGD("illegal head format, dataLen:%{public}u, label:%{public}d", dataLen, Anonymous::Change(label).c_str());
+//        return DBStatus::INVALID_FORMAT;
+//    }
+//    if (users.empty()) {
+//        ZLOGW("no valid user");
+//        return DBStatus::NO_PERMISSION;
+//    }
+//    ZLOGD("ok, result:%{public}zu, user:%{public}s", users.size(), users.front().c_str());
+//    return DBStatus::OK;
+//}
+
 Status ProcessCommunicatorImpl::ReuseConnect(const DeviceId &deviceId)
 {
     PipeInfo pi = {thisProcessLabel_, ""};
diff --git a/services/distributeddataservice/adapter/include/communicator/process_communicator_impl.h b/services/distributeddataservice/adapter/include/communicator/process_communicator_impl.h
index a196c69b0d427501ab360f6fb77a34917392f3e3..66db8f29cce5f35e71583480dd528d7e42d7e25d 100644
--- a/services/distributeddataservice/adapter/include/communicator/process_communicator_impl.h
+++ b/services/distributeddataservice/adapter/include/communicator/process_communicator_impl.h
@@ -61,6 +61,9 @@ public:
 
     API_EXPORT std::shared_ptr<DistributedDB::ExtendHeaderHandle> GetExtendHeaderHandle(
         const DistributedDB::ExtendInfo &info) override;
+//    API_EXPORT DBStatus GetDataHeadInfo(const uint8_t *data, uint32_t dataLen, uint32_t &headLen) override;
+//    API_EXPORT DBStatus GetDataUserInfo(const uint8_t *data, uint32_t dataLen, const std::string &label,
+//        std::string &userId) override;
     API_EXPORT DBStatus CheckAndGetDataHeadInfo(
         const uint8_t *data, uint32_t dataLen, uint32_t &headLen, std::vector<std::string> &users) override;
 
diff --git a/services/distributeddataservice/adapter/include/communicator/route_head_handler.h b/services/distributeddataservice/adapter/include/communicator/route_head_handler.h
index f31eea2db267e3d48b87bed4d392c7cc38bb9408..089ec0c188a34274f214fec9f38e1600b16412ee 100644
--- a/services/distributeddataservice/adapter/include/communicator/route_head_handler.h
+++ b/services/distributeddataservice/adapter/include/communicator/route_head_handler.h
@@ -25,6 +25,9 @@ public:
     using ExtendInfo = DistributedDB::ExtendInfo;
     using DBStatus = DistributedDB::DBStatus;
 
+    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::string &userId) = 0;
     virtual bool ParseHeadData(
         const uint8_t *data, uint32_t totalLen, uint32_t &headSize, std::vector<std::string> &users) = 0;
 };
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..37cf9029de6665f0e95e96a33f44a86916c6eb8f 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)
@@ -62,6 +64,14 @@ void RouteHeadHandlerImpl::Init()
     if (!DmAdapter::GetInstance().IsOHOSType(deviceId_) && userId_ != DEFAULT_USERID) {
         userId_ = DEFAULT_USERID;
     }
+    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_ };
     session_ = SessionManager::GetInstance().GetSession(localPoint, deviceId_);
@@ -194,6 +204,79 @@ bool RouteHeadHandlerImpl::PackDataBody(uint8_t *data, uint32_t totalLen)
     return true;
 }
 
+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::string &userId)
+{
+    uint32_t headSize = 0;
+    auto ret = UnPackData(data, len, headSize);
+    if (!ret) {
+        return false;
+    }
+    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);
+                users.emplace_back(std::to_string(foregroundUserId));
+                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 };
+    ZLOGD("valid session:appId:%{public}s, srcDevId:%{public}s, srcUser:%{public}u, trgDevId:%{public}s,",
+          session_.appId.c_str(), Anonymous::Change(session_.sourceDeviceId).c_str(),
+          session_.sourceUserId, Anonymous::Change(session_.targetDeviceId).c_str());
+    for (const auto &item : session_.targetUserIds) {
+        local.userId = item;
+        if (SessionManager::GetInstance().CheckSession(local, peer)) {
+            users.emplace_back(std::to_string(item));
+        }
+    }
+    return true;
+}
+
 bool RouteHeadHandlerImpl::ParseHeadData(
     const uint8_t *data, uint32_t len, uint32_t &headSize, std::vector<std::string> &users)
 {
@@ -211,6 +294,19 @@ bool RouteHeadHandlerImpl::ParseHeadData(
     ZLOGD("valid session:appId:%{public}s, srcDevId:%{public}s, srcUser:%{public}u, trgDevId:%{public}s,",
           session_.appId.c_str(), Anonymous::Change(session_.sourceDeviceId).c_str(),
           session_.sourceUserId, Anonymous::Change(session_.targetDeviceId).c_str());
+    if (std::to_string(peer.userId) == DEFAULT_USERID) {
+        StoreMetaData metaData;
+        metaData.deviceId = local.deviceId;
+        metaData.user = peer.userId;
+        metaData.bundleName = local.appId;
+        metaData.storeId = local.storeId;
+        if (!MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData)) {
+            int foregroundUserId = 0;
+            AccountDelegate::GetInstance()->QueryForegroundUserId(foregroundUserId);
+            users.emplace_back(std::to_string(foregroundUserId));
+            return true;
+        }
+    }
     for (const auto &item : session_.targetUserIds) {
         local.userId = item;
         if (SessionManager::GetInstance().CheckSession(local, peer)) {
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..0e99e11df4e5d4489611e7fa805d75c3ed623b79 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,6 +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 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::string &userId) override;
     bool ParseHeadData(const uint8_t *data, uint32_t len, uint32_t &headSize, std::vector<std::string> &users) override;
 
 private:
@@ -71,6 +74,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;