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 #include "update_engine/common/utils.h"
18
19 #include <stdint.h>
20
21 #include <dirent.h>
22 #include <elf.h>
23 #include <endian.h>
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/mount.h>
30 #include <sys/resource.h>
31 #include <sys/stat.h>
32 #include <sys/types.h>
33 #include <time.h>
34 #include <unistd.h>
35
36 #include <algorithm>
37 #include <utility>
38 #include <vector>
39
40 #include <base/callback.h>
41 #include <base/files/file_path.h>
42 #include <base/files/file_util.h>
43 #include <base/files/scoped_file.h>
44 #include <base/format_macros.h>
45 #include <base/location.h>
46 #include <base/logging.h>
47 #include <base/posix/eintr_wrapper.h>
48 #include <base/rand_util.h>
49 #include <base/strings/string_number_conversions.h>
50 #include <base/strings/string_split.h>
51 #include <base/strings/string_util.h>
52 #include <base/strings/stringprintf.h>
53 #include <brillo/data_encoding.h>
54
55 #include "update_engine/common/clock_interface.h"
56 #include "update_engine/common/constants.h"
57 #include "update_engine/common/platform_constants.h"
58 #include "update_engine/common/prefs_interface.h"
59 #include "update_engine/common/subprocess.h"
60 #include "update_engine/payload_consumer/file_descriptor.h"
61
62 using base::Time;
63 using base::TimeDelta;
64 using std::min;
65 using std::numeric_limits;
66 using std::pair;
67 using std::string;
68 using std::vector;
69
70 namespace chromeos_update_engine {
71
72 namespace {
73
74 // The following constants control how UnmountFilesystem should retry if
75 // umount() fails with an errno EBUSY, i.e. retry 5 times over the course of
76 // one second.
77 const int kUnmountMaxNumOfRetries = 5;
78 const int kUnmountRetryIntervalInMicroseconds = 200 * 1000; // 200 ms
79
80 // Number of bytes to read from a file to attempt to detect its contents. Used
81 // in GetFileFormat.
82 const int kGetFileFormatMaxHeaderSize = 32;
83
84 // The path to the kernel's boot_id.
85 const char kBootIdPath[] = "/proc/sys/kernel/random/boot_id";
86
87 // If |path| is absolute, or explicit relative to the current working directory,
88 // leaves it as is. Otherwise, uses the system's temp directory, as defined by
89 // base::GetTempDir() and prepends it to |path|. On success stores the full
90 // temporary path in |template_path| and returns true.
GetTempName(const string & path,base::FilePath * template_path)91 bool GetTempName(const string& path, base::FilePath* template_path) {
92 if (path[0] == '/' ||
93 base::StartsWith(path, "./", base::CompareCase::SENSITIVE) ||
94 base::StartsWith(path, "../", base::CompareCase::SENSITIVE)) {
95 *template_path = base::FilePath(path);
96 return true;
97 }
98
99 base::FilePath temp_dir;
100 #ifdef __ANDROID__
101 temp_dir = base::FilePath(constants::kNonVolatileDirectory).Append("tmp");
102 #else
103 TEST_AND_RETURN_FALSE(base::GetTempDir(&temp_dir));
104 #endif // __ANDROID__
105 if (!base::PathExists(temp_dir))
106 TEST_AND_RETURN_FALSE(base::CreateDirectory(temp_dir));
107 *template_path = temp_dir.Append(path);
108 return true;
109 }
110
111 } // namespace
112
113 namespace utils {
114
ParseECVersion(string input_line)115 string ParseECVersion(string input_line) {
116 base::TrimWhitespaceASCII(input_line, base::TRIM_ALL, &input_line);
117
118 // At this point we want to convert the format key=value pair from mosys to
119 // a vector of key value pairs.
120 vector<pair<string, string>> kv_pairs;
121 if (base::SplitStringIntoKeyValuePairs(input_line, '=', ' ', &kv_pairs)) {
122 for (const pair<string, string>& kv_pair : kv_pairs) {
123 // Finally match against the fw_verion which may have quotes.
124 if (kv_pair.first == "fw_version") {
125 string output;
126 // Trim any quotes.
127 base::TrimString(kv_pair.second, "\"", &output);
128 return output;
129 }
130 }
131 }
132 LOG(ERROR) << "Unable to parse fwid from ec info.";
133 return "";
134 }
135
WriteFile(const char * path,const void * data,size_t data_len)136 bool WriteFile(const char* path, const void* data, size_t data_len) {
137 int fd = HANDLE_EINTR(open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600));
138 TEST_AND_RETURN_FALSE_ERRNO(fd >= 0);
139 ScopedFdCloser fd_closer(&fd);
140 return WriteAll(fd, data, data_len);
141 }
142
ReadAll(int fd,void * buf,size_t count,size_t * out_bytes_read,bool * eof)143 bool ReadAll(
144 int fd, void* buf, size_t count, size_t* out_bytes_read, bool* eof) {
145 char* c_buf = static_cast<char*>(buf);
146 size_t bytes_read = 0;
147 *eof = false;
148 while (bytes_read < count) {
149 ssize_t rc = HANDLE_EINTR(read(fd, c_buf + bytes_read, count - bytes_read));
150 if (rc < 0) {
151 // EAGAIN and EWOULDBLOCK are normal return values when there's no more
152 // input and we are in non-blocking mode.
153 if (errno != EWOULDBLOCK && errno != EAGAIN) {
154 PLOG(ERROR) << "Error reading fd " << fd;
155 *out_bytes_read = bytes_read;
156 return false;
157 }
158 break;
159 } else if (rc == 0) {
160 // A value of 0 means that we reached EOF and there is nothing else to
161 // read from this fd.
162 *eof = true;
163 break;
164 } else {
165 bytes_read += rc;
166 }
167 }
168 *out_bytes_read = bytes_read;
169 return true;
170 }
171
WriteAll(int fd,const void * buf,size_t count)172 bool WriteAll(int fd, const void* buf, size_t count) {
173 const char* c_buf = static_cast<const char*>(buf);
174 ssize_t bytes_written = 0;
175 while (bytes_written < static_cast<ssize_t>(count)) {
176 ssize_t rc = write(fd, c_buf + bytes_written, count - bytes_written);
177 TEST_AND_RETURN_FALSE_ERRNO(rc >= 0);
178 bytes_written += rc;
179 }
180 return true;
181 }
182
PWriteAll(int fd,const void * buf,size_t count,off_t offset)183 bool PWriteAll(int fd, const void* buf, size_t count, off_t offset) {
184 const char* c_buf = static_cast<const char*>(buf);
185 size_t bytes_written = 0;
186 int num_attempts = 0;
187 while (bytes_written < count) {
188 num_attempts++;
189 ssize_t rc = pwrite(fd,
190 c_buf + bytes_written,
191 count - bytes_written,
192 offset + bytes_written);
193 // TODO(garnold) for debugging failure in chromium-os:31077; to be removed.
194 if (rc < 0) {
195 PLOG(ERROR) << "pwrite error; num_attempts=" << num_attempts
196 << " bytes_written=" << bytes_written << " count=" << count
197 << " offset=" << offset;
198 }
199 TEST_AND_RETURN_FALSE_ERRNO(rc >= 0);
200 bytes_written += rc;
201 }
202 return true;
203 }
204
WriteAll(const FileDescriptorPtr & fd,const void * buf,size_t count)205 bool WriteAll(const FileDescriptorPtr& fd, const void* buf, size_t count) {
206 const char* c_buf = static_cast<const char*>(buf);
207 ssize_t bytes_written = 0;
208 while (bytes_written < static_cast<ssize_t>(count)) {
209 ssize_t rc = fd->Write(c_buf + bytes_written, count - bytes_written);
210 TEST_AND_RETURN_FALSE_ERRNO(rc >= 0);
211 bytes_written += rc;
212 }
213 return true;
214 }
215
PWriteAll(const FileDescriptorPtr & fd,const void * buf,size_t count,off_t offset)216 bool PWriteAll(const FileDescriptorPtr& fd,
217 const void* buf,
218 size_t count,
219 off_t offset) {
220 TEST_AND_RETURN_FALSE_ERRNO(fd->Seek(offset, SEEK_SET) !=
221 static_cast<off_t>(-1));
222 return WriteAll(fd, buf, count);
223 }
224
PReadAll(int fd,void * buf,size_t count,off_t offset,ssize_t * out_bytes_read)225 bool PReadAll(
226 int fd, void* buf, size_t count, off_t offset, ssize_t* out_bytes_read) {
227 char* c_buf = static_cast<char*>(buf);
228 ssize_t bytes_read = 0;
229 while (bytes_read < static_cast<ssize_t>(count)) {
230 ssize_t rc =
231 pread(fd, c_buf + bytes_read, count - bytes_read, offset + bytes_read);
232 TEST_AND_RETURN_FALSE_ERRNO(rc >= 0);
233 if (rc == 0) {
234 break;
235 }
236 bytes_read += rc;
237 }
238 *out_bytes_read = bytes_read;
239 return true;
240 }
241
PReadAll(const FileDescriptorPtr & fd,void * buf,size_t count,off_t offset,ssize_t * out_bytes_read)242 bool PReadAll(const FileDescriptorPtr& fd,
243 void* buf,
244 size_t count,
245 off_t offset,
246 ssize_t* out_bytes_read) {
247 TEST_AND_RETURN_FALSE_ERRNO(fd->Seek(offset, SEEK_SET) !=
248 static_cast<off_t>(-1));
249 char* c_buf = static_cast<char*>(buf);
250 ssize_t bytes_read = 0;
251 while (bytes_read < static_cast<ssize_t>(count)) {
252 ssize_t rc = fd->Read(c_buf + bytes_read, count - bytes_read);
253 TEST_AND_RETURN_FALSE_ERRNO(rc >= 0);
254 if (rc == 0) {
255 break;
256 }
257 bytes_read += rc;
258 }
259 *out_bytes_read = bytes_read;
260 return true;
261 }
262
263 // Append |nbytes| of content from |buf| to the vector pointed to by either
264 // |vec_p| or |str_p|.
AppendBytes(const uint8_t * buf,size_t nbytes,brillo::Blob * vec_p)265 static void AppendBytes(const uint8_t* buf,
266 size_t nbytes,
267 brillo::Blob* vec_p) {
268 CHECK(buf);
269 CHECK(vec_p);
270 vec_p->insert(vec_p->end(), buf, buf + nbytes);
271 }
AppendBytes(const uint8_t * buf,size_t nbytes,string * str_p)272 static void AppendBytes(const uint8_t* buf, size_t nbytes, string* str_p) {
273 CHECK(buf);
274 CHECK(str_p);
275 str_p->append(buf, buf + nbytes);
276 }
277
278 // Reads from an open file |fp|, appending the read content to the container
279 // pointer to by |out_p|. Returns true upon successful reading all of the
280 // file's content, false otherwise. If |size| is not -1, reads up to |size|
281 // bytes.
282 template <class T>
Read(FILE * fp,off_t size,T * out_p)283 static bool Read(FILE* fp, off_t size, T* out_p) {
284 CHECK(fp);
285 CHECK(size == -1 || size >= 0);
286 uint8_t buf[1024];
287 while (size == -1 || size > 0) {
288 off_t bytes_to_read = sizeof(buf);
289 if (size > 0 && bytes_to_read > size) {
290 bytes_to_read = size;
291 }
292 size_t nbytes = fread(buf, 1, bytes_to_read, fp);
293 if (!nbytes) {
294 break;
295 }
296 AppendBytes(buf, nbytes, out_p);
297 if (size != -1) {
298 CHECK(size >= static_cast<off_t>(nbytes));
299 size -= nbytes;
300 }
301 }
302 if (ferror(fp)) {
303 return false;
304 }
305 return size == 0 || feof(fp);
306 }
307
308 // Opens a file |path| for reading and appends its the contents to a container
309 // |out_p|. Starts reading the file from |offset|. If |offset| is beyond the end
310 // of the file, returns success. If |size| is not -1, reads up to |size| bytes.
311 template <class T>
ReadFileChunkAndAppend(const string & path,off_t offset,off_t size,T * out_p)312 static bool ReadFileChunkAndAppend(const string& path,
313 off_t offset,
314 off_t size,
315 T* out_p) {
316 CHECK_GE(offset, 0);
317 CHECK(size == -1 || size >= 0);
318 base::ScopedFILE fp(fopen(path.c_str(), "r"));
319 if (!fp.get())
320 return false;
321 if (offset) {
322 // Return success without appending any data if a chunk beyond the end of
323 // the file is requested.
324 if (offset >= FileSize(path)) {
325 return true;
326 }
327 TEST_AND_RETURN_FALSE_ERRNO(fseek(fp.get(), offset, SEEK_SET) == 0);
328 }
329 return Read(fp.get(), size, out_p);
330 }
331
332 // TODO(deymo): This is only used in unittest, but requires the private
333 // Read<string>() defined here. Expose Read<string>() or move to base/ version.
ReadPipe(const string & cmd,string * out_p)334 bool ReadPipe(const string& cmd, string* out_p) {
335 FILE* fp = popen(cmd.c_str(), "r");
336 if (!fp)
337 return false;
338 bool success = Read(fp, -1, out_p);
339 return (success && pclose(fp) >= 0);
340 }
341
ReadFile(const string & path,brillo::Blob * out_p)342 bool ReadFile(const string& path, brillo::Blob* out_p) {
343 return ReadFileChunkAndAppend(path, 0, -1, out_p);
344 }
345
ReadFile(const string & path,string * out_p)346 bool ReadFile(const string& path, string* out_p) {
347 return ReadFileChunkAndAppend(path, 0, -1, out_p);
348 }
349
ReadFileChunk(const string & path,off_t offset,off_t size,brillo::Blob * out_p)350 bool ReadFileChunk(const string& path,
351 off_t offset,
352 off_t size,
353 brillo::Blob* out_p) {
354 return ReadFileChunkAndAppend(path, offset, size, out_p);
355 }
356
BlockDevSize(int fd)357 off_t BlockDevSize(int fd) {
358 uint64_t dev_size;
359 int rc = ioctl(fd, BLKGETSIZE64, &dev_size);
360 if (rc == -1) {
361 dev_size = -1;
362 PLOG(ERROR) << "Error running ioctl(BLKGETSIZE64) on " << fd;
363 }
364 return dev_size;
365 }
366
FileSize(int fd)367 off_t FileSize(int fd) {
368 struct stat stbuf;
369 int rc = fstat(fd, &stbuf);
370 CHECK_EQ(rc, 0);
371 if (rc < 0) {
372 PLOG(ERROR) << "Error stat-ing " << fd;
373 return rc;
374 }
375 if (S_ISREG(stbuf.st_mode))
376 return stbuf.st_size;
377 if (S_ISBLK(stbuf.st_mode))
378 return BlockDevSize(fd);
379 LOG(ERROR) << "Couldn't determine the type of " << fd;
380 return -1;
381 }
382
FileSize(const string & path)383 off_t FileSize(const string& path) {
384 int fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
385 if (fd == -1) {
386 PLOG(ERROR) << "Error opening " << path;
387 return fd;
388 }
389 off_t size = FileSize(fd);
390 if (size == -1)
391 PLOG(ERROR) << "Error getting file size of " << path;
392 close(fd);
393 return size;
394 }
395
HexDumpArray(const uint8_t * const arr,const size_t length)396 void HexDumpArray(const uint8_t* const arr, const size_t length) {
397 LOG(INFO) << "Logging array of length: " << length;
398 const unsigned int bytes_per_line = 16;
399 for (uint32_t i = 0; i < length; i += bytes_per_line) {
400 const unsigned int bytes_remaining = length - i;
401 const unsigned int bytes_per_this_line =
402 min(bytes_per_line, bytes_remaining);
403 char header[100];
404 int r = snprintf(header, sizeof(header), "0x%08x : ", i);
405 TEST_AND_RETURN(r == 13);
406 string line = header;
407 for (unsigned int j = 0; j < bytes_per_this_line; j++) {
408 char buf[20];
409 uint8_t c = arr[i + j];
410 r = snprintf(buf, sizeof(buf), "%02x ", static_cast<unsigned int>(c));
411 TEST_AND_RETURN(r == 3);
412 line += buf;
413 }
414 LOG(INFO) << line;
415 }
416 }
417
SplitPartitionName(const string & partition_name,string * out_disk_name,int * out_partition_num)418 bool SplitPartitionName(const string& partition_name,
419 string* out_disk_name,
420 int* out_partition_num) {
421 if (!base::StartsWith(
422 partition_name, "/dev/", base::CompareCase::SENSITIVE)) {
423 LOG(ERROR) << "Invalid partition device name: " << partition_name;
424 return false;
425 }
426
427 size_t last_nondigit_pos = partition_name.find_last_not_of("0123456789");
428 if (last_nondigit_pos == string::npos ||
429 (last_nondigit_pos + 1) == partition_name.size()) {
430 LOG(ERROR) << "Unable to parse partition device name: " << partition_name;
431 return false;
432 }
433
434 if (out_disk_name) {
435 // Special case for MMC devices which have the following naming scheme:
436 // mmcblk0p2
437 size_t disk_name_len = last_nondigit_pos;
438 if (partition_name[last_nondigit_pos] != 'p' || last_nondigit_pos == 0 ||
439 !isdigit(partition_name[last_nondigit_pos - 1])) {
440 disk_name_len++;
441 }
442 *out_disk_name = partition_name.substr(0, disk_name_len);
443 }
444
445 if (out_partition_num) {
446 string partition_str = partition_name.substr(last_nondigit_pos + 1);
447 *out_partition_num = atoi(partition_str.c_str());
448 }
449 return true;
450 }
451
MakePartitionName(const string & disk_name,int partition_num)452 string MakePartitionName(const string& disk_name, int partition_num) {
453 if (partition_num < 1) {
454 LOG(ERROR) << "Invalid partition number: " << partition_num;
455 return string();
456 }
457
458 if (!base::StartsWith(disk_name, "/dev/", base::CompareCase::SENSITIVE)) {
459 LOG(ERROR) << "Invalid disk name: " << disk_name;
460 return string();
461 }
462
463 string partition_name = disk_name;
464 if (isdigit(partition_name.back())) {
465 // Special case for devices with names ending with a digit.
466 // Add "p" to separate the disk name from partition number,
467 // e.g. "/dev/loop0p2"
468 partition_name += 'p';
469 }
470
471 partition_name += std::to_string(partition_num);
472
473 return partition_name;
474 }
475
ErrnoNumberAsString(int err)476 string ErrnoNumberAsString(int err) {
477 char buf[100];
478 buf[0] = '\0';
479 return strerror_r(err, buf, sizeof(buf));
480 }
481
FileExists(const char * path)482 bool FileExists(const char* path) {
483 struct stat stbuf;
484 return 0 == lstat(path, &stbuf);
485 }
486
IsSymlink(const char * path)487 bool IsSymlink(const char* path) {
488 struct stat stbuf;
489 return lstat(path, &stbuf) == 0 && S_ISLNK(stbuf.st_mode) != 0;
490 }
491
MakeTempFile(const string & base_filename_template,string * filename,int * fd)492 bool MakeTempFile(const string& base_filename_template,
493 string* filename,
494 int* fd) {
495 base::FilePath filename_template;
496 TEST_AND_RETURN_FALSE(
497 GetTempName(base_filename_template, &filename_template));
498 DCHECK(filename || fd);
499 vector<char> buf(filename_template.value().size() + 1);
500 memcpy(buf.data(),
501 filename_template.value().data(),
502 filename_template.value().size());
503 buf[filename_template.value().size()] = '\0';
504
505 int mkstemp_fd = mkstemp(buf.data());
506 TEST_AND_RETURN_FALSE_ERRNO(mkstemp_fd >= 0);
507 if (filename) {
508 *filename = buf.data();
509 }
510 if (fd) {
511 *fd = mkstemp_fd;
512 } else {
513 close(mkstemp_fd);
514 }
515 return true;
516 }
517
SetBlockDeviceReadOnly(const string & device,bool read_only)518 bool SetBlockDeviceReadOnly(const string& device, bool read_only) {
519 int fd = HANDLE_EINTR(open(device.c_str(), O_RDONLY | O_CLOEXEC));
520 if (fd < 0) {
521 PLOG(ERROR) << "Opening block device " << device;
522 return false;
523 }
524 ScopedFdCloser fd_closer(&fd);
525 // We take no action if not needed.
526 int read_only_flag;
527 int expected_flag = read_only ? 1 : 0;
528 int rc = ioctl(fd, BLKROGET, &read_only_flag);
529 // In case of failure reading the setting we will try to set it anyway.
530 if (rc == 0 && read_only_flag == expected_flag)
531 return true;
532
533 rc = ioctl(fd, BLKROSET, &expected_flag);
534 if (rc != 0) {
535 PLOG(ERROR) << "Marking block device " << device
536 << " as read_only=" << expected_flag;
537 return false;
538 }
539 return true;
540 }
541
MountFilesystem(const string & device,const string & mountpoint,unsigned long mountflags,const string & type,const string & fs_mount_options)542 bool MountFilesystem(const string& device,
543 const string& mountpoint,
544 unsigned long mountflags, // NOLINT(runtime/int)
545 const string& type,
546 const string& fs_mount_options) {
547 vector<const char*> fstypes;
548 if (type.empty()) {
549 fstypes = {"ext2", "ext3", "ext4", "squashfs"};
550 } else {
551 fstypes = {type.c_str()};
552 }
553 for (const char* fstype : fstypes) {
554 int rc = mount(device.c_str(),
555 mountpoint.c_str(),
556 fstype,
557 mountflags,
558 fs_mount_options.c_str());
559 if (rc == 0)
560 return true;
561
562 PLOG(WARNING) << "Unable to mount destination device " << device << " on "
563 << mountpoint << " as " << fstype;
564 }
565 if (!type.empty()) {
566 LOG(ERROR) << "Unable to mount " << device << " with any supported type";
567 }
568 return false;
569 }
570
UnmountFilesystem(const string & mountpoint)571 bool UnmountFilesystem(const string& mountpoint) {
572 int num_retries = 1;
573 for (;; ++num_retries) {
574 if (umount(mountpoint.c_str()) == 0)
575 return true;
576 if (errno != EBUSY || num_retries >= kUnmountMaxNumOfRetries)
577 break;
578 usleep(kUnmountRetryIntervalInMicroseconds);
579 }
580 if (errno == EINVAL) {
581 LOG(INFO) << "Not a mountpoint: " << mountpoint;
582 return false;
583 }
584 PLOG(WARNING) << "Error unmounting " << mountpoint << " after " << num_retries
585 << " attempts. Lazy unmounting instead, error was";
586 if (umount2(mountpoint.c_str(), MNT_DETACH) != 0) {
587 PLOG(ERROR) << "Lazy unmount failed";
588 return false;
589 }
590 return true;
591 }
592
IsMountpoint(const std::string & mountpoint)593 bool IsMountpoint(const std::string& mountpoint) {
594 struct stat stdir, stparent;
595
596 // Check whether the passed mountpoint is a directory and the /.. is in the
597 // same device or not. If mountpoint/.. is in a different device it means that
598 // there is a filesystem mounted there. If it is not, but they both point to
599 // the same inode it basically is the special case of /.. pointing to /. This
600 // test doesn't play well with bind mount but that's out of the scope of what
601 // we want to detect here.
602 if (lstat(mountpoint.c_str(), &stdir) != 0) {
603 PLOG(ERROR) << "Error stat'ing " << mountpoint;
604 return false;
605 }
606 if (!S_ISDIR(stdir.st_mode))
607 return false;
608
609 base::FilePath parent(mountpoint);
610 parent = parent.Append("..");
611 if (lstat(parent.value().c_str(), &stparent) != 0) {
612 PLOG(ERROR) << "Error stat'ing " << parent.value();
613 return false;
614 }
615 return S_ISDIR(stparent.st_mode) &&
616 (stparent.st_dev != stdir.st_dev || stparent.st_ino == stdir.st_ino);
617 }
618
619 // Tries to parse the header of an ELF file to obtain a human-readable
620 // description of it on the |output| string.
GetFileFormatELF(const uint8_t * buffer,size_t size,string * output)621 static bool GetFileFormatELF(const uint8_t* buffer,
622 size_t size,
623 string* output) {
624 // 0x00: EI_MAG - ELF magic header, 4 bytes.
625 if (size < SELFMAG || memcmp(buffer, ELFMAG, SELFMAG) != 0)
626 return false;
627 *output = "ELF";
628
629 // 0x04: EI_CLASS, 1 byte.
630 if (size < EI_CLASS + 1)
631 return true;
632 switch (buffer[EI_CLASS]) {
633 case ELFCLASS32:
634 *output += " 32-bit";
635 break;
636 case ELFCLASS64:
637 *output += " 64-bit";
638 break;
639 default:
640 *output += " ?-bit";
641 }
642
643 // 0x05: EI_DATA, endianness, 1 byte.
644 if (size < EI_DATA + 1)
645 return true;
646 uint8_t ei_data = buffer[EI_DATA];
647 switch (ei_data) {
648 case ELFDATA2LSB:
649 *output += " little-endian";
650 break;
651 case ELFDATA2MSB:
652 *output += " big-endian";
653 break;
654 default:
655 *output += " ?-endian";
656 // Don't parse anything after the 0x10 offset if endianness is unknown.
657 return true;
658 }
659
660 const Elf32_Ehdr* hdr = reinterpret_cast<const Elf32_Ehdr*>(buffer);
661 // 0x12: e_machine, 2 byte endianness based on ei_data. The position (0x12)
662 // and size is the same for both 32 and 64 bits.
663 if (size < offsetof(Elf32_Ehdr, e_machine) + sizeof(hdr->e_machine))
664 return true;
665 uint16_t e_machine;
666 // Fix endianness regardless of the host endianness.
667 if (ei_data == ELFDATA2LSB)
668 e_machine = le16toh(hdr->e_machine);
669 else
670 e_machine = be16toh(hdr->e_machine);
671
672 switch (e_machine) {
673 case EM_386:
674 *output += " x86";
675 break;
676 case EM_MIPS:
677 *output += " mips";
678 break;
679 case EM_ARM:
680 *output += " arm";
681 break;
682 case EM_X86_64:
683 *output += " x86-64";
684 break;
685 default:
686 *output += " unknown-arch";
687 }
688 return true;
689 }
690
GetFileFormat(const string & path)691 string GetFileFormat(const string& path) {
692 brillo::Blob buffer;
693 if (!ReadFileChunkAndAppend(path, 0, kGetFileFormatMaxHeaderSize, &buffer))
694 return "File not found.";
695
696 string result;
697 if (GetFileFormatELF(buffer.data(), buffer.size(), &result))
698 return result;
699
700 return "data";
701 }
702
FuzzInt(int value,unsigned int range)703 int FuzzInt(int value, unsigned int range) {
704 int min = value - range / 2;
705 int max = value + range - range / 2;
706 return base::RandInt(min, max);
707 }
708
FormatSecs(unsigned secs)709 string FormatSecs(unsigned secs) {
710 return FormatTimeDelta(TimeDelta::FromSeconds(secs));
711 }
712
FormatTimeDelta(TimeDelta delta)713 string FormatTimeDelta(TimeDelta delta) {
714 string str;
715
716 // Handle negative durations by prefixing with a minus.
717 if (delta.ToInternalValue() < 0) {
718 delta *= -1;
719 str = "-";
720 }
721
722 // Canonicalize into days, hours, minutes, seconds and microseconds.
723 unsigned days = delta.InDays();
724 delta -= TimeDelta::FromDays(days);
725 unsigned hours = delta.InHours();
726 delta -= TimeDelta::FromHours(hours);
727 unsigned mins = delta.InMinutes();
728 delta -= TimeDelta::FromMinutes(mins);
729 unsigned secs = delta.InSeconds();
730 delta -= TimeDelta::FromSeconds(secs);
731 unsigned usecs = delta.InMicroseconds();
732
733 if (days)
734 base::StringAppendF(&str, "%ud", days);
735 if (days || hours)
736 base::StringAppendF(&str, "%uh", hours);
737 if (days || hours || mins)
738 base::StringAppendF(&str, "%um", mins);
739 base::StringAppendF(&str, "%u", secs);
740 if (usecs) {
741 int width = 6;
742 while ((usecs / 10) * 10 == usecs) {
743 usecs /= 10;
744 width--;
745 }
746 base::StringAppendF(&str, ".%0*u", width, usecs);
747 }
748 base::StringAppendF(&str, "s");
749 return str;
750 }
751
ToString(const Time utc_time)752 string ToString(const Time utc_time) {
753 Time::Exploded exp_time;
754 utc_time.UTCExplode(&exp_time);
755 return base::StringPrintf("%d/%d/%d %d:%02d:%02d GMT",
756 exp_time.month,
757 exp_time.day_of_month,
758 exp_time.year,
759 exp_time.hour,
760 exp_time.minute,
761 exp_time.second);
762 }
763
ToString(bool b)764 string ToString(bool b) {
765 return (b ? "true" : "false");
766 }
767
ToString(DownloadSource source)768 string ToString(DownloadSource source) {
769 switch (source) {
770 case kDownloadSourceHttpsServer:
771 return "HttpsServer";
772 case kDownloadSourceHttpServer:
773 return "HttpServer";
774 case kDownloadSourceHttpPeer:
775 return "HttpPeer";
776 case kNumDownloadSources:
777 return "Unknown";
778 // Don't add a default case to let the compiler warn about newly added
779 // download sources which should be added here.
780 }
781
782 return "Unknown";
783 }
784
ToString(PayloadType payload_type)785 string ToString(PayloadType payload_type) {
786 switch (payload_type) {
787 case kPayloadTypeDelta:
788 return "Delta";
789 case kPayloadTypeFull:
790 return "Full";
791 case kPayloadTypeForcedFull:
792 return "ForcedFull";
793 case kNumPayloadTypes:
794 return "Unknown";
795 // Don't add a default case to let the compiler warn about newly added
796 // payload types which should be added here.
797 }
798
799 return "Unknown";
800 }
801
GetBaseErrorCode(ErrorCode code)802 ErrorCode GetBaseErrorCode(ErrorCode code) {
803 // Ignore the higher order bits in the code by applying the mask as
804 // we want the enumerations to be in the small contiguous range
805 // with values less than ErrorCode::kUmaReportedMax.
806 ErrorCode base_code = static_cast<ErrorCode>(
807 static_cast<int>(code) & ~static_cast<int>(ErrorCode::kSpecialFlags));
808
809 // Make additional adjustments required for UMA and error classification.
810 // TODO(jaysri): Move this logic to UeErrorCode.cc when we fix
811 // chromium-os:34369.
812 if (base_code >= ErrorCode::kOmahaRequestHTTPResponseBase) {
813 // Since we want to keep the enums to a small value, aggregate all HTTP
814 // errors into this one bucket for UMA and error classification purposes.
815 LOG(INFO) << "Converting error code " << base_code
816 << " to ErrorCode::kOmahaErrorInHTTPResponse";
817 base_code = ErrorCode::kOmahaErrorInHTTPResponse;
818 }
819
820 return base_code;
821 }
822
StringVectorToString(const vector<string> & vec_str)823 string StringVectorToString(const vector<string> &vec_str) {
824 string str = "[";
825 for (vector<string>::const_iterator i = vec_str.begin(); i != vec_str.end();
826 ++i) {
827 if (i != vec_str.begin())
828 str += ", ";
829 str += '"';
830 str += *i;
831 str += '"';
832 }
833 str += "]";
834 return str;
835 }
836
837 // The P2P file id should be the same for devices running new version and old
838 // version so that they can share it with each other. The hash in the response
839 // was base64 encoded, but now that we switched to use "hash_sha256" field which
840 // is hex encoded, we have to convert them back to base64 for P2P. However, the
841 // base64 encoded hash was base64 encoded here again historically for some
842 // reason, so we keep the same behavior here.
CalculateP2PFileId(const brillo::Blob & payload_hash,size_t payload_size)843 string CalculateP2PFileId(const brillo::Blob& payload_hash,
844 size_t payload_size) {
845 string encoded_hash = brillo::data_encoding::Base64Encode(
846 brillo::data_encoding::Base64Encode(payload_hash));
847 return base::StringPrintf("cros_update_size_%" PRIuS "_hash_%s",
848 payload_size,
849 encoded_hash.c_str());
850 }
851
ConvertToOmahaInstallDate(Time time,int * out_num_days)852 bool ConvertToOmahaInstallDate(Time time, int *out_num_days) {
853 time_t unix_time = time.ToTimeT();
854 // Output of: date +"%s" --date="Jan 1, 2007 0:00 PST".
855 const time_t kOmahaEpoch = 1167638400;
856 const int64_t kNumSecondsPerWeek = 7 * 24 * 3600;
857 const int64_t kNumDaysPerWeek = 7;
858
859 time_t omaha_time = unix_time - kOmahaEpoch;
860
861 if (omaha_time < 0)
862 return false;
863
864 // Note, as per the comment in utils.h we are deliberately not
865 // handling DST correctly.
866
867 int64_t num_weeks_since_omaha_epoch = omaha_time / kNumSecondsPerWeek;
868 *out_num_days = num_weeks_since_omaha_epoch * kNumDaysPerWeek;
869
870 return true;
871 }
872
GetMinorVersion(const brillo::KeyValueStore & store,uint32_t * minor_version)873 bool GetMinorVersion(const brillo::KeyValueStore& store,
874 uint32_t* minor_version) {
875 string result;
876 if (store.GetString("PAYLOAD_MINOR_VERSION", &result)) {
877 if (!base::StringToUint(result, minor_version)) {
878 LOG(ERROR) << "StringToUint failed when parsing delta minor version.";
879 return false;
880 }
881 return true;
882 }
883 return false;
884 }
885
ReadExtents(const string & path,const vector<Extent> & extents,brillo::Blob * out_data,ssize_t out_data_size,size_t block_size)886 bool ReadExtents(const string& path,
887 const vector<Extent>& extents,
888 brillo::Blob* out_data,
889 ssize_t out_data_size,
890 size_t block_size) {
891 brillo::Blob data(out_data_size);
892 ssize_t bytes_read = 0;
893 int fd = open(path.c_str(), O_RDONLY);
894 TEST_AND_RETURN_FALSE_ERRNO(fd >= 0);
895 ScopedFdCloser fd_closer(&fd);
896
897 for (const Extent& extent : extents) {
898 ssize_t bytes_read_this_iteration = 0;
899 ssize_t bytes = extent.num_blocks() * block_size;
900 TEST_AND_RETURN_FALSE(bytes_read + bytes <= out_data_size);
901 TEST_AND_RETURN_FALSE(utils::PReadAll(fd,
902 &data[bytes_read],
903 bytes,
904 extent.start_block() * block_size,
905 &bytes_read_this_iteration));
906 TEST_AND_RETURN_FALSE(bytes_read_this_iteration == bytes);
907 bytes_read += bytes_read_this_iteration;
908 }
909 TEST_AND_RETURN_FALSE(out_data_size == bytes_read);
910 *out_data = data;
911 return true;
912 }
913
GetBootId(string * boot_id)914 bool GetBootId(string* boot_id) {
915 TEST_AND_RETURN_FALSE(
916 base::ReadFileToString(base::FilePath(kBootIdPath), boot_id));
917 base::TrimWhitespaceASCII(*boot_id, base::TRIM_TRAILING, boot_id);
918 return true;
919 }
920
VersionPrefix(const std::string & version)921 int VersionPrefix(const std::string& version) {
922 if (version.empty()) {
923 return 0;
924 }
925 vector<string> tokens = base::SplitString(
926 version, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
927 int value;
928 if (tokens.empty() || !base::StringToInt(tokens[0], &value))
929 return -1; // Target version is invalid.
930 return value;
931 }
932
ParseRollbackKeyVersion(const string & raw_version,uint16_t * high_version,uint16_t * low_version)933 void ParseRollbackKeyVersion(const string& raw_version,
934 uint16_t* high_version,
935 uint16_t* low_version) {
936 DCHECK(high_version);
937 DCHECK(low_version);
938 *high_version = numeric_limits<uint16_t>::max();
939 *low_version = numeric_limits<uint16_t>::max();
940
941 vector<string> parts = base::SplitString(
942 raw_version, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
943 if (parts.size() != 2) {
944 // The version string must have exactly one period.
945 return;
946 }
947
948 int high;
949 int low;
950 if (!(base::StringToInt(parts[0], &high) &&
951 base::StringToInt(parts[1], &low))) {
952 // Both parts of the version could not be parsed correctly.
953 return;
954 }
955
956 if (high >= 0 && high < numeric_limits<uint16_t>::max() && low >= 0 &&
957 low < numeric_limits<uint16_t>::max()) {
958 *high_version = static_cast<uint16_t>(high);
959 *low_version = static_cast<uint16_t>(low);
960 }
961 }
962
GetFilePath(int fd)963 string GetFilePath(int fd) {
964 base::FilePath proc("/proc/self/fd/" + std::to_string(fd));
965 base::FilePath file_name;
966
967 if (!base::ReadSymbolicLink(proc, &file_name)) {
968 return "not found";
969 }
970 return file_name.value();
971 }
972
GetTimeAsString(time_t utime)973 string GetTimeAsString(time_t utime) {
974 struct tm tm;
975 CHECK_EQ(localtime_r(&utime, &tm), &tm);
976 char str[16];
977 CHECK_EQ(strftime(str, sizeof(str), "%Y%m%d-%H%M%S", &tm), 15u);
978 return str;
979 }
980
GetExclusionName(const string & str_to_convert)981 string GetExclusionName(const string& str_to_convert) {
982 return base::NumberToString(base::StringPieceHash()(str_to_convert));
983 }
984
985 } // namespace utils
986
987 } // namespace chromeos_update_engine
988