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 #ifndef UPDATE_ENGINE_COMMON_UTILS_H_ 18 #define UPDATE_ENGINE_COMMON_UTILS_H_ 19 20 #include <errno.h> 21 #include <unistd.h> 22 23 #include <algorithm> 24 #include <map> 25 #include <memory> 26 #include <set> 27 #include <string> 28 #include <vector> 29 30 #include <base/files/file_path.h> 31 #include <base/posix/eintr_wrapper.h> 32 #include <base/time/time.h> 33 #include <brillo/key_value_store.h> 34 #include <brillo/secure_blob.h> 35 36 #include "update_engine/common/action.h" 37 #include "update_engine/common/action_processor.h" 38 #include "update_engine/common/constants.h" 39 #include "update_engine/payload_consumer/file_descriptor.h" 40 #include "update_engine/update_metadata.pb.h" 41 42 namespace chromeos_update_engine { 43 44 namespace utils { 45 46 // Converts a struct timespec representing a number of seconds since 47 // the Unix epoch to a base::Time. Sub-microsecond time is rounded 48 // down. 49 base::Time TimeFromStructTimespec(struct timespec *ts); 50 51 // Formats |vec_str| as a string of the form ["<elem1>", "<elem2>"]. 52 // Does no escaping, only use this for presentation in error messages. 53 std::string StringVectorToString(const std::vector<std::string> &vec_str); 54 55 // Calculates the p2p file id from payload hash and size 56 std::string CalculateP2PFileId(const brillo::Blob& payload_hash, 57 size_t payload_size); 58 59 // Parse the firmware version from one line of output from the 60 // "mosys" command. 61 std::string ParseECVersion(std::string input_line); 62 63 // Writes the data passed to path. The file at path will be overwritten if it 64 // exists. Returns true on success, false otherwise. 65 bool WriteFile(const char* path, const void* data, size_t data_len); 66 67 // Calls write() or pwrite() repeatedly until all count bytes at buf are 68 // written to fd or an error occurs. Returns true on success. 69 bool WriteAll(int fd, const void* buf, size_t count); 70 bool PWriteAll(int fd, const void* buf, size_t count, off_t offset); 71 72 bool WriteAll(const FileDescriptorPtr& fd, const void* buf, size_t count); 73 bool PWriteAll(const FileDescriptorPtr& fd, 74 const void* buf, 75 size_t count, 76 off_t offset); 77 78 // Calls read() repeatedly until |count| bytes are read or EOF or EWOULDBLOCK 79 // is reached. Returns whether all read() calls succeeded (including EWOULDBLOCK 80 // as a success case), sets |eof| to whether the eof was reached and sets 81 // |out_bytes_read| to the actual number of bytes read regardless of the return 82 // value. 83 bool ReadAll( 84 int fd, void* buf, size_t count, size_t* out_bytes_read, bool* eof); 85 86 // Calls pread() repeatedly until count bytes are read, or EOF is reached. 87 // Returns number of bytes read in *bytes_read. Returns true on success. 88 bool PReadAll(int fd, void* buf, size_t count, off_t offset, 89 ssize_t* out_bytes_read); 90 91 bool PReadAll(const FileDescriptorPtr& fd, void* buf, size_t count, 92 off_t offset, ssize_t* out_bytes_read); 93 94 // Opens |path| for reading and appends its entire content to the container 95 // pointed to by |out_p|. Returns true upon successfully reading all of the 96 // file's content, false otherwise, in which case the state of the output 97 // container is unknown. ReadFileChunk starts reading the file from |offset|; if 98 // |size| is not -1, only up to |size| bytes are read in. 99 bool ReadFile(const std::string& path, brillo::Blob* out_p); 100 bool ReadFile(const std::string& path, std::string* out_p); 101 bool ReadFileChunk(const std::string& path, off_t offset, off_t size, 102 brillo::Blob* out_p); 103 104 // Invokes |cmd| in a pipe and appends its stdout to the container pointed to by 105 // |out_p|. Returns true upon successfully reading all of the output, false 106 // otherwise, in which case the state of the output container is unknown. 107 bool ReadPipe(const std::string& cmd, std::string* out_p); 108 109 // Returns the size of the block device at the file descriptor fd. If an error 110 // occurs, -1 is returned. 111 off_t BlockDevSize(int fd); 112 113 // Returns the size of the file at path, or the file desciptor fd. If the file 114 // is actually a block device, this function will automatically call 115 // BlockDevSize. If the file doesn't exist or some error occurrs, -1 is 116 // returned. 117 off_t FileSize(const std::string& path); 118 off_t FileSize(int fd); 119 120 std::string ErrnoNumberAsString(int err); 121 122 // Returns true if the file exists for sure. Returns false if it doesn't exist, 123 // or an error occurs. 124 bool FileExists(const char* path); 125 126 // Returns true if |path| exists and is a symbolic link. 127 bool IsSymlink(const char* path); 128 129 // Try attaching UBI |volume_num|. If there is any error executing required 130 // commands to attach the volume, this function returns false. This function 131 // only returns true if "/dev/ubi%d_0" becomes available in |timeout| seconds. 132 bool TryAttachingUbiVolume(int volume_num, int timeout); 133 134 // Setup the directory |new_root_temp_dir| to be used as the root directory for 135 // temporary files instead of the system's default. If the directory doesn't 136 // exists, it will be created when first used. 137 // NOTE: The memory pointed by |new_root_temp_dir| must be available until this 138 // function is called again with a different value. 139 void SetRootTempDir(const char* new_root_temp_dir); 140 141 // If |base_filename_template| is neither absolute (starts with "/") nor 142 // explicitly relative to the current working directory (starts with "./" or 143 // "../"), then it is prepended the system's temporary directory. On success, 144 // stores the name of the new temporary file in |filename|. If |fd| is 145 // non-null, the file descriptor returned by mkstemp is written to it and 146 // kept open; otherwise, it is closed. The template must end with "XXXXXX". 147 // Returns true on success. 148 bool MakeTempFile(const std::string& base_filename_template, 149 std::string* filename, 150 int* fd); 151 152 // Splits the partition device name into the block device name and partition 153 // number. For example, "/dev/sda3" will be split into {"/dev/sda", 3} and 154 // "/dev/mmcblk0p2" into {"/dev/mmcblk0", 2} 155 // Returns false when malformed device name is passed in. 156 // If both output parameters are omitted (null), can be used 157 // just to test the validity of the device name. Note that the function 158 // simply checks if the device name looks like a valid device, no other 159 // checks are performed (i.e. it doesn't check if the device actually exists). 160 bool SplitPartitionName(const std::string& partition_name, 161 std::string* out_disk_name, 162 int* out_partition_num); 163 164 // Builds a partition device name from the block device name and partition 165 // number. For example: 166 // {"/dev/sda", 1} => "/dev/sda1" 167 // {"/dev/mmcblk2", 12} => "/dev/mmcblk2p12" 168 // Returns empty string when invalid parameters are passed in 169 std::string MakePartitionName(const std::string& disk_name, 170 int partition_num); 171 172 // Similar to "MakePartitionName" but returns a name that is suitable for 173 // mounting. On NAND system we can write to "/dev/ubiX_0", which is what 174 // MakePartitionName returns, but we cannot mount that device. To mount, we 175 // have to use "/dev/ubiblockX_0" for rootfs. Stateful and OEM partitions are 176 // mountable with "/dev/ubiX_0". The input is a partition device such as 177 // /dev/sda3. Return empty string on error. 178 std::string MakePartitionNameForMount(const std::string& part_name); 179 180 // Set the read-only attribute on the block device |device| to the value passed 181 // in |read_only|. Return whether the operation succeeded. 182 bool SetBlockDeviceReadOnly(const std::string& device, bool read_only); 183 184 // Synchronously mount or unmount a filesystem. Return true on success. 185 // When mounting, it will attempt to mount the device as the passed filesystem 186 // type |type|, with the passed |flags| options. If |type| is empty, "ext2", 187 // "ext3", "ext4" and "squashfs" will be tried. 188 bool MountFilesystem(const std::string& device, 189 const std::string& mountpoint, 190 unsigned long flags, // NOLINT(runtime/int) 191 const std::string& type, 192 const std::string& fs_mount_options); 193 bool UnmountFilesystem(const std::string& mountpoint); 194 195 // Return whether the passed |mountpoint| path is a directory where a filesystem 196 // is mounted. Due to detection mechanism limitations, when used on directories 197 // where another part of the tree was bind mounted returns true only if bind 198 // mounted on top of a different filesystem (not inside the same filesystem). 199 bool IsMountpoint(const std::string& mountpoint); 200 201 // Returns a human-readable string with the file format based on magic constants 202 // on the header of the file. 203 std::string GetFileFormat(const std::string& path); 204 205 // Returns the string representation of the given UTC time. 206 // such as "11/14/2011 14:05:30 GMT". 207 std::string ToString(const base::Time utc_time); 208 209 // Returns true or false depending on the value of b. 210 std::string ToString(bool b); 211 212 // Returns a string representation of the given enum. 213 std::string ToString(DownloadSource source); 214 215 // Returns a string representation of the given enum. 216 std::string ToString(PayloadType payload_type); 217 218 // Fuzzes an integer |value| randomly in the range: 219 // [value - range / 2, value + range - range / 2] 220 int FuzzInt(int value, unsigned int range); 221 222 // Log a string in hex to LOG(INFO). Useful for debugging. 223 void HexDumpArray(const uint8_t* const arr, const size_t length); 224 inline void HexDumpString(const std::string& str) { 225 HexDumpArray(reinterpret_cast<const uint8_t*>(str.data()), str.size()); 226 } 227 inline void HexDumpVector(const brillo::Blob& vect) { 228 HexDumpArray(vect.data(), vect.size()); 229 } 230 231 template<typename KeyType, typename ValueType> 232 bool MapContainsKey(const std::map<KeyType, ValueType>& m, const KeyType& k) { 233 return m.find(k) != m.end(); 234 } 235 template<typename KeyType> 236 bool SetContainsKey(const std::set<KeyType>& s, const KeyType& k) { 237 return s.find(k) != s.end(); 238 } 239 240 template<typename T> 241 bool VectorContainsValue(const std::vector<T>& vect, const T& value) { 242 return std::find(vect.begin(), vect.end(), value) != vect.end(); 243 } 244 245 template<typename T> 246 bool VectorIndexOf(const std::vector<T>& vect, const T& value, 247 typename std::vector<T>::size_type* out_index) { 248 typename std::vector<T>::const_iterator it = std::find(vect.begin(), 249 vect.end(), 250 value); 251 if (it == vect.end()) { 252 return false; 253 } else { 254 *out_index = it - vect.begin(); 255 return true; 256 } 257 } 258 259 // Return the total number of blocks in the passed |extents| collection. 260 template <class T> 261 uint64_t BlocksInExtents(const T& extents) { 262 uint64_t sum = 0; 263 for (const auto& ext : extents) { 264 sum += ext.num_blocks(); 265 } 266 return sum; 267 } 268 269 // Converts seconds into human readable notation including days, hours, minutes 270 // and seconds. For example, 185 will yield 3m5s, 4300 will yield 1h11m40s, and 271 // 360000 will yield 4d4h0m0s. Zero padding not applied. Seconds are always 272 // shown in the result. 273 std::string FormatSecs(unsigned secs); 274 275 // Converts a TimeDelta into human readable notation including days, hours, 276 // minutes, seconds and fractions of a second down to microsecond granularity, 277 // as necessary; for example, an output of 5d2h0m15.053s means that the input 278 // time was precise to the milliseconds only. Zero padding not applied, except 279 // for fractions. Seconds are always shown, but fractions thereof are only shown 280 // when applicable. If |delta| is negative, the output will have a leading '-' 281 // followed by the absolute duration. 282 std::string FormatTimeDelta(base::TimeDelta delta); 283 284 // This method transforms the given error code to be suitable for UMA and 285 // for error classification purposes by removing the higher order bits and 286 // aggregating error codes beyond the enum range, etc. This method is 287 // idempotent, i.e. if called with a value previously returned by this method, 288 // it'll return the same value again. 289 ErrorCode GetBaseErrorCode(ErrorCode code); 290 291 // Decodes the data in |base64_encoded| and stores it in a temporary 292 // file. Returns false if the given data is empty, not well-formed 293 // base64 or if an error occurred. If true is returned, the decoded 294 // data is stored in the file returned in |out_path|. The file should 295 // be deleted when no longer needed. 296 bool DecodeAndStoreBase64String(const std::string& base64_encoded, 297 base::FilePath *out_path); 298 299 // Converts |time| to an Omaha InstallDate which is defined as "the 300 // number of PST8PDT calendar weeks since Jan 1st 2007 0:00 PST, times 301 // seven" with PST8PDT defined as "Pacific Time" (e.g. UTC-07:00 if 302 // daylight savings is observed and UTC-08:00 otherwise.) 303 // 304 // If the passed in |time| variable is before Monday January 1st 2007 305 // 0:00 PST, False is returned and the value returned in 306 // |out_num_days| is undefined. Otherwise the number of PST8PDT 307 // calendar weeks since that date times seven is returned in 308 // |out_num_days| and the function returns True. 309 // 310 // (NOTE: This function does not currently take daylight savings time 311 // into account so the result may up to one hour off. This is because 312 // the glibc date and timezone routines depend on the TZ environment 313 // variable and changing environment variables is not thread-safe. 314 bool ConvertToOmahaInstallDate(base::Time time, int *out_num_days); 315 316 // Look for the minor version value in the passed |store| and set 317 // |minor_version| to that value. Return whether the value was found and valid. 318 bool GetMinorVersion(const brillo::KeyValueStore& store, 319 uint32_t* minor_version); 320 321 // This function reads the specified data in |extents| into |out_data|. The 322 // extents are read from the file at |path|. |out_data_size| is the size of 323 // |out_data|. Returns false if the number of bytes to read given in 324 // |extents| does not equal |out_data_size|. 325 bool ReadExtents(const std::string& path, const std::vector<Extent>& extents, 326 brillo::Blob* out_data, ssize_t out_data_size, 327 size_t block_size); 328 329 // Read the current boot identifier and store it in |boot_id|. This identifier 330 // is constants during the same boot of the kernel and is regenerated after 331 // reboot. Returns whether it succeeded getting the boot_id. 332 bool GetBootId(std::string* boot_id); 333 334 } // namespace utils 335 336 337 // Utility class to close a file descriptor 338 class ScopedFdCloser { 339 public: 340 explicit ScopedFdCloser(int* fd) : fd_(fd) {} 341 ~ScopedFdCloser() { 342 if (should_close_ && fd_ && (*fd_ >= 0) && !IGNORE_EINTR(close(*fd_))) 343 *fd_ = -1; 344 } 345 void set_should_close(bool should_close) { should_close_ = should_close; } 346 private: 347 int* fd_; 348 bool should_close_ = true; 349 DISALLOW_COPY_AND_ASSIGN(ScopedFdCloser); 350 }; 351 352 // Utility class to delete a file when it goes out of scope. 353 class ScopedPathUnlinker { 354 public: 355 explicit ScopedPathUnlinker(const std::string& path) 356 : path_(path), 357 should_remove_(true) {} 358 ~ScopedPathUnlinker() { 359 if (should_remove_ && unlink(path_.c_str()) < 0) { 360 PLOG(ERROR) << "Unable to unlink path " << path_; 361 } 362 } 363 void set_should_remove(bool should_remove) { should_remove_ = should_remove; } 364 365 private: 366 const std::string path_; 367 bool should_remove_; 368 DISALLOW_COPY_AND_ASSIGN(ScopedPathUnlinker); 369 }; 370 371 // A little object to call ActionComplete on the ActionProcessor when 372 // it's destructed. 373 class ScopedActionCompleter { 374 public: 375 explicit ScopedActionCompleter(ActionProcessor* processor, 376 AbstractAction* action) 377 : processor_(processor), 378 action_(action), 379 code_(ErrorCode::kError), 380 should_complete_(true) {} 381 ~ScopedActionCompleter() { 382 if (should_complete_) 383 processor_->ActionComplete(action_, code_); 384 } 385 void set_code(ErrorCode code) { code_ = code; } 386 void set_should_complete(bool should_complete) { 387 should_complete_ = should_complete; 388 } 389 ErrorCode get_code() const { return code_; } 390 391 private: 392 ActionProcessor* processor_; 393 AbstractAction* action_; 394 ErrorCode code_; 395 bool should_complete_; 396 DISALLOW_COPY_AND_ASSIGN(ScopedActionCompleter); 397 }; 398 399 } // namespace chromeos_update_engine 400 401 #define TEST_AND_RETURN_FALSE_ERRNO(_x) \ 402 do { \ 403 bool _success = static_cast<bool>(_x); \ 404 if (!_success) { \ 405 std::string _msg = \ 406 chromeos_update_engine::utils::ErrnoNumberAsString(errno); \ 407 LOG(ERROR) << #_x " failed: " << _msg; \ 408 return false; \ 409 } \ 410 } while (0) 411 412 #define TEST_AND_RETURN_FALSE(_x) \ 413 do { \ 414 bool _success = static_cast<bool>(_x); \ 415 if (!_success) { \ 416 LOG(ERROR) << #_x " failed."; \ 417 return false; \ 418 } \ 419 } while (0) 420 421 #define TEST_AND_RETURN_ERRNO(_x) \ 422 do { \ 423 bool _success = static_cast<bool>(_x); \ 424 if (!_success) { \ 425 std::string _msg = \ 426 chromeos_update_engine::utils::ErrnoNumberAsString(errno); \ 427 LOG(ERROR) << #_x " failed: " << _msg; \ 428 return; \ 429 } \ 430 } while (0) 431 432 #define TEST_AND_RETURN(_x) \ 433 do { \ 434 bool _success = static_cast<bool>(_x); \ 435 if (!_success) { \ 436 LOG(ERROR) << #_x " failed."; \ 437 return; \ 438 } \ 439 } while (0) 440 441 #define TEST_AND_RETURN_FALSE_ERRCODE(_x) \ 442 do { \ 443 errcode_t _error = (_x); \ 444 if (_error) { \ 445 errno = _error; \ 446 LOG(ERROR) << #_x " failed: " << _error; \ 447 return false; \ 448 } \ 449 } while (0) 450 451 #endif // UPDATE_ENGINE_COMMON_UTILS_H_ 452
