1 //
2 // Copyright (C) 2012 The Android Open Source Project
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 <errno.h>
18 #include <stdio.h>
19 #include <time.h>
20 #include <unistd.h>
21
22 #include <string>
23 #include <vector>
24
25 #include <base/bind.h>
26 #include <base/command_line.h>
27 #include <base/files/file_path.h>
28 #include <base/strings/string_number_conversions.h>
29 #include <base/strings/string_split.h>
30 #include <brillo/minijail/minijail.h>
31 #include <brillo/syslog_logging.h>
32
33 #include "shill/daemon_task.h"
34 #include "shill/error.h"
35 #include "shill/logging.h"
36 #include "shill/shill_config.h"
37 #include "shill/shill_daemon.h"
38 #include "shill/technology.h"
39
40 using base::FilePath;
41 using std::string;
42 using std::vector;
43
44 namespace switches {
45
46 // Don't daemon()ize; run in foreground.
47 static const char kForeground[] = "foreground";
48 // Don't attempt to manage these devices.
49 static const char kDeviceBlackList[] = "device-black-list";
50 // Manage only these devices.
51 static const char kDeviceWhiteList[] = "device-white-list";
52 // Ignore Ethernet-like devices that don't have any driver information.
53 static const char kIgnoreUnknownEthernet[] = "ignore-unknown-ethernet";
54 // Technologies to enable for portal check at startup.
55 static const char kPortalList[] = "portal-list";
56 // When in passive mode, Shill will not manage any devices by default.
57 // Remote service can instruct Shill to manage/unmanage devices through
58 // org.chromium.flimflam.Manager's ClaimInterface/ReleaseInterface APIs.
59 static const char kPassiveMode[] = "passive-mode";
60 // Default priority order of the technologies.
61 static const char kTechnologyOrder[] = "default-technology-order";
62 // Comma-separated list of DNS servers to prepend to the resolver list.
63 static const char kPrependDNSServers[] = "prepend-dns-servers";
64 // The minimum MTU value that will be respected in DHCP responses.
65 static const char kMinimumMTU[] = "minimum-mtu";
66 // Accept hostname from the DHCP server for the specified devices.
67 // eg. eth0 or eth*
68 static const char kAcceptHostnameFrom[] = "accept-hostname-from";
69 #ifndef DISABLE_DHCPV6
70 // List of devices to enable DHCPv6.
71 static const char kDhcpv6EnabledDevices[] = "dhcpv6-enabled-devices";
72 #endif // DISABLE_DHCPV6
73 // Flag that causes shill to show the help message and exit.
74 static const char kHelp[] = "help";
75
76 // The help message shown if help flag is passed to the program.
77 static const char kHelpMessage[] = "\n"
78 "Available Switches: \n"
79 " --foreground\n"
80 " Don\'t daemon()ize; run in foreground.\n"
81 " --device-black-list=device1,device2\n"
82 " Do not manage devices named device1 or device2\n"
83 " --device-white-list=device1,device2\n"
84 " Manage only devices named device1 and device2\n"
85 " --ignore-unknown-ethernet\n"
86 " Ignore Ethernet-like devices that do not report a driver\n"
87 " --log-level=N\n"
88 " Logging level:\n"
89 " 0 = LOG(INFO), 1 = LOG(WARNING), 2 = LOG(ERROR),\n"
90 " -1 = SLOG(..., 1), -2 = SLOG(..., 2), etc.\n"
91 " --log-scopes=\"*scope1+scope2\".\n"
92 " Scopes to enable for SLOG()-based logging.\n"
93 " --portal-list=technology1,technology2\n"
94 " Specify technologies to perform portal detection on at startup.\n"
95 " --passive-mode\n"
96 " Do not manage any devices by default\n"
97 " --default-technology-order=technology1,technology2\n"
98 " Specify the default priority order of the technologies.\n"
99 " --prepend-dns-servers=server1,server2,...\n"
100 " Prepend the provided DNS servers to the resolver list.\n"
101 " --accept-hostname-from=eth0 or --accept-hostname-from=eth*\n"
102 " Accept a hostname from the DHCP server for the matching devices.\n"
103 #ifndef DISABLE_DHCPV6
104 " --dhcpv6-enabled-devices=device1,device2\n"
105 " Enable DHCPv6 for devices named device1 and device2\n"
106 #endif // DISABLE_DHCPV6
107 " --minimum-mtu=mtu\n"
108 " Set the minimum value to respect as the MTU from DHCP responses.\n";
109 } // namespace switches
110
111 namespace {
112
113 #if !defined(__ANDROID__)
114 const char* kLoggerCommand = "/usr/bin/logger";
115 const char* kLoggerUser = "syslog";
116 #endif // __ANDROID__
117
118 const char* kDefaultTechnologyOrder = "vpn,ethernet,wifi,wimax,cellular";
119
120 } // namespace
121
122 // Always logs to the syslog and logs to stderr if
123 // we are running in the foreground.
SetupLogging(bool foreground,const char * daemon_name)124 void SetupLogging(bool foreground, const char* daemon_name) {
125 int log_flags = 0;
126 log_flags |= brillo::kLogToSyslog;
127 log_flags |= brillo::kLogHeader;
128 if (foreground) {
129 log_flags |= brillo::kLogToStderr;
130 }
131 brillo::InitLog(log_flags);
132
133 #if !defined(__ANDROID__)
134 // Logger utility doesn't exist on Android, so do not run it on Android.
135 // TODO(zqiu): add support to redirect stderr logs from child processes
136 // to Android logging facility.
137 if (!foreground) {
138 vector<char*> logger_command_line;
139 int logger_stdin_fd;
140 logger_command_line.push_back(const_cast<char*>(kLoggerCommand));
141 logger_command_line.push_back(const_cast<char*>("--priority"));
142 logger_command_line.push_back(const_cast<char*>("daemon.err"));
143 logger_command_line.push_back(const_cast<char*>("--tag"));
144 logger_command_line.push_back(const_cast<char*>(daemon_name));
145 logger_command_line.push_back(nullptr);
146
147 brillo::Minijail* minijail = brillo::Minijail::GetInstance();
148 struct minijail* jail = minijail->New();
149 minijail->DropRoot(jail, kLoggerUser, kLoggerUser);
150
151 if (!minijail->RunPipeAndDestroy(jail, logger_command_line, nullptr,
152 &logger_stdin_fd)) {
153 LOG(ERROR) << "Unable to spawn logger. "
154 << "Writes to stderr will be discarded.";
155 return;
156 }
157
158 // Note that we don't set O_CLOEXEC here. This means that stderr
159 // from any child processes will, by default, be logged to syslog.
160 if (dup2(logger_stdin_fd, fileno(stderr)) != fileno(stderr)) {
161 PLOG(ERROR) << "Failed to redirect stderr to syslog";
162 }
163 close(logger_stdin_fd);
164 }
165 #endif // __ANDROID__
166 }
167
OnStartup(const char * daemon_name,base::CommandLine * cl)168 void OnStartup(const char *daemon_name, base::CommandLine* cl) {
169 SetupLogging(cl->HasSwitch(switches::kForeground), daemon_name);
170 shill::SetLogLevelFromCommandLine(cl);
171 }
172
main(int argc,char ** argv)173 int main(int argc, char** argv) {
174 base::CommandLine::Init(argc, argv);
175 base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
176
177 if (cl->HasSwitch(switches::kHelp)) {
178 LOG(INFO) << switches::kHelpMessage;
179 return 0;
180 }
181
182 shill::DaemonTask::Settings settings;
183 if (cl->HasSwitch(switches::kTechnologyOrder)) {
184 shill::Error error;
185 string order_flag = cl->GetSwitchValueASCII(
186 switches::kTechnologyOrder);
187 vector<shill::Technology::Identifier> test_order_vector;
188 if (shill::Technology::GetTechnologyVectorFromString(
189 order_flag, &test_order_vector, &error)) {
190 settings.default_technology_order = order_flag;
191 } else {
192 LOG(ERROR) << "Invalid default technology order: [" << order_flag
193 << "] Error: " << error.message();
194 }
195 }
196 if (settings.default_technology_order.empty()) {
197 settings.default_technology_order = kDefaultTechnologyOrder;
198 }
199
200 if (cl->HasSwitch(switches::kDeviceBlackList)) {
201 settings.device_blacklist = base::SplitString(
202 cl->GetSwitchValueASCII(switches::kDeviceBlackList), ",",
203 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
204 }
205
206 if (cl->HasSwitch(switches::kDeviceWhiteList)) {
207 settings.device_whitelist = base::SplitString(
208 cl->GetSwitchValueASCII(switches::kDeviceWhiteList), ",",
209 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
210 }
211
212 settings.ignore_unknown_ethernet =
213 cl->HasSwitch(switches::kIgnoreUnknownEthernet);
214
215 if (cl->HasSwitch(switches::kPortalList)) {
216 settings.use_portal_list = true;
217 settings.portal_list = cl->GetSwitchValueASCII(switches::kPortalList);
218 }
219
220 settings.passive_mode = cl->HasSwitch(switches::kPassiveMode);
221
222 if (cl->HasSwitch(switches::kPrependDNSServers)) {
223 settings.prepend_dns_servers =
224 cl->GetSwitchValueASCII(switches::kPrependDNSServers);
225 }
226
227 if (cl->HasSwitch(switches::kMinimumMTU)) {
228 int mtu;
229 std::string value = cl->GetSwitchValueASCII(switches::kMinimumMTU);
230 if (!base::StringToInt(value, &mtu)) {
231 LOG(FATAL) << "Could not convert '" << value << "' to integer.";
232 }
233 settings.minimum_mtu = mtu;
234 }
235
236 if (cl->HasSwitch(switches::kAcceptHostnameFrom)) {
237 settings.accept_hostname_from =
238 cl->GetSwitchValueASCII(switches::kAcceptHostnameFrom);
239 }
240
241 #ifndef DISABLE_DHCPV6
242 if (cl->HasSwitch(switches::kDhcpv6EnabledDevices)) {
243 settings.dhcpv6_enabled_devices = base::SplitString(
244 cl->GetSwitchValueASCII(switches::kDhcpv6EnabledDevices), ",",
245 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
246 }
247 #endif // DISABLE_DHCPV6
248
249 shill::Config config;
250
251 shill::ShillDaemon daemon(base::Bind(&OnStartup, argv[0], cl), settings,
252 &config);
253 daemon.Run();
254
255 LOG(INFO) << "Process exiting.";
256
257 return 0;
258 }
259