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 #include "base/sys_info.h"
6
7 #include "base/basictypes.h"
8 #include "base/environment.h"
9 #include "base/file_util.h"
10 #include "base/files/file_path.h"
11 #include "base/lazy_instance.h"
12 #include "base/strings/string_number_conversions.h"
13 #include "base/strings/string_piece.h"
14 #include "base/strings/string_split.h"
15 #include "base/strings/string_tokenizer.h"
16 #include "base/strings/string_util.h"
17 #include "base/threading/thread_restrictions.h"
18
19 namespace base {
20
21 namespace {
22
23 const char* kLinuxStandardBaseVersionKeys[] = {
24 "CHROMEOS_RELEASE_VERSION",
25 "GOOGLE_RELEASE",
26 "DISTRIB_RELEASE",
27 };
28
29 const char kChromeOsReleaseNameKey[] = "CHROMEOS_RELEASE_NAME";
30
31 const char* const kChromeOsReleaseNames[] = {
32 "Chrome OS",
33 "Chromium OS",
34 };
35
36 const char kLinuxStandardBaseReleaseFile[] = "/etc/lsb-release";
37
38 const char kLsbReleaseKey[] = "LSB_RELEASE";
39 const char kLsbReleaseTimeKey[] = "LSB_RELEASE_TIME"; // Seconds since epoch
40
41 const char kLsbReleaseSourceKey[] = "lsb-release";
42 const char kLsbReleaseSourceEnv[] = "env";
43 const char kLsbReleaseSourceFile[] = "file";
44
45 class ChromeOSVersionInfo {
46 public:
ChromeOSVersionInfo()47 ChromeOSVersionInfo() {
48 Parse();
49 }
50
Parse()51 void Parse() {
52 lsb_release_map_.clear();
53 major_version_ = 0;
54 minor_version_ = 0;
55 bugfix_version_ = 0;
56 is_running_on_chromeos_ = false;
57
58 std::string lsb_release, lsb_release_time_str;
59 scoped_ptr<Environment> env(Environment::Create());
60 bool parsed_from_env =
61 env->GetVar(kLsbReleaseKey, &lsb_release) &&
62 env->GetVar(kLsbReleaseTimeKey, &lsb_release_time_str);
63 if (parsed_from_env) {
64 double us = 0;
65 if (StringToDouble(lsb_release_time_str, &us))
66 lsb_release_time_ = Time::FromDoubleT(us);
67 } else {
68 // If the LSB_RELEASE and LSB_RELEASE_TIME environment variables are not
69 // set, fall back to a blocking read of the lsb_release file. This should
70 // only happen in non Chrome OS environments.
71 ThreadRestrictions::ScopedAllowIO allow_io;
72 FilePath path(kLinuxStandardBaseReleaseFile);
73 ReadFileToString(path, &lsb_release);
74 PlatformFileInfo fileinfo;
75 if (GetFileInfo(path, &fileinfo))
76 lsb_release_time_ = fileinfo.creation_time;
77 }
78 ParseLsbRelease(lsb_release);
79 // For debugging:
80 lsb_release_map_[kLsbReleaseSourceKey] =
81 parsed_from_env ? kLsbReleaseSourceEnv : kLsbReleaseSourceFile;
82 }
83
GetLsbReleaseValue(const std::string & key,std::string * value)84 bool GetLsbReleaseValue(const std::string& key, std::string* value) {
85 SysInfo::LsbReleaseMap::const_iterator iter = lsb_release_map_.find(key);
86 if (iter == lsb_release_map_.end())
87 return false;
88 *value = iter->second;
89 return true;
90 }
91
GetVersionNumbers(int32 * major_version,int32 * minor_version,int32 * bugfix_version)92 void GetVersionNumbers(int32* major_version,
93 int32* minor_version,
94 int32* bugfix_version) {
95 *major_version = major_version_;
96 *minor_version = minor_version_;
97 *bugfix_version = bugfix_version_;
98 }
99
lsb_release_time() const100 const Time& lsb_release_time() const { return lsb_release_time_; }
lsb_release_map() const101 const SysInfo::LsbReleaseMap& lsb_release_map() const {
102 return lsb_release_map_;
103 }
is_running_on_chromeos() const104 bool is_running_on_chromeos() const { return is_running_on_chromeos_; }
105
106 private:
ParseLsbRelease(const std::string & lsb_release)107 void ParseLsbRelease(const std::string& lsb_release) {
108 // Parse and cache lsb_release key pairs. There should only be a handful
109 // of entries so the overhead for this will be small, and it can be
110 // useful for debugging.
111 std::vector<std::pair<std::string, std::string> > pairs;
112 SplitStringIntoKeyValuePairs(lsb_release, '=', '\n', &pairs);
113 for (size_t i = 0; i < pairs.size(); ++i) {
114 std::string key, value;
115 TrimWhitespaceASCII(pairs[i].first, TRIM_ALL, &key);
116 TrimWhitespaceASCII(pairs[i].second, TRIM_ALL, &value);
117 if (key.empty())
118 continue;
119 lsb_release_map_[key] = value;
120 }
121 // Parse the version from the first matching recognized version key.
122 std::string version;
123 for (size_t i = 0; i < arraysize(kLinuxStandardBaseVersionKeys); ++i) {
124 std::string key = kLinuxStandardBaseVersionKeys[i];
125 if (GetLsbReleaseValue(key, &version) && !version.empty())
126 break;
127 }
128 StringTokenizer tokenizer(version, ".");
129 if (tokenizer.GetNext()) {
130 StringToInt(StringPiece(tokenizer.token_begin(), tokenizer.token_end()),
131 &major_version_);
132 }
133 if (tokenizer.GetNext()) {
134 StringToInt(StringPiece(tokenizer.token_begin(), tokenizer.token_end()),
135 &minor_version_);
136 }
137 if (tokenizer.GetNext()) {
138 StringToInt(StringPiece(tokenizer.token_begin(), tokenizer.token_end()),
139 &bugfix_version_);
140 }
141
142 // Check release name for Chrome OS.
143 std::string release_name;
144 if (GetLsbReleaseValue(kChromeOsReleaseNameKey, &release_name)) {
145 for (size_t i = 0; i < arraysize(kChromeOsReleaseNames); ++i) {
146 if (release_name == kChromeOsReleaseNames[i]) {
147 is_running_on_chromeos_ = true;
148 break;
149 }
150 }
151 }
152 }
153
154 Time lsb_release_time_;
155 SysInfo::LsbReleaseMap lsb_release_map_;
156 int32 major_version_;
157 int32 minor_version_;
158 int32 bugfix_version_;
159 bool is_running_on_chromeos_;
160 };
161
162 static LazyInstance<ChromeOSVersionInfo>
163 g_chrome_os_version_info = LAZY_INSTANCE_INITIALIZER;
164
GetChromeOSVersionInfo()165 ChromeOSVersionInfo& GetChromeOSVersionInfo() {
166 return g_chrome_os_version_info.Get();
167 }
168
169 } // namespace
170
171 // static
OperatingSystemVersionNumbers(int32 * major_version,int32 * minor_version,int32 * bugfix_version)172 void SysInfo::OperatingSystemVersionNumbers(int32* major_version,
173 int32* minor_version,
174 int32* bugfix_version) {
175 return GetChromeOSVersionInfo().GetVersionNumbers(
176 major_version, minor_version, bugfix_version);
177 }
178
179 // static
GetLsbReleaseMap()180 const SysInfo::LsbReleaseMap& SysInfo::GetLsbReleaseMap() {
181 return GetChromeOSVersionInfo().lsb_release_map();
182 }
183
184 // static
GetLsbReleaseValue(const std::string & key,std::string * value)185 bool SysInfo::GetLsbReleaseValue(const std::string& key, std::string* value) {
186 return GetChromeOSVersionInfo().GetLsbReleaseValue(key, value);
187 }
188
189 // static
GetLsbReleaseBoard()190 std::string SysInfo::GetLsbReleaseBoard() {
191 const char kMachineInfoBoard[] = "CHROMEOS_RELEASE_BOARD";
192 std::string board;
193 if (!GetLsbReleaseValue(kMachineInfoBoard, &board))
194 board = "unknown";
195 return board;
196 }
197
198 // static
GetLsbReleaseTime()199 Time SysInfo::GetLsbReleaseTime() {
200 return GetChromeOSVersionInfo().lsb_release_time();
201 }
202
203 // static
IsRunningOnChromeOS()204 bool SysInfo::IsRunningOnChromeOS() {
205 return GetChromeOSVersionInfo().is_running_on_chromeos();
206 }
207
208 // static
SetChromeOSVersionInfoForTest(const std::string & lsb_release,const Time & lsb_release_time)209 void SysInfo::SetChromeOSVersionInfoForTest(const std::string& lsb_release,
210 const Time& lsb_release_time) {
211 scoped_ptr<Environment> env(Environment::Create());
212 env->SetVar(kLsbReleaseKey, lsb_release);
213 env->SetVar(kLsbReleaseTimeKey,
214 DoubleToString(lsb_release_time.ToDoubleT()));
215 g_chrome_os_version_info.Get().Parse();
216 }
217
218 } // namespace base
219