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.
5 #include "base/sys_info.h"
7 #include "base/basictypes.h"
8 #include "base/environment.h"
9 #include "base/files/file.h"
10 #include "base/files/file_path.h"
11 #include "base/files/file_util.h"
12 #include "base/lazy_instance.h"
13 #include "base/strings/string_number_conversions.h"
14 #include "base/strings/string_piece.h"
15 #include "base/strings/string_split.h"
16 #include "base/strings/string_tokenizer.h"
17 #include "base/strings/string_util.h"
18 #include "base/threading/thread_restrictions.h"
24 const char* kLinuxStandardBaseVersionKeys
[] = {
25 "CHROMEOS_RELEASE_VERSION",
30 const char kChromeOsReleaseNameKey
[] = "CHROMEOS_RELEASE_NAME";
32 const char* const kChromeOsReleaseNames
[] = {
37 const char kLinuxStandardBaseReleaseFile
[] = "/etc/lsb-release";
39 const char kLsbReleaseKey
[] = "LSB_RELEASE";
40 const char kLsbReleaseTimeKey
[] = "LSB_RELEASE_TIME"; // Seconds since epoch
42 const char kLsbReleaseSourceKey
[] = "lsb-release";
43 const char kLsbReleaseSourceEnv
[] = "env";
44 const char kLsbReleaseSourceFile
[] = "file";
46 class ChromeOSVersionInfo
{
48 ChromeOSVersionInfo() {
53 lsb_release_map_
.clear();
57 is_running_on_chromeos_
= false;
59 std::string lsb_release
, lsb_release_time_str
;
60 scoped_ptr
<Environment
> env(Environment::Create());
61 bool parsed_from_env
=
62 env
->GetVar(kLsbReleaseKey
, &lsb_release
) &&
63 env
->GetVar(kLsbReleaseTimeKey
, &lsb_release_time_str
);
64 if (parsed_from_env
) {
66 if (StringToDouble(lsb_release_time_str
, &us
))
67 lsb_release_time_
= Time::FromDoubleT(us
);
69 // If the LSB_RELEASE and LSB_RELEASE_TIME environment variables are not
70 // set, fall back to a blocking read of the lsb_release file. This should
71 // only happen in non Chrome OS environments.
72 ThreadRestrictions::ScopedAllowIO allow_io
;
73 FilePath
path(kLinuxStandardBaseReleaseFile
);
74 ReadFileToString(path
, &lsb_release
);
76 if (GetFileInfo(path
, &fileinfo
))
77 lsb_release_time_
= fileinfo
.creation_time
;
79 ParseLsbRelease(lsb_release
);
81 lsb_release_map_
[kLsbReleaseSourceKey
] =
82 parsed_from_env
? kLsbReleaseSourceEnv
: kLsbReleaseSourceFile
;
85 bool GetLsbReleaseValue(const std::string
& key
, std::string
* value
) {
86 SysInfo::LsbReleaseMap::const_iterator iter
= lsb_release_map_
.find(key
);
87 if (iter
== lsb_release_map_
.end())
89 *value
= iter
->second
;
93 void GetVersionNumbers(int32
* major_version
,
95 int32
* bugfix_version
) {
96 *major_version
= major_version_
;
97 *minor_version
= minor_version_
;
98 *bugfix_version
= bugfix_version_
;
101 const Time
& lsb_release_time() const { return lsb_release_time_
; }
102 const SysInfo::LsbReleaseMap
& lsb_release_map() const {
103 return lsb_release_map_
;
105 bool is_running_on_chromeos() const { return is_running_on_chromeos_
; }
108 void ParseLsbRelease(const std::string
& lsb_release
) {
109 // Parse and cache lsb_release key pairs. There should only be a handful
110 // of entries so the overhead for this will be small, and it can be
111 // useful for debugging.
112 std::vector
<std::pair
<std::string
, std::string
> > pairs
;
113 SplitStringIntoKeyValuePairs(lsb_release
, '=', '\n', &pairs
);
114 for (size_t i
= 0; i
< pairs
.size(); ++i
) {
115 std::string key
, value
;
116 TrimWhitespaceASCII(pairs
[i
].first
, TRIM_ALL
, &key
);
117 TrimWhitespaceASCII(pairs
[i
].second
, TRIM_ALL
, &value
);
120 lsb_release_map_
[key
] = value
;
122 // Parse the version from the first matching recognized version key.
124 for (size_t i
= 0; i
< arraysize(kLinuxStandardBaseVersionKeys
); ++i
) {
125 std::string key
= kLinuxStandardBaseVersionKeys
[i
];
126 if (GetLsbReleaseValue(key
, &version
) && !version
.empty())
129 StringTokenizer
tokenizer(version
, ".");
130 if (tokenizer
.GetNext()) {
131 StringToInt(StringPiece(tokenizer
.token_begin(), tokenizer
.token_end()),
134 if (tokenizer
.GetNext()) {
135 StringToInt(StringPiece(tokenizer
.token_begin(), tokenizer
.token_end()),
138 if (tokenizer
.GetNext()) {
139 StringToInt(StringPiece(tokenizer
.token_begin(), tokenizer
.token_end()),
143 // Check release name for Chrome OS.
144 std::string release_name
;
145 if (GetLsbReleaseValue(kChromeOsReleaseNameKey
, &release_name
)) {
146 for (size_t i
= 0; i
< arraysize(kChromeOsReleaseNames
); ++i
) {
147 if (release_name
== kChromeOsReleaseNames
[i
]) {
148 is_running_on_chromeos_
= true;
155 Time lsb_release_time_
;
156 SysInfo::LsbReleaseMap lsb_release_map_
;
157 int32 major_version_
;
158 int32 minor_version_
;
159 int32 bugfix_version_
;
160 bool is_running_on_chromeos_
;
163 static LazyInstance
<ChromeOSVersionInfo
>
164 g_chrome_os_version_info
= LAZY_INSTANCE_INITIALIZER
;
166 ChromeOSVersionInfo
& GetChromeOSVersionInfo() {
167 return g_chrome_os_version_info
.Get();
173 void SysInfo::OperatingSystemVersionNumbers(int32
* major_version
,
174 int32
* minor_version
,
175 int32
* bugfix_version
) {
176 return GetChromeOSVersionInfo().GetVersionNumbers(
177 major_version
, minor_version
, bugfix_version
);
181 const SysInfo::LsbReleaseMap
& SysInfo::GetLsbReleaseMap() {
182 return GetChromeOSVersionInfo().lsb_release_map();
186 bool SysInfo::GetLsbReleaseValue(const std::string
& key
, std::string
* value
) {
187 return GetChromeOSVersionInfo().GetLsbReleaseValue(key
, value
);
191 std::string
SysInfo::GetLsbReleaseBoard() {
192 const char kMachineInfoBoard
[] = "CHROMEOS_RELEASE_BOARD";
194 if (!GetLsbReleaseValue(kMachineInfoBoard
, &board
))
200 Time
SysInfo::GetLsbReleaseTime() {
201 return GetChromeOSVersionInfo().lsb_release_time();
205 bool SysInfo::IsRunningOnChromeOS() {
206 return GetChromeOSVersionInfo().is_running_on_chromeos();
210 void SysInfo::SetChromeOSVersionInfoForTest(const std::string
& lsb_release
,
211 const Time
& lsb_release_time
) {
212 scoped_ptr
<Environment
> env(Environment::Create());
213 env
->SetVar(kLsbReleaseKey
, lsb_release
);
214 env
->SetVar(kLsbReleaseTimeKey
,
215 DoubleToString(lsb_release_time
.ToDoubleT()));
216 g_chrome_os_version_info
.Get().Parse();