1 //
2 // Copyright 2015 Google, Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at:
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include "service/ipc/ipc_handler_linux.h"
18
19 #include <sys/socket.h>
20 #include <sys/un.h>
21
22 #include <base/bind.h>
23
24 #include "osi/include/socket_utils/sockets.h"
25 #include "service/daemon.h"
26 #include "service/ipc/linux_ipc_host.h"
27 #include "service/settings.h"
28
29 namespace ipc {
30
IPCHandlerLinux(bluetooth::Adapter * adapter,IPCManager::Delegate * delegate)31 IPCHandlerLinux::IPCHandlerLinux(bluetooth::Adapter* adapter,
32 IPCManager::Delegate* delegate)
33 : IPCHandler(adapter, delegate),
34 running_(false),
35 thread_("IPCHandlerLinux"),
36 keep_running_(true) {}
37
~IPCHandlerLinux()38 IPCHandlerLinux::~IPCHandlerLinux() {
39 // This will only be set if the Settings::create_ipc_socket_path() was
40 // originally provided.
41 if (!socket_path_.empty()) unlink(socket_path_.value().c_str());
42 }
43
Run()44 bool IPCHandlerLinux::Run() {
45 CHECK(!running_);
46
47 const std::string& android_suffix =
48 bluetooth::Daemon::Get()->GetSettings()->android_ipc_socket_suffix();
49 const base::FilePath& path =
50 bluetooth::Daemon::Get()->GetSettings()->create_ipc_socket_path();
51
52 // Both flags cannot be set at the same time.
53 CHECK(android_suffix.empty() || path.empty());
54 if (android_suffix.empty() && path.empty()) {
55 LOG(ERROR) << "No domain socket path provided";
56 return false;
57 }
58
59 CHECK(base::MessageLoop::current()); // An origin event loop is required.
60 origin_task_runner_ = base::MessageLoop::current()->task_runner();
61
62 if (!android_suffix.empty()) {
63 int server_fd = osi_android_get_control_socket(android_suffix.c_str());
64 if (server_fd == -1) {
65 LOG(ERROR) << "Unable to get Android socket from: " << android_suffix;
66 return false;
67 }
68 LOG(INFO) << "Binding to Android server socket:" << android_suffix;
69 socket_.reset(server_fd);
70 } else {
71 LOG(INFO) << "Creating a Unix domain socket:" << path.value();
72
73 // TODO(armansito): This is opens the door to potentially unlinking files in
74 // the current directory that we're not supposed to. For now we will have an
75 // assumption that the daemon runs in a sandbox but we should generally do
76 // this properly.
77 unlink(path.value().c_str());
78
79 base::ScopedFD server_socket(socket(PF_UNIX, SOCK_SEQPACKET, 0));
80 if (!server_socket.is_valid()) {
81 LOG(ERROR) << "Failed to open domain socket for IPC";
82 return false;
83 }
84
85 struct sockaddr_un address;
86 memset(&address, 0, sizeof(address));
87 address.sun_family = AF_UNIX;
88 strncpy(address.sun_path, path.value().c_str(),
89 sizeof(address.sun_path) - 1);
90 if (bind(server_socket.get(), (struct sockaddr*)&address, sizeof(address)) <
91 0) {
92 PLOG(ERROR) << "Failed to bind IPC socket to address";
93 return false;
94 }
95
96 socket_.swap(server_socket);
97 socket_path_ = path;
98 }
99
100 CHECK(socket_.is_valid());
101
102 running_ = true; // Set this here before launching the thread.
103
104 // Start an IO thread and post the listening task.
105 base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
106 if (!thread_.StartWithOptions(options)) {
107 LOG(ERROR) << "Failed to start IPCHandlerLinux thread";
108 running_ = false;
109 return false;
110 }
111
112 thread_.task_runner()->PostTask(
113 FROM_HERE, base::Bind(&IPCHandlerLinux::StartListeningOnThread, this));
114
115 return true;
116 }
117
Stop()118 void IPCHandlerLinux::Stop() {
119 keep_running_ = false;
120
121 // At this moment the listening thread might be blocking on the accept
122 // syscall. Shutdown and close the server socket before joining the thread to
123 // interrupt accept so that the main thread doesn't keep blocking.
124 shutdown(socket_.get(), SHUT_RDWR);
125 socket_.reset();
126
127 // Join and clean up the thread.
128 thread_.Stop();
129
130 // Thread exited. Notify the delegate. Post this on the event loop so that the
131 // callback isn't reentrant.
132 NotifyStoppedOnOriginThread();
133 }
134
StartListeningOnThread()135 void IPCHandlerLinux::StartListeningOnThread() {
136 CHECK(socket_.is_valid());
137 CHECK(adapter());
138 CHECK(running_);
139
140 LOG(INFO) << "Listening to incoming connections";
141
142 int status = listen(socket_.get(), SOMAXCONN);
143 if (status < 0) {
144 PLOG(ERROR) << "Failed to listen on domain socket";
145 origin_task_runner_->PostTask(
146 FROM_HERE, base::Bind(&IPCHandlerLinux::ShutDownOnOriginThread, this));
147 return;
148 }
149
150 NotifyStartedOnOriginThread();
151
152 // TODO(armansito): The code below can cause the daemon to run indefinitely if
153 // the thread is joined while it's in the middle of the EventLoop() call. The
154 // EventLoop() won't exit until a client terminates the connection, however
155 // this can be fixed by using the |thread_|'s MessageLoopForIO instead (since
156 // it gets stopped along with the thread).
157 // TODO(icoolidge): accept simultaneous clients
158 while (keep_running_.load()) {
159 int client_socket = accept4(socket_.get(), nullptr, nullptr, SOCK_NONBLOCK);
160 if (client_socket < 0) {
161 PLOG(ERROR) << "Failed to accept client connection";
162 continue;
163 }
164
165 LOG(INFO) << "Established client connection: fd=" << client_socket;
166
167 LinuxIPCHost ipc_host(client_socket, adapter());
168
169 // TODO(armansito): Use |thread_|'s MessageLoopForIO instead of using a
170 // custom event loop to poll from the socket.
171 ipc_host.EventLoop();
172 }
173 }
174
ShutDownOnOriginThread()175 void IPCHandlerLinux::ShutDownOnOriginThread() {
176 LOG(INFO) << "Shutting down IPCHandlerLinux thread";
177 thread_.Stop();
178 running_ = false;
179
180 NotifyStoppedOnCurrentThread();
181 }
182
NotifyStartedOnOriginThread()183 void IPCHandlerLinux::NotifyStartedOnOriginThread() {
184 if (!delegate()) return;
185
186 origin_task_runner_->PostTask(
187 FROM_HERE,
188 base::Bind(&IPCHandlerLinux::NotifyStartedOnCurrentThread, this));
189 }
190
NotifyStartedOnCurrentThread()191 void IPCHandlerLinux::NotifyStartedOnCurrentThread() {
192 if (delegate()) delegate()->OnIPCHandlerStarted(IPCManager::TYPE_LINUX);
193 }
194
NotifyStoppedOnOriginThread()195 void IPCHandlerLinux::NotifyStoppedOnOriginThread() {
196 if (!delegate()) return;
197
198 origin_task_runner_->PostTask(
199 FROM_HERE,
200 base::Bind(&IPCHandlerLinux::NotifyStoppedOnCurrentThread, this));
201 }
202
NotifyStoppedOnCurrentThread()203 void IPCHandlerLinux::NotifyStoppedOnCurrentThread() {
204 if (delegate()) delegate()->OnIPCHandlerStopped(IPCManager::TYPE_LINUX);
205 }
206
207 } // namespace ipc
208