xref: /ohos5.0/foundation/filemanagement/user_file_service/services/native/file_access_service/src/file_access_service_stub.cpp

/*
 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "file_access_service_stub.h"

#include <memory>
#include <string>

#include "access_token.h"
#include "accesstoken_kit.h"
#include "file_access_framework_errno.h"
#include "file_access_service_ipc_interface_code.h"
#include "hilog_wrapper.h"
#include "hitrace_meter.h"
#include "ipc_object_stub.h"
#include "ipc_skeleton.h"
#include "user_access_tracer.h"
#include "message_parcel.h"
#include "uri.h"

namespace OHOS {
namespace FileAccessFwk {
namespace {
    const std::string FILE_ACCESS_PERMISSION = "ohos.permission.FILE_ACCESS_MANAGER";
}
FileAccessServiceStub::FileAccessServiceStub()
{
    stubFuncMap_[static_cast<uint32_t>(FileAccessServiceInterfaceCode::CMD_REGISTER_NOTIFY)] =
        &FileAccessServiceStub::CmdRegisterNotify;
    stubFuncMap_[static_cast<uint32_t>(FileAccessServiceInterfaceCode::CMD_UNREGISTER_NOTIFY)] =
        &FileAccessServiceStub::CmdUnregisterNotify;
    stubFuncMap_[static_cast<uint32_t>(FileAccessServiceInterfaceCode::CMD_ONCHANGE)] =
        &FileAccessServiceStub::CmdOnChange;
    stubFuncMap_[static_cast<uint32_t>(FileAccessServiceInterfaceCode::CMD_CONNECT_FILE_EXT_ABILITY)] =
        &FileAccessServiceStub::CmdConnectFileExtAbility;
    stubFuncMap_[static_cast<uint32_t>(FileAccessServiceInterfaceCode::CMD_DISCONNECT_FILE_EXT_ABILITY)] =
        &FileAccessServiceStub::CmdDisConnectFileExtAbility;
}

FileAccessServiceStub::~FileAccessServiceStub()
{
    stubFuncMap_.clear();
}

int32_t FileAccessServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
    MessageOption &option)
{
    UserAccessTracer trace;
    trace.Start("OnRemoteRequest");
    std::u16string descriptor = FileAccessServiceStub::GetDescriptor();
    std::u16string remoteDescriptor = data.ReadInterfaceToken();
    if (descriptor != remoteDescriptor) {
        return ERR_INVALID_STATE;
    }

    if (!CheckCallingPermission(FILE_ACCESS_PERMISSION)) {
        HILOG_ERROR("permission error");
        return E_PERMISSION;
    }

    const auto &itFunc = stubFuncMap_.find(code);
    if (itFunc != stubFuncMap_.end()) {
        return (this->*(itFunc->second))(data, reply);
    }
    return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
}

ErrCode FileAccessServiceStub::CmdOnChange(MessageParcel &data, MessageParcel &reply)
{
    UserAccessTracer trace;
    trace.Start("CmdOnChange");
    std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
    if (uri == nullptr) {
        HILOG_ERROR("UnregisterNotify uri is nullptr");
        return E_IPCS;
    }

    NotifyType notifyType = static_cast<NotifyType>(data.ReadInt32());
    int ret = OnChange(*uri, notifyType);
    if (!reply.WriteInt32(ret)) {
        HILOG_ERROR("Parameter OnChange fail to WriteInt32 ret");
        return E_IPCS;
    }

    return ret;
}

ErrCode FileAccessServiceStub::CmdRegisterNotify(MessageParcel &data, MessageParcel &reply)
{
    UserAccessTracer trace;
    trace.Start("CmdRegisterNotify");
    std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
    if (uri == nullptr) {
        HILOG_ERROR("RegisterNotify uri is nullptr");
        return E_IPCS;
    }

    sptr<IRemoteObject> obj = data.ReadRemoteObject();
    if (obj == nullptr) {
        HILOG_INFO("get remote obj fail.");
        return E_IPCS;
    }

    sptr<IFileAccessObserver> observer = iface_cast<IFileAccessObserver>(obj);
    if (observer == nullptr) {
        HILOG_INFO("get observer fail");
        return E_IPCS;
    }

    bool notifyForDescendants = data.ReadBool();
    auto connectExtensionInfo = std::make_shared<ConnectExtensionInfo>();
    if (!connectExtensionInfo->ReadFromParcel(data)) {
        HILOG_ERROR("fail to read info");
        return E_IPCS;
    }
    int ret = RegisterNotify(*uri, notifyForDescendants, observer, connectExtensionInfo);
    if (!reply.WriteInt32(ret)) {
        HILOG_ERROR("Parameter RegisterNotify fail to WriteInt32 ret");
        return E_IPCS;
    }
    return ERR_OK;
}

ErrCode FileAccessServiceStub::CmdUnregisterNotify(MessageParcel &data, MessageParcel &reply)
{
    UserAccessTracer trace;
    trace.Start("CmdUnregisterNotify");
    std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
    if (uri == nullptr) {
        HILOG_ERROR("UnregisterNotify uri is nullptr");
        return E_IPCS;
    }

    bool observerNotNull = data.ReadBool();
    int ret = E_IPCS;
    if (observerNotNull) {
        sptr<IRemoteObject> obj = data.ReadRemoteObject();
        if (obj == nullptr) {
            HILOG_ERROR("get remote obj fail.");
            return E_IPCS;
        }

        sptr<IFileAccessObserver> observer = iface_cast<IFileAccessObserver>(obj);
        if (observer == nullptr) {
            HILOG_ERROR("get observer fail");
            return E_IPCS;
        }

        auto connectExtensionInfo = std::make_shared<ConnectExtensionInfo>();
        if (!connectExtensionInfo->ReadFromParcel(data)) {
            HILOG_ERROR("fail to read info");
            return E_IPCS;
        }
        ret = UnregisterNotify(*uri, observer, connectExtensionInfo);
    } else {
        auto connectExtensionInfo = std::make_shared<ConnectExtensionInfo>();
        if (!connectExtensionInfo->ReadFromParcel(data)) {
            HILOG_ERROR("fail to read info");
            return E_IPCS;
        }
        ret = CleanAllNotify(*uri, connectExtensionInfo);
    }

    if (!reply.WriteInt32(ret)) {
        HILOG_ERROR("Parameter UnregisterNotify fail to WriteInt32 ret");
        return E_IPCS;
    }
    return ERR_OK;
}

bool FileAccessServiceStub::CheckCallingPermission(const std::string &permission)
{
    UserAccessTracer trace;
    trace.Start("CheckCallingPermission");
    Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
    int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permission);
    if (res != Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
        HILOG_ERROR("FileAccessExtStub::CheckCallingPermission have no fileAccess permission");
        return false;
    }

    return true;
}

ErrCode FileAccessServiceStub::CmdConnectFileExtAbility(MessageParcel &data, MessageParcel &reply)
{
    UserAccessTracer trace;
    trace.Start("CmdConnectFileExtAbility");
    std::shared_ptr<AAFwk::Want> wantPtr(data.ReadParcelable<AAFwk::Want>());
    if (wantPtr == nullptr) {
        return E_IPCS;
    }
    AAFwk::Want want = AAFwk::Want(*wantPtr);

    sptr<AAFwk::IAbilityConnection> connection = iface_cast<AAFwk::IAbilityConnection>(data.ReadRemoteObject());
    if (!connection) {
        HILOG_ERROR("fail to read connection");
        return E_IPCS;
    }

    int ret = ConnectFileExtAbility(want, connection);
    if (!reply.WriteInt32(ret)) {
        HILOG_ERROR("fail to CmdConnectFileExtAbility");
        return E_IPCS;
    }

    return ERR_OK;
}


ErrCode FileAccessServiceStub::CmdDisConnectFileExtAbility(MessageParcel &data, MessageParcel &reply)
{
    UserAccessTracer trace;
    trace.Start("CmdDisConnectFileExtAbility");
    sptr<AAFwk::IAbilityConnection> connection = iface_cast<AAFwk::IAbilityConnection>(data.ReadRemoteObject());
    if (!connection) {
        HILOG_ERROR("fail to read connection");
        return E_IPCS;
    }

    int ret = DisConnectFileExtAbility(connection);
    if (!reply.WriteInt32(ret)) {
        HILOG_ERROR("fail to CmdDisConnectFileExtAbility");
        return E_IPCS;
    }

    return ERR_OK;
}

ErrCode FileAccessServiceStub::CmdGetExensionProxy(MessageParcel &data, MessageParcel &reply)
{
    UserAccessTracer trace;
    trace.Start("CmdGetExensionProxy");
    std::shared_ptr<ConnectExtensionInfo> connectExtensionInfo = std::make_shared<ConnectExtensionInfo>();
    if (!connectExtensionInfo->ReadFromParcel(data)) {
        HILOG_ERROR("fail to read info");
        return E_IPCS;
    }

    sptr<IFileAccessExtBase> extensionProxy;
    int ret = GetExtensionProxy(connectExtensionInfo, extensionProxy);
    if (!reply.WriteInt32(ret) || extensionProxy == nullptr) {
        HILOG_ERROR("fail to GetExtensionProxy");
        return E_IPCS;
    }
    if (!reply.WriteRemoteObject(extensionProxy->AsObject())) {
        HILOG_ERROR("fail to WriteRemoteObject observer");
        return E_IPCS;
    }
    return ERR_OK;
}
} // namespace FileAccessFwk
} // namespace OHOS