1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/dbus/fusebox_service_provider.h"
#include <sys/stat.h>
#include "ash/constants/ash_features.h"
#include "content/public/browser/browser_thread.h"
#include "dbus/message.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
// This file provides the "D-Bus protocol logic" half of the FuseBox server,
// coupled with the "business logic" half in fusebox_server.cc.
namespace ash {
namespace {
void OnExportedCallback(const std::string& interface_name,
const std::string& method_name,
bool success) {
LOG_IF(ERROR, !success) << "Failed to export " << interface_name << "."
<< method_name;
}
template <typename T>
void ReplyToProtoMethod(dbus::MethodCall* method_call,
dbus::ExportedObject::ResponseSender sender,
const T& proto) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
std::unique_ptr<dbus::Response> response =
dbus::Response::FromMethodCall(method_call);
dbus::MessageWriter writer(response.get());
writer.AppendProtoAsArrayOfBytes(proto);
std::move(sender).Run(std::move(response));
}
} // namespace
FuseBoxServiceProvider::FuseBoxServiceProvider() : server_(this) {}
FuseBoxServiceProvider::~FuseBoxServiceProvider() = default;
void FuseBoxServiceProvider::Start(scoped_refptr<dbus::ExportedObject> object) {
exported_object_ = object;
ExportProtoMethod(fusebox::kClose2Method, &fusebox::Server::Close2);
ExportProtoMethod(fusebox::kCreateMethod, &fusebox::Server::Create);
ExportProtoMethod(fusebox::kFlushMethod, &fusebox::Server::Flush);
ExportProtoMethod(fusebox::kMkDirMethod, &fusebox::Server::MkDir);
ExportProtoMethod(fusebox::kOpen2Method, &fusebox::Server::Open2);
ExportProtoMethod(fusebox::kRead2Method, &fusebox::Server::Read2);
ExportProtoMethod(fusebox::kReadDir2Method, &fusebox::Server::ReadDir2);
ExportProtoMethod(fusebox::kRenameMethod, &fusebox::Server::Rename);
ExportProtoMethod(fusebox::kRmDirMethod, &fusebox::Server::RmDir);
ExportProtoMethod(fusebox::kStat2Method, &fusebox::Server::Stat2);
ExportProtoMethod(fusebox::kTruncateMethod, &fusebox::Server::Truncate);
ExportProtoMethod(fusebox::kUnlinkMethod, &fusebox::Server::Unlink);
ExportProtoMethod(fusebox::kWrite2Method, &fusebox::Server::Write2);
ExportProtoMethod(fusebox::kListStoragesMethod,
&fusebox::Server::ListStorages);
}
void FuseBoxServiceProvider::OnRegisterFSURLPrefix(const std::string& subdir) {
if (!exported_object_) {
return;
}
dbus::Signal signal(fusebox::kFuseBoxServiceInterface,
fusebox::kStorageAttachedSignal);
dbus::MessageWriter writer(&signal);
writer.AppendString(subdir);
exported_object_->SendSignal(&signal);
}
void FuseBoxServiceProvider::OnUnregisterFSURLPrefix(
const std::string& subdir) {
if (!exported_object_) {
return;
}
dbus::Signal signal(fusebox::kFuseBoxServiceInterface,
fusebox::kStorageDetachedSignal);
dbus::MessageWriter writer(&signal);
writer.AppendString(subdir);
exported_object_->SendSignal(&signal);
}
template <typename RequestProto, typename ResponseProto>
void FuseBoxServiceProvider::ServeProtoMethod(
ServerMethodPtr<RequestProto, ResponseProto> method,
dbus::MethodCall* method_call,
dbus::ExportedObject::ResponseSender sender) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
dbus::MessageReader reader(method_call);
RequestProto request_proto;
if (!reader.PopArrayOfBytesAsProto(&request_proto)) {
ResponseProto response_proto;
response_proto.set_posix_error_code(EINVAL);
ReplyToProtoMethod(method_call, std::move(sender), response_proto);
return;
}
(server_.*method)(request_proto,
base::BindOnce(&ReplyToProtoMethod<ResponseProto>,
method_call, std::move(sender)));
}
template <typename RequestProto, typename ResponseProto>
void FuseBoxServiceProvider::ExportProtoMethod(
const std::string& method_name,
ServerMethodPtr<RequestProto, ResponseProto> method) {
exported_object_->ExportMethod(
fusebox::kFuseBoxServiceInterface, method_name,
base::BindRepeating(
&FuseBoxServiceProvider::ServeProtoMethod<RequestProto,
ResponseProto>,
weak_ptr_factory_.GetWeakPtr(), method),
base::BindOnce(&OnExportedCallback));
}
} // namespace ash
|
