blob: 77ed9d9f03927327022a44c10b0bae8af82ee1fe [file] [log] [blame]
Gilad Arnoldd7b513d2012-05-10 14:25:27 -07001// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
adlr@google.com3defe6a2009-12-04 20:57:17 +00002// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
Alex Deymo759c2752014-03-17 21:09:36 -07005#ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H_
6#define CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H_
adlr@google.com3defe6a2009-12-04 20:57:17 +00007
Andrew de los Reyes81ebcd82010-03-09 15:56:18 -08008#include <algorithm>
Han Shen2643cb72012-06-26 14:45:33 -07009#include <errno.h>
adlr@google.com3defe6a2009-12-04 20:57:17 +000010#include <set>
11#include <string>
Han Shen2643cb72012-06-26 14:45:33 -070012#include <unistd.h>
adlr@google.com3defe6a2009-12-04 20:57:17 +000013#include <vector>
Darin Petkovc6c135c2010-08-11 13:36:18 -070014
Alex Vakulenko75039d72014-03-25 12:36:28 -070015#include <base/files/file_path.h>
Chris Sosafc661a12013-02-26 14:43:21 -080016#include <base/posix/eintr_wrapper.h>
Alex Vakulenko75039d72014-03-25 12:36:28 -070017#include <base/time/time.h>
Thieu Le5c7d9752010-12-15 16:09:28 -080018#include <ext2fs/ext2fs.h>
Andrew de los Reyesc7020782010-04-28 10:46:04 -070019#include <glib.h>
Jay Srinivasanf0572052012-10-23 18:12:56 -070020#include "metrics/metrics_library.h"
Darin Petkovc6c135c2010-08-11 13:36:18 -070021
adlr@google.com3defe6a2009-12-04 20:57:17 +000022#include "update_engine/action.h"
David Zeuthenb281f072014-04-02 10:20:19 -070023#include "update_engine/action_processor.h"
24#include "update_engine/connection_manager.h"
Jay Srinivasan19409b72013-04-12 19:23:36 -070025#include "update_engine/constants.h"
David Zeuthen33bae492014-02-25 16:16:18 -080026#include "update_engine/metrics.h"
adlr@google.com3defe6a2009-12-04 20:57:17 +000027
28namespace chromeos_update_engine {
29
Jay Srinivasan55f50c22013-01-10 19:24:35 -080030class SystemState;
31
adlr@google.com3defe6a2009-12-04 20:57:17 +000032namespace utils {
33
David Zeuthen27a48bc2013-08-06 12:06:29 -070034// Converts a struct timespec representing a number of seconds since
35// the Unix epoch to a base::Time. Sub-microsecond time is rounded
36// down.
37base::Time TimeFromStructTimespec(struct timespec *ts);
38
39// Converts a vector of strings to a NULL-terminated array of
40// strings. The resulting array should be freed with g_strfreev()
41// when are you done with it.
42gchar** StringVectorToGStrv(const std::vector<std::string> &vector);
43
44// Formats |vector| as a string of the form ["<elem1>", "<elem2>"].
45// Does no escaping, only use this for presentation in error messages.
46std::string StringVectorToString(const std::vector<std::string> &vector);
47
David Zeuthen8f191b22013-08-06 12:27:50 -070048// Calculates the p2p file id from payload hash and size
49std::string CalculateP2PFileId(const std::string& payload_hash,
50 size_t payload_size);
51
J. Richard Barnette63137e52013-10-28 10:57:29 -070052// Parse the firmware version from one line of output from the
53// "mosys" command.
54std::string ParseECVersion(std::string input_line);
55
J. Richard Barnette30842932013-10-28 15:04:23 -070056// Given the name of the block device of a boot partition, return the
57// name of the associated kernel partition (e.g. given "/dev/sda3",
58// return "/dev/sda2").
59const std::string KernelDeviceOfBootDevice(const std::string& boot_device);
60
Andrew de los Reyes970bb282009-12-09 16:34:04 -080061// Writes the data passed to path. The file at path will be overwritten if it
62// exists. Returns true on success, false otherwise.
63bool WriteFile(const char* path, const char* data, int data_len);
64
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070065// Calls write() or pwrite() repeatedly until all count bytes at buf are
66// written to fd or an error occurs. Returns true on success.
67bool WriteAll(int fd, const void* buf, size_t count);
68bool PWriteAll(int fd, const void* buf, size_t count, off_t offset);
69
70// Calls pread() repeatedly until count bytes are read, or EOF is reached.
71// Returns number of bytes read in *bytes_read. Returns true on success.
72bool PReadAll(int fd, void* buf, size_t count, off_t offset,
73 ssize_t* out_bytes_read);
Andrew de los Reyesb10320d2010-03-31 16:44:44 -070074
Gilad Arnold19a45f02012-07-19 12:36:10 -070075// Opens |path| for reading and appends its entire content to the container
76// pointed to by |out_p|. Returns true upon successfully reading all of the
77// file's content, false otherwise, in which case the state of the output
Darin Petkov8e447e02013-04-16 16:23:50 +020078// container is unknown. ReadFileChunk starts reading the file from |offset|; if
79// |size| is not -1, only up to |size| bytes are read in.
Gilad Arnold19a45f02012-07-19 12:36:10 -070080bool ReadFile(const std::string& path, std::vector<char>* out_p);
81bool ReadFile(const std::string& path, std::string* out_p);
Darin Petkov8e447e02013-04-16 16:23:50 +020082bool ReadFileChunk(const std::string& path, off_t offset, off_t size,
83 std::vector<char>* out_p);
Gilad Arnold19a45f02012-07-19 12:36:10 -070084
85// Invokes |cmd| in a pipe and appends its stdout to the container pointed to by
86// |out_p|. Returns true upon successfully reading all of the output, false
87// otherwise, in which case the state of the output container is unknown.
88bool ReadPipe(const std::string& cmd, std::vector<char>* out_p);
89bool ReadPipe(const std::string& cmd, std::string* out_p);
adlr@google.com3defe6a2009-12-04 20:57:17 +000090
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -070091// Returns the size of the file at path. If the file doesn't exist or some
92// error occurrs, -1 is returned.
93off_t FileSize(const std::string& path);
94
adlr@google.com3defe6a2009-12-04 20:57:17 +000095std::string ErrnoNumberAsString(int err);
96
97// Strips duplicate slashes, and optionally removes all trailing slashes.
98// Does not compact /./ or /../.
99std::string NormalizePath(const std::string& path, bool strip_trailing_slash);
100
101// Returns true if the file exists for sure. Returns false if it doesn't exist,
102// or an error occurs.
103bool FileExists(const char* path);
104
Darin Petkov30291ed2010-11-12 10:23:06 -0800105// Returns true if |path| exists and is a symbolic link.
106bool IsSymlink(const char* path);
107
adlr@google.com3defe6a2009-12-04 20:57:17 +0000108// The last 6 chars of path must be XXXXXX. They will be randomly changed
109// and a non-existent path will be returned. Intentionally makes a copy
110// of the string passed in.
111// NEVER CALL THIS FUNCTION UNLESS YOU ARE SURE
112// THAT YOUR PROCESS WILL BE THE ONLY THING WRITING FILES IN THIS DIRECTORY.
Andrew de los Reyes4fe15d02009-12-10 19:01:36 -0800113std::string TempFilename(std::string path);
adlr@google.com3defe6a2009-12-04 20:57:17 +0000114
Gilad Arnoldd04f8e22014-01-09 13:13:40 -0800115// If |base_filename_template| is neither absolute (starts with "/") nor
116// explicitly relative to the current working directory (starts with "./" or
117// "../"), then it is prepended the value of TMPDIR, which defaults to /tmp if
118// it isn't set or is empty. It then calls mkstemp(3) with the resulting
119// template. Writes the name of a new temporary file to |filename|. If |fd| is
120// non-NULL, the file descriptor returned by mkstemp is written to it and kept
121// open; otherwise, it is closed. The template must end with "XXXXXX". Returns
122// true on success.
123bool MakeTempFile(const std::string& base_filename_template,
Andrew de los Reyesb10320d2010-03-31 16:44:44 -0700124 std::string* filename,
125 int* fd);
126
Gilad Arnoldd04f8e22014-01-09 13:13:40 -0800127// If |base_filename_template| is neither absolute (starts with "/") nor
128// explicitly relative to the current working directory (starts with "./" or
129// "../"), then it is prepended the value of TMPDIR, which defaults to /tmp if
130// it isn't set or is empty. It then calls mkdtemp() with the resulting
131// template. Writes the name of the new temporary directory to |dirname|.
132// The template must end with "XXXXXX". Returns true on success.
133bool MakeTempDirectory(const std::string& base_dirname_template,
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700134 std::string* dirname);
135
adlr@google.com3defe6a2009-12-04 20:57:17 +0000136// Deletes a directory and all its contents synchronously. Returns true
137// on success. This may be called with a regular file--it will just unlink it.
138// This WILL cross filesystem boundaries.
139bool RecursiveUnlinkDir(const std::string& path);
140
Alex Vakulenko4f5b1442014-02-21 12:19:44 -0800141// Returns the disk device name for a partition. For example,
142// GetDiskName("/dev/sda3") returns "/dev/sda". Returns an empty string
143// if the input device is not of the "/dev/xyz#" form.
144std::string GetDiskName(const std::string& partition_name);
Andrew de los Reyesf9714432010-05-04 10:21:23 -0700145
Alex Vakulenko4f5b1442014-02-21 12:19:44 -0800146// Returns the partition number, of partition device name. For example,
147// GetPartitionNumber("/dev/sda3") returns 3.
148// Returns 0 on failure
149int GetPartitionNumber(const std::string& partition_name);
150
151// Splits the partition device name into the block device name and partition
152// number. For example, "/dev/sda3" will be split into {"/dev/sda", 3} and
153// "/dev/mmcblk0p2" into {"/dev/mmcblk0", 2}
154// Returns false when malformed device name is passed in.
155// If both output parameters are omitted (nullptr), can be used
156// just to test the validity of the device name. Note that the function
157// simply checks if the device name looks like a valid device, no other
158// checks are performed (i.e. it doesn't check if the device actually exists).
159bool SplitPartitionName(const std::string& partition_name,
160 std::string* out_disk_name,
161 int* out_partition_num);
162
163// Builds a partition device name from the block device name and partition
164// number. For example:
165// {"/dev/sda", 1} => "/dev/sda1"
166// {"/dev/mmcblk2", 12} => "/dev/mmcblk2p12"
167// Returns empty string when invalid parameters are passed in
168std::string MakePartitionName(const std::string& disk_name,
169 int partition_num);
Andrew de los Reyesf9714432010-05-04 10:21:23 -0700170
Darin Petkovf74eb652010-08-04 12:08:38 -0700171// Returns the sysfs block device for a root block device. For
172// example, SysfsBlockDevice("/dev/sda") returns
173// "/sys/block/sda". Returns an empty string if the input device is
174// not of the "/dev/xyz" form.
175std::string SysfsBlockDevice(const std::string& device);
176
177// Returns true if the root |device| (e.g., "/dev/sdb") is known to be
178// removable, false otherwise.
179bool IsRemovableDevice(const std::string& device);
180
adlr@google.com3defe6a2009-12-04 20:57:17 +0000181// Synchronously mount or unmount a filesystem. Return true on success.
182// Mounts as ext3 with default options.
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700183bool MountFilesystem(const std::string& device, const std::string& mountpoint,
184 unsigned long flags);
Andrew de los Reyes4fe15d02009-12-10 19:01:36 -0800185bool UnmountFilesystem(const std::string& mountpoint);
adlr@google.com3defe6a2009-12-04 20:57:17 +0000186
Darin Petkovd3f8c892010-10-12 21:38:45 -0700187// Returns the block count and the block byte size of the ext3 file system on
188// |device| (which may be a real device or a path to a filesystem image) or on
189// an opened file descriptor |fd|. The actual file-system size is |block_count|
190// * |block_size| bytes. Returns true on success, false otherwise.
191bool GetFilesystemSize(const std::string& device,
192 int* out_block_count,
193 int* out_block_size);
194bool GetFilesystemSizeFromFD(int fd,
195 int* out_block_count,
196 int* out_block_size);
197
Alex Deymo032e7722014-03-25 17:53:56 -0700198
199// Returns a human-readable string with the file format based on magic constants
200// on the header of the file.
201std::string GetFileFormat(const std::string& path);
202
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700203// Returns the string representation of the given UTC time.
204// such as "11/14/2011 14:05:30 GMT".
205std::string ToString(const base::Time utc_time);
206
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700207// Returns true or false depending on the value of b.
208std::string ToString(bool b);
209
Jay Srinivasan19409b72013-04-12 19:23:36 -0700210// Returns a string representation of the given enum.
211std::string ToString(DownloadSource source);
212
Alex Deymo1c656c42013-06-28 11:02:14 -0700213// Returns a string representation of the given enum.
214std::string ToString(PayloadType payload_type);
215
Andrew de los Reyesf9714432010-05-04 10:21:23 -0700216enum BootLoader {
217 BootLoader_SYSLINUX = 0,
218 BootLoader_CHROME_FIRMWARE = 1
219};
220// Detects which bootloader this system uses and returns it via the out
221// param. Returns true on success.
222bool GetBootloader(BootLoader* out_bootloader);
223
Darin Petkova0b9e772011-10-06 05:05:56 -0700224// Returns the error message, if any, from a GError pointer. Frees the GError
225// object and resets error to NULL.
226std::string GetAndFreeGError(GError** error);
Andrew de los Reyesc7020782010-04-28 10:46:04 -0700227
Darin Petkov296889c2010-07-23 16:20:54 -0700228// Initiates a system reboot. Returns true on success, false otherwise.
229bool Reboot();
230
Andrew de los Reyes712b3ac2011-01-07 13:47:52 -0800231// Schedules a Main Loop callback to trigger the crash reporter to perform an
232// upload as if this process had crashed.
233void ScheduleCrashReporterUpload();
234
Darin Petkov5c0a8af2010-08-24 13:39:13 -0700235// Fuzzes an integer |value| randomly in the range:
236// [value - range / 2, value + range - range / 2]
237int FuzzInt(int value, unsigned int range);
238
adlr@google.com3defe6a2009-12-04 20:57:17 +0000239// Log a string in hex to LOG(INFO). Useful for debugging.
240void HexDumpArray(const unsigned char* const arr, const size_t length);
241inline void HexDumpString(const std::string& str) {
242 HexDumpArray(reinterpret_cast<const unsigned char*>(str.data()), str.size());
243}
244inline void HexDumpVector(const std::vector<char>& vect) {
245 HexDumpArray(reinterpret_cast<const unsigned char*>(&vect[0]), vect.size());
246}
247
adlr@google.com3defe6a2009-12-04 20:57:17 +0000248bool StringHasSuffix(const std::string& str, const std::string& suffix);
249bool StringHasPrefix(const std::string& str, const std::string& prefix);
250
251template<typename KeyType, typename ValueType>
252bool MapContainsKey(const std::map<KeyType, ValueType>& m, const KeyType& k) {
253 return m.find(k) != m.end();
254}
Andrew de los Reyes4fe15d02009-12-10 19:01:36 -0800255template<typename KeyType>
256bool SetContainsKey(const std::set<KeyType>& s, const KeyType& k) {
257 return s.find(k) != s.end();
258}
adlr@google.com3defe6a2009-12-04 20:57:17 +0000259
260template<typename ValueType>
261std::set<ValueType> SetWithValue(const ValueType& value) {
262 std::set<ValueType> ret;
263 ret.insert(value);
264 return ret;
265}
266
Andrew de los Reyes0ce161b2010-02-22 15:27:01 -0800267template<typename T>
268bool VectorContainsValue(const std::vector<T>& vect, const T& value) {
Darin Petkovc1a8b422010-07-19 11:34:49 -0700269 return std::find(vect.begin(), vect.end(), value) != vect.end();
Andrew de los Reyes0ce161b2010-02-22 15:27:01 -0800270}
271
Andrew de los Reyesb10320d2010-03-31 16:44:44 -0700272template<typename T>
273bool VectorIndexOf(const std::vector<T>& vect, const T& value,
274 typename std::vector<T>::size_type* out_index) {
275 typename std::vector<T>::const_iterator it = std::find(vect.begin(),
276 vect.end(),
277 value);
278 if (it == vect.end()) {
279 return false;
280 } else {
281 *out_index = it - vect.begin();
282 return true;
283 }
284}
285
Andrew de los Reyescc92cd32010-10-05 16:56:14 -0700286template<typename ValueType>
287void ApplyMap(std::vector<ValueType>* collection,
288 const std::map<ValueType, ValueType>& the_map) {
289 for (typename std::vector<ValueType>::iterator it = collection->begin();
290 it != collection->end(); ++it) {
291 typename std::map<ValueType, ValueType>::const_iterator map_it =
292 the_map.find(*it);
293 if (map_it != the_map.end()) {
294 *it = map_it->second;
295 }
296 }
297}
298
Chris Sosa4f8ee272012-11-30 13:01:54 -0800299// Cgroups cpu shares constants. 1024 is the default shares a standard process
300// gets and 2 is the minimum value. We set High as a value that gives the
301// update-engine 2x the cpu share of a standard process.
302enum CpuShares {
303 kCpuSharesHigh = 2048,
304 kCpuSharesNormal = 1024,
305 kCpuSharesLow = 2,
Darin Petkovc6c135c2010-08-11 13:36:18 -0700306};
307
Chris Sosa4f8ee272012-11-30 13:01:54 -0800308// Compares cpu shares and returns an integer that is less
309// than, equal to or greater than 0 if |shares_lhs| is,
310// respectively, lower than, same as or higher than |shares_rhs|.
311int CompareCpuShares(CpuShares shares_lhs,
312 CpuShares shares_rhs);
Darin Petkovc6c135c2010-08-11 13:36:18 -0700313
Chris Sosa4f8ee272012-11-30 13:01:54 -0800314// Sets the current process shares to |shares|. Returns true on
Darin Petkovc6c135c2010-08-11 13:36:18 -0700315// success, false otherwise.
Chris Sosa4f8ee272012-11-30 13:01:54 -0800316bool SetCpuShares(CpuShares shares);
Andrew de los Reyesf9185172010-05-03 11:07:05 -0700317
Andrew de los Reyesf3ed8e72011-02-16 10:35:46 -0800318// Assumes data points to a Closure. Runs it and returns FALSE;
319gboolean GlibRunClosure(gpointer data);
320
Gilad Arnoldd7b513d2012-05-10 14:25:27 -0700321// Converts seconds into human readable notation including days, hours, minutes
322// and seconds. For example, 185 will yield 3m5s, 4300 will yield 1h11m40s, and
323// 360000 will yield 4d4h0m0s. Zero padding not applied. Seconds are always
324// shown in the result.
325std::string FormatSecs(unsigned secs);
326
327// Converts a TimeDelta into human readable notation including days, hours,
328// minutes, seconds and fractions of a second down to microsecond granularity,
329// as necessary; for example, an output of 5d2h0m15.053s means that the input
330// time was precise to the milliseconds only. Zero padding not applied, except
331// for fractions. Seconds are always shown, but fractions thereof are only shown
332// when applicable.
333std::string FormatTimeDelta(base::TimeDelta delta);
Gilad Arnold1ebd8132012-03-05 10:19:29 -0800334
Jay Srinivasan2b5a0f02012-12-19 17:25:56 -0800335// This method transforms the given error code to be suitable for UMA and
336// for error classification purposes by removing the higher order bits and
337// aggregating error codes beyond the enum range, etc. This method is
338// idempotent, i.e. if called with a value previously returned by this method,
339// it'll return the same value again.
David Zeuthena99981f2013-04-29 13:42:47 -0700340ErrorCode GetBaseErrorCode(ErrorCode code);
Jay Srinivasan2b5a0f02012-12-19 17:25:56 -0800341
David Zeuthen33bae492014-02-25 16:16:18 -0800342// Transforms a ErrorCode value into a metrics::DownloadErrorCode.
343// This obviously only works for errors related to downloading so if |code|
344// is e.g. |kErrorCodeFilesystemCopierError| then
345// |kDownloadErrorCodeInputMalformed| is returned.
346metrics::DownloadErrorCode GetDownloadErrorCode(ErrorCode code);
347
348// Transforms a ErrorCode value into a metrics::AttemptResult.
349//
350// If metrics::AttemptResult::kPayloadDownloadError is returned, you
351// can use utils::GetDownloadError() to get more detail.
352metrics::AttemptResult GetAttemptResult(ErrorCode code);
353
David Zeuthenb281f072014-04-02 10:20:19 -0700354// Calculates the internet connection type given |type| and |tethering|.
355metrics::ConnectionType GetConnectionType(NetworkConnectionType type,
356 NetworkTethering tethering);
357
Jay Srinivasan55f50c22013-01-10 19:24:35 -0800358// Sends the error code to UMA using the metrics interface object in the given
359// system state. It also uses the system state to determine the right UMA
360// bucket for the error code.
David Zeuthena99981f2013-04-29 13:42:47 -0700361void SendErrorCodeToUma(SystemState* system_state, ErrorCode code);
Jay Srinivasan55f50c22013-01-10 19:24:35 -0800362
David Zeuthena99981f2013-04-29 13:42:47 -0700363// Returns a string representation of the ErrorCodes (either the base
Jay Srinivasan55f50c22013-01-10 19:24:35 -0800364// error codes or the bit flags) for logging purposes.
David Zeuthena99981f2013-04-29 13:42:47 -0700365std::string CodeToString(ErrorCode code);
Jay Srinivasan55f50c22013-01-10 19:24:35 -0800366
Gilad Arnold30dedd82013-07-03 06:19:09 -0700367// Creates the powerwash marker file with the appropriate commands in it. Uses
368// |file_path| as the path to the marker file if non-NULL, otherwise uses the
369// global default. Returns true if successfully created. False otherwise.
370bool CreatePowerwashMarkerFile(const char* file_path);
Jay Srinivasan1c0fe792013-03-28 16:45:25 -0700371
Gilad Arnold30dedd82013-07-03 06:19:09 -0700372// Deletes the marker file used to trigger Powerwash using clobber-state. Uses
373// |file_path| as the path to the marker file if non-NULL, otherwise uses the
374// global default. Returns true if successfully deleted. False otherwise.
375bool DeletePowerwashMarkerFile(const char* file_path);
Jay Srinivasan1c0fe792013-03-28 16:45:25 -0700376
Chris Sosad317e402013-06-12 13:47:09 -0700377// Assumes you want to install on the "other" device, where the other
378// device is what you get if you swap 1 for 2 or 3 for 4 or vice versa
379// for the number at the end of the boot device. E.g., /dev/sda1 -> /dev/sda2
380// or /dev/sda4 -> /dev/sda3. See
381// http://www.chromium.org/chromium-os/chromiumos-design-docs/disk-format
382bool GetInstallDev(const std::string& boot_dev, std::string* install_dev);
383
David Zeuthen910ec5b2013-09-26 12:10:58 -0700384// Checks if xattr is supported in the directory specified by
385// |dir_path| which must be writable. Returns true if the feature is
386// supported, false if not or if an error occured.
387bool IsXAttrSupported(const base::FilePath& dir_path);
388
David Zeuthene7f89172013-10-31 10:21:04 -0700389// Decodes the data in |base64_encoded| and stores it in a temporary
390// file. Returns false if the given data is empty, not well-formed
391// base64 or if an error occurred. If true is returned, the decoded
392// data is stored in the file returned in |out_path|. The file should
393// be deleted when no longer needed.
394bool DecodeAndStoreBase64String(const std::string& base64_encoded,
395 base::FilePath *out_path);
396
David Zeuthen639aa362014-02-03 16:23:44 -0800397// Converts |time| to an Omaha InstallDate which is defined as "the
398// number of PST8PDT calendar weeks since Jan 1st 2007 0:00 PST, times
399// seven" with PST8PDT defined as "Pacific Time" (e.g. UTC-07:00 if
400// daylight savings is observed and UTC-08:00 otherwise.)
401//
402// If the passed in |time| variable is before Monday January 1st 2007
403// 0:00 PST, False is returned and the value returned in
404// |out_num_days| is undefined. Otherwise the number of PST8PDT
405// calendar weeks since that date times seven is returned in
406// |out_num_days| and the function returns True.
407//
408// (NOTE: This function does not currently take daylight savings time
409// into account so the result may up to one hour off. This is because
410// the glibc date and timezone routines depend on the TZ environment
411// variable and changing environment variables is not thread-safe. An
412// alternative, thread-safe API to use would be GDateTime/GTimeZone
413// available in GLib 2.26 or later.)
414bool ConvertToOmahaInstallDate(base::Time time, int *out_num_days);
415
David Zeuthen33bae492014-02-25 16:16:18 -0800416// This function returns the duration on the wallclock since the last
417// time it was called for the same |state_variable_key| value.
418//
419// If the function returns |true|, the duration (always non-negative)
420// is returned in |out_duration|. If the function returns |false|
421// something went wrong or there was no previous measurement.
422bool WallclockDurationHelper(SystemState* system_state,
423 const std::string& state_variable_key,
424 base::TimeDelta* out_duration);
425
426// This function returns the duration on the monotonic clock since the
427// last time it was called for the same |storage| pointer.
428//
429// You should pass a pointer to a 64-bit integer in |storage| which
430// should be initialized to 0.
431//
432// If the function returns |true|, the duration (always non-negative)
433// is returned in |out_duration|. If the function returns |false|
434// something went wrong or there was no previous measurement.
435bool MonotonicDurationHelper(SystemState* system_state,
436 int64_t* storage,
437 base::TimeDelta* out_duration);
438
adlr@google.com3defe6a2009-12-04 20:57:17 +0000439} // namespace utils
440
Jay Srinivasan08fce042012-06-07 16:31:01 -0700441
adlr@google.com3defe6a2009-12-04 20:57:17 +0000442// Class to unmount FS when object goes out of scope
443class ScopedFilesystemUnmounter {
444 public:
445 explicit ScopedFilesystemUnmounter(const std::string& mountpoint)
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800446 : mountpoint_(mountpoint),
447 should_unmount_(true) {}
adlr@google.com3defe6a2009-12-04 20:57:17 +0000448 ~ScopedFilesystemUnmounter() {
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800449 if (should_unmount_) {
450 utils::UnmountFilesystem(mountpoint_);
451 }
adlr@google.com3defe6a2009-12-04 20:57:17 +0000452 }
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800453 void set_should_unmount(bool unmount) { should_unmount_ = unmount; }
adlr@google.com3defe6a2009-12-04 20:57:17 +0000454 private:
455 const std::string mountpoint_;
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800456 bool should_unmount_;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700457 DISALLOW_COPY_AND_ASSIGN(ScopedFilesystemUnmounter);
adlr@google.com3defe6a2009-12-04 20:57:17 +0000458};
459
460// Utility class to close a file descriptor
461class ScopedFdCloser {
462 public:
463 explicit ScopedFdCloser(int* fd) : fd_(fd), should_close_(true) {}
adlr@google.com3defe6a2009-12-04 20:57:17 +0000464 ~ScopedFdCloser() {
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800465 if (should_close_ && fd_ && (*fd_ >= 0)) {
Gilad Arnoldf9609112012-02-29 11:38:47 -0800466 if (!close(*fd_))
467 *fd_ = -1;
adlr@google.com3defe6a2009-12-04 20:57:17 +0000468 }
469 }
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800470 void set_should_close(bool should_close) { should_close_ = should_close; }
adlr@google.com3defe6a2009-12-04 20:57:17 +0000471 private:
472 int* fd_;
473 bool should_close_;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700474 DISALLOW_COPY_AND_ASSIGN(ScopedFdCloser);
475};
476
Gilad Arnoldf9609112012-02-29 11:38:47 -0800477// An EINTR-immune file descriptor closer.
478class ScopedEintrSafeFdCloser {
479 public:
480 explicit ScopedEintrSafeFdCloser(int* fd) : fd_(fd), should_close_(true) {}
481 ~ScopedEintrSafeFdCloser() {
482 if (should_close_ && fd_ && (*fd_ >= 0)) {
483 if (!HANDLE_EINTR(close(*fd_)))
484 *fd_ = -1;
485 }
486 }
487 void set_should_close(bool should_close) { should_close_ = should_close; }
488 private:
489 int* fd_;
490 bool should_close_;
491 DISALLOW_COPY_AND_ASSIGN(ScopedEintrSafeFdCloser);
492};
493
Thieu Le5c7d9752010-12-15 16:09:28 -0800494// Utility class to close a file system
495class ScopedExt2fsCloser {
496 public:
497 explicit ScopedExt2fsCloser(ext2_filsys filsys) : filsys_(filsys) {}
498 ~ScopedExt2fsCloser() { ext2fs_close(filsys_); }
499
500 private:
501 ext2_filsys filsys_;
502 DISALLOW_COPY_AND_ASSIGN(ScopedExt2fsCloser);
503};
504
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700505// Utility class to delete a file when it goes out of scope.
506class ScopedPathUnlinker {
507 public:
Darin Petkov52dcaeb2011-01-14 15:33:06 -0800508 explicit ScopedPathUnlinker(const std::string& path)
509 : path_(path),
510 should_remove_(true) {}
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700511 ~ScopedPathUnlinker() {
Darin Petkov52dcaeb2011-01-14 15:33:06 -0800512 if (should_remove_ && unlink(path_.c_str()) < 0) {
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700513 std::string err_message = strerror(errno);
514 LOG(ERROR) << "Unable to unlink path " << path_ << ": " << err_message;
515 }
516 }
Darin Petkov52dcaeb2011-01-14 15:33:06 -0800517 void set_should_remove(bool should_remove) { should_remove_ = should_remove; }
518
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700519 private:
520 const std::string path_;
Darin Petkov52dcaeb2011-01-14 15:33:06 -0800521 bool should_remove_;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700522 DISALLOW_COPY_AND_ASSIGN(ScopedPathUnlinker);
523};
524
525// Utility class to delete an empty directory when it goes out of scope.
526class ScopedDirRemover {
527 public:
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800528 explicit ScopedDirRemover(const std::string& path)
529 : path_(path),
530 should_remove_(true) {}
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700531 ~ScopedDirRemover() {
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800532 if (should_remove_ && (rmdir(path_.c_str()) < 0)) {
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700533 PLOG(ERROR) << "Unable to remove dir " << path_;
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800534 }
535 }
536 void set_should_remove(bool should_remove) { should_remove_ = should_remove; }
537
538 protected:
539 const std::string path_;
540
541 private:
542 bool should_remove_;
543 DISALLOW_COPY_AND_ASSIGN(ScopedDirRemover);
544};
545
546// Utility class to unmount a filesystem mounted on a temporary directory and
547// delete the temporary directory when it goes out of scope.
548class ScopedTempUnmounter : public ScopedDirRemover {
549 public:
550 explicit ScopedTempUnmounter(const std::string& path) :
551 ScopedDirRemover(path) {}
552 ~ScopedTempUnmounter() {
553 utils::UnmountFilesystem(path_);
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700554 }
555 private:
Darin Petkov6f03a3b2010-11-10 14:27:14 -0800556 DISALLOW_COPY_AND_ASSIGN(ScopedTempUnmounter);
adlr@google.com3defe6a2009-12-04 20:57:17 +0000557};
558
559// A little object to call ActionComplete on the ActionProcessor when
560// it's destructed.
561class ScopedActionCompleter {
562 public:
563 explicit ScopedActionCompleter(ActionProcessor* processor,
564 AbstractAction* action)
565 : processor_(processor),
566 action_(action),
David Zeuthena99981f2013-04-29 13:42:47 -0700567 code_(kErrorCodeError),
adlr@google.com3defe6a2009-12-04 20:57:17 +0000568 should_complete_(true) {}
569 ~ScopedActionCompleter() {
570 if (should_complete_)
Darin Petkovc1a8b422010-07-19 11:34:49 -0700571 processor_->ActionComplete(action_, code_);
adlr@google.com3defe6a2009-12-04 20:57:17 +0000572 }
David Zeuthena99981f2013-04-29 13:42:47 -0700573 void set_code(ErrorCode code) { code_ = code; }
adlr@google.com3defe6a2009-12-04 20:57:17 +0000574 void set_should_complete(bool should_complete) {
575 should_complete_ = should_complete;
576 }
David Zeuthen33bae492014-02-25 16:16:18 -0800577 ErrorCode get_code() const { return code_; }
Darin Petkovc1a8b422010-07-19 11:34:49 -0700578
adlr@google.com3defe6a2009-12-04 20:57:17 +0000579 private:
580 ActionProcessor* processor_;
581 AbstractAction* action_;
David Zeuthena99981f2013-04-29 13:42:47 -0700582 ErrorCode code_;
adlr@google.com3defe6a2009-12-04 20:57:17 +0000583 bool should_complete_;
584 DISALLOW_COPY_AND_ASSIGN(ScopedActionCompleter);
585};
586
David Zeuthen27a48bc2013-08-06 12:06:29 -0700587// A base::FreeDeleter that frees memory using g_free(). Useful when
588// integrating with GLib since it can be used with scoped_ptr to
589// automatically free memory when going out of scope.
590struct GLibFreeDeleter : public base::FreeDeleter {
591 inline void operator()(void *ptr) const {
592 g_free(reinterpret_cast<gpointer>(ptr));
593 }
594};
595
596// A base::FreeDeleter that frees memory using g_strfreev(). Useful
597// when integrating with GLib since it can be used with scoped_ptr to
598// automatically free memory when going out of scope.
599struct GLibStrvFreeDeleter : public base::FreeDeleter {
600 inline void operator()(void *ptr) const {
601 g_strfreev(reinterpret_cast<gchar**>(ptr));
602 }
603};
604
adlr@google.com3defe6a2009-12-04 20:57:17 +0000605} // namespace chromeos_update_engine
606
607#define TEST_AND_RETURN_FALSE_ERRNO(_x) \
608 do { \
609 bool _success = (_x); \
610 if (!_success) { \
611 std::string _msg = \
612 chromeos_update_engine::utils::ErrnoNumberAsString(errno); \
613 LOG(ERROR) << #_x " failed: " << _msg; \
614 return false; \
615 } \
616 } while (0)
617
618#define TEST_AND_RETURN_FALSE(_x) \
619 do { \
620 bool _success = (_x); \
621 if (!_success) { \
622 LOG(ERROR) << #_x " failed."; \
623 return false; \
624 } \
625 } while (0)
626
627#define TEST_AND_RETURN_ERRNO(_x) \
628 do { \
629 bool _success = (_x); \
630 if (!_success) { \
631 std::string _msg = \
632 chromeos_update_engine::utils::ErrnoNumberAsString(errno); \
633 LOG(ERROR) << #_x " failed: " << _msg; \
634 return; \
635 } \
636 } while (0)
637
638#define TEST_AND_RETURN(_x) \
639 do { \
640 bool _success = (_x); \
641 if (!_success) { \
642 LOG(ERROR) << #_x " failed."; \
643 return; \
644 } \
645 } while (0)
646
Thieu Le5c7d9752010-12-15 16:09:28 -0800647#define TEST_AND_RETURN_FALSE_ERRCODE(_x) \
648 do { \
649 errcode_t _error = (_x); \
650 if (_error) { \
651 errno = _error; \
652 LOG(ERROR) << #_x " failed: " << _error; \
653 return false; \
654 } \
655 } while (0)
656
adlr@google.com3defe6a2009-12-04 20:57:17 +0000657
658
Alex Deymo759c2752014-03-17 21:09:36 -0700659#endif // CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H_