1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // TODO(jamiewalch): Add unit tests for this.
6
7 #include "remoting/host/posix/signal_handler.h"
8
9 #include <errno.h>
10 #include <signal.h>
11
12 #include <list>
13 #include <utility>
14
15 #include "base/compiler_specific.h"
16 #include "base/message_loop/message_loop.h"
17 #include "base/message_loop/message_pump_libevent.h"
18 #include "base/posix/eintr_wrapper.h"
19 #include "base/threading/platform_thread.h"
20
21 namespace remoting {
22 namespace {
23
24 class SignalListener : public base::MessagePumpLibevent::Watcher {
25 public:
26 SignalListener();
27
28 void AddSignalHandler(int signal, const SignalHandler& handler);
29
30 virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
OnFileCanWriteWithoutBlocking(int fd)31 virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {}
32
33 // WatchFileDescriptor needs a controller through which the operation can be
34 // canceled. We don't use it, but this is as good a place as any to store it.
35 base::MessagePumpLibevent::FileDescriptorWatcher controller;
36
37 private:
38 typedef std::pair<int, SignalHandler> SignalAndHandler;
39 typedef std::list<SignalAndHandler> SignalHandlers;
40 SignalHandlers signal_handlers_;
41 };
42
SignalListener()43 SignalListener::SignalListener() {
44 }
45
AddSignalHandler(int signal,const SignalHandler & handler)46 void SignalListener::AddSignalHandler(int signal,
47 const SignalHandler& handler) {
48 signal_handlers_.push_back(SignalAndHandler(signal, handler));
49 }
50
OnFileCanReadWithoutBlocking(int fd)51 void SignalListener::OnFileCanReadWithoutBlocking(int fd) {
52 char buffer;
53 int result = HANDLE_EINTR(read(fd, &buffer, sizeof(buffer)));
54 if (result > 0) {
55 for (SignalHandlers::const_iterator i = signal_handlers_.begin();
56 i != signal_handlers_.end();
57 ++i) {
58 if (i->first == buffer) {
59 i->second.Run(i->first);
60 }
61 }
62 }
63 }
64
65 SignalListener* g_signal_listener = NULL;
66 int g_write_fd = 0;
67
GlobalSignalHandler(int signal)68 void GlobalSignalHandler(int signal) {
69 char byte = signal;
70 int r ALLOW_UNUSED = write(g_write_fd, &byte, 1);
71 }
72
73 } // namespace
74
75 // RegisterSignalHandler registers a signal handler that writes a byte to a
76 // pipe each time a signal is received. The read end of the pipe is registered
77 // with the current MessageLoop (which must be of type IO); whenever the pipe
78 // is readable, it invokes the specified callback.
79 //
80 // This arrangement is required because the set of system APIs that are safe to
81 // call from a signal handler is very limited (but does include write).
RegisterSignalHandler(int signal_number,const SignalHandler & handler)82 bool RegisterSignalHandler(int signal_number, const SignalHandler& handler) {
83 CHECK(signal_number < 256); // Don't want to worry about multi-byte writes.
84 if (!g_signal_listener) {
85 g_signal_listener = new SignalListener();
86 }
87 if (!g_write_fd) {
88 int pipe_fd[2];
89 int result = pipe(pipe_fd);
90 if (result < 0) {
91 LOG(ERROR) << "Could not create signal pipe: " << errno;
92 return false;
93 }
94 base::MessageLoopForIO* message_loop = base::MessageLoopForIO::current();
95 result =
96 message_loop->WatchFileDescriptor(pipe_fd[0],
97 true,
98 base::MessageLoopForIO::WATCH_READ,
99 &g_signal_listener->controller,
100 g_signal_listener);
101 if (!result) {
102 LOG(ERROR) << "Failed to create signal detector task.";
103 close(pipe_fd[0]);
104 close(pipe_fd[1]);
105 return false;
106 }
107 g_write_fd = pipe_fd[1];
108 }
109 if (signal(signal_number, GlobalSignalHandler) == SIG_ERR) {
110 LOG(ERROR) << "signal() failed: " << errno;
111 return false;
112 }
113 g_signal_listener->AddSignalHandler(signal_number, handler);
114 return true;
115 }
116
117 } // namespace remoting
118