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, off_t offset, 92 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 // Converts seconds into human readable notation including days, hours, minutes 260 // and seconds. For example, 185 will yield 3m5s, 4300 will yield 1h11m40s, and 261 // 360000 will yield 4d4h0m0s. Zero padding not applied. Seconds are always 262 // shown in the result. 263 std::string FormatSecs(unsigned secs); 264 265 // Converts a TimeDelta into human readable notation including days, hours, 266 // minutes, seconds and fractions of a second down to microsecond granularity, 267 // as necessary; for example, an output of 5d2h0m15.053s means that the input 268 // time was precise to the milliseconds only. Zero padding not applied, except 269 // for fractions. Seconds are always shown, but fractions thereof are only shown 270 // when applicable. If |delta| is negative, the output will have a leading '-' 271 // followed by the absolute duration. 272 std::string FormatTimeDelta(base::TimeDelta delta); 273 274 // This method transforms the given error code to be suitable for UMA and 275 // for error classification purposes by removing the higher order bits and 276 // aggregating error codes beyond the enum range, etc. This method is 277 // idempotent, i.e. if called with a value previously returned by this method, 278 // it'll return the same value again. 279 ErrorCode GetBaseErrorCode(ErrorCode code); 280 281 // Decodes the data in |base64_encoded| and stores it in a temporary 282 // file. Returns false if the given data is empty, not well-formed 283 // base64 or if an error occurred. If true is returned, the decoded 284 // data is stored in the file returned in |out_path|. The file should 285 // be deleted when no longer needed. 286 bool DecodeAndStoreBase64String(const std::string& base64_encoded, 287 base::FilePath *out_path); 288 289 // Converts |time| to an Omaha InstallDate which is defined as "the 290 // number of PST8PDT calendar weeks since Jan 1st 2007 0:00 PST, times 291 // seven" with PST8PDT defined as "Pacific Time" (e.g. UTC-07:00 if 292 // daylight savings is observed and UTC-08:00 otherwise.) 293 // 294 // If the passed in |time| variable is before Monday January 1st 2007 295 // 0:00 PST, False is returned and the value returned in 296 // |out_num_days| is undefined. Otherwise the number of PST8PDT 297 // calendar weeks since that date times seven is returned in 298 // |out_num_days| and the function returns True. 299 // 300 // (NOTE: This function does not currently take daylight savings time 301 // into account so the result may up to one hour off. This is because 302 // the glibc date and timezone routines depend on the TZ environment 303 // variable and changing environment variables is not thread-safe. 304 bool ConvertToOmahaInstallDate(base::Time time, int *out_num_days); 305 306 // Look for the minor version value in the passed |store| and set 307 // |minor_version| to that value. Return whether the value was found and valid. 308 bool GetMinorVersion(const brillo::KeyValueStore& store, 309 uint32_t* minor_version); 310 311 // Returns whether zlib |fingerprint| is compatible with zlib we are using. 312 bool IsZlibCompatible(const std::string& fingerprint); 313 314 // This function reads the specified data in |extents| into |out_data|. The 315 // extents are read from the file at |path|. |out_data_size| is the size of 316 // |out_data|. Returns false if the number of bytes to read given in 317 // |extents| does not equal |out_data_size|. 318 bool ReadExtents(const std::string& path, const std::vector<Extent>& extents, 319 brillo::Blob* out_data, ssize_t out_data_size, 320 size_t block_size); 321 322 // Read the current boot identifier and store it in |boot_id|. This identifier 323 // is constants during the same boot of the kernel and is regenerated after 324 // reboot. Returns whether it succeeded getting the boot_id. 325 bool GetBootId(std::string* boot_id); 326 327 } // namespace utils 328 329 330 // Utility class to close a file descriptor 331 class ScopedFdCloser { 332 public: 333 explicit ScopedFdCloser(int* fd) : fd_(fd) {} 334 ~ScopedFdCloser() { 335 if (should_close_ && fd_ && (*fd_ >= 0) && !IGNORE_EINTR(close(*fd_))) 336 *fd_ = -1; 337 } 338 void set_should_close(bool should_close) { should_close_ = should_close; } 339 private: 340 int* fd_; 341 bool should_close_ = true; 342 DISALLOW_COPY_AND_ASSIGN(ScopedFdCloser); 343 }; 344 345 // Utility class to delete a file when it goes out of scope. 346 class ScopedPathUnlinker { 347 public: 348 explicit ScopedPathUnlinker(const std::string& path) 349 : path_(path), 350 should_remove_(true) {} 351 ~ScopedPathUnlinker() { 352 if (should_remove_ && unlink(path_.c_str()) < 0) { 353 PLOG(ERROR) << "Unable to unlink path " << path_; 354 } 355 } 356 void set_should_remove(bool should_remove) { should_remove_ = should_remove; } 357 358 private: 359 const std::string path_; 360 bool should_remove_; 361 DISALLOW_COPY_AND_ASSIGN(ScopedPathUnlinker); 362 }; 363 364 // A little object to call ActionComplete on the ActionProcessor when 365 // it's destructed. 366 class ScopedActionCompleter { 367 public: 368 explicit ScopedActionCompleter(ActionProcessor* processor, 369 AbstractAction* action) 370 : processor_(processor), 371 action_(action), 372 code_(ErrorCode::kError), 373 should_complete_(true) {} 374 ~ScopedActionCompleter() { 375 if (should_complete_) 376 processor_->ActionComplete(action_, code_); 377 } 378 void set_code(ErrorCode code) { code_ = code; } 379 void set_should_complete(bool should_complete) { 380 should_complete_ = should_complete; 381 } 382 ErrorCode get_code() const { return code_; } 383 384 private: 385 ActionProcessor* processor_; 386 AbstractAction* action_; 387 ErrorCode code_; 388 bool should_complete_; 389 DISALLOW_COPY_AND_ASSIGN(ScopedActionCompleter); 390 }; 391 392 } // namespace chromeos_update_engine 393 394 #define TEST_AND_RETURN_FALSE_ERRNO(_x) \ 395 do { \ 396 bool _success = static_cast<bool>(_x); \ 397 if (!_success) { \ 398 std::string _msg = \ 399 chromeos_update_engine::utils::ErrnoNumberAsString(errno); \ 400 LOG(ERROR) << #_x " failed: " << _msg; \ 401 return false; \ 402 } \ 403 } while (0) 404 405 #define TEST_AND_RETURN_FALSE(_x) \ 406 do { \ 407 bool _success = static_cast<bool>(_x); \ 408 if (!_success) { \ 409 LOG(ERROR) << #_x " failed."; \ 410 return false; \ 411 } \ 412 } while (0) 413 414 #define TEST_AND_RETURN_ERRNO(_x) \ 415 do { \ 416 bool _success = static_cast<bool>(_x); \ 417 if (!_success) { \ 418 std::string _msg = \ 419 chromeos_update_engine::utils::ErrnoNumberAsString(errno); \ 420 LOG(ERROR) << #_x " failed: " << _msg; \ 421 return; \ 422 } \ 423 } while (0) 424 425 #define TEST_AND_RETURN(_x) \ 426 do { \ 427 bool _success = static_cast<bool>(_x); \ 428 if (!_success) { \ 429 LOG(ERROR) << #_x " failed."; \ 430 return; \ 431 } \ 432 } while (0) 433 434 #define TEST_AND_RETURN_FALSE_ERRCODE(_x) \ 435 do { \ 436 errcode_t _error = (_x); \ 437 if (_error) { \ 438 errno = _error; \ 439 LOG(ERROR) << #_x " failed: " << _error; \ 440 return false; \ 441 } \ 442 } while (0) 443 444 #endif // UPDATE_ENGINE_COMMON_UTILS_H_ 445
