libcros 0.5.1

A Rust library that provides easy-to-use functions for interacting with a Chrome device
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

// Copyright 2024 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "vpd/util/file.h"

#include <dirent.h>
#include <stddef.h>
#include <stdint.h>
#include <unistd.h>

#include <fstream>
#include <optional>
#include <sstream>
#include <string>
#include <vector>

#include "absl/log/check.h"
#include "absl/log/log.h"

namespace vpd {
namespace util {

std::optional<std::vector<uint8_t>> ReadFileToBytes(
    const std::string& filename) {
  std::ifstream file_stream(filename, std::ios::in | std::ios::binary);

  if (!file_stream.is_open()) {
    return {};
  }

  file_stream.seekg(0, std::ios::end);
  size_t file_size = file_stream.tellg();
  file_stream.seekg(0, std::ios::beg);

  std::vector<uint8_t> blob(file_size);
  file_stream.read(reinterpret_cast<char*>(blob.data()), file_size);

  file_stream.close();

  return blob;
}

std::optional<std::string> ReadFileToString(const std::string& filename) {
  std::ifstream file(filename, std::ios::in);

  if (!file.is_open()) {
    return {};
  }

  std::stringstream buffer;
  buffer << file.rdbuf();
  file.close();

  return buffer.str();
}

bool WriteFile(const std::string& filename, const std::string& data) {
  std::ofstream file(filename, std::ios::out);

  if (!file.is_open()) {
    return false;
  }

  file << data;
  file.close();

  return file.good();
}

std::vector<std::string> ListFiles(const std::string& dir) {
  DIR* d = opendir(dir.c_str());
  if (d == nullptr) {
    LOG(ERROR) << "Error opening directory: " << dir;
    return {};
  }

  std::vector<std::string> files;
  struct dirent* entry = nullptr;
  while ((entry = readdir(d)) != nullptr) {
    // Check if the entry is a regular file (and not a directory, symlink, etc.)
    if (entry->d_type == DT_REG) {
      files.push_back(entry->d_name);
    }
  }

  closedir(d);
  return files;
}

bool PathExists(const std::string& path) {
  return access(path.c_str(), F_OK) == 0;
}

std::string JoinPath(const std::string& dir, const std::string& basename) {
  if (basename.empty()) {
    return (!dir.empty() && dir.back() == '/') ? dir.substr(0, dir.size() - 1)
                                               : dir;
  }

  auto d = (dir.empty() || dir.back() == '/') ? dir : (dir + '/');
  auto b = basename[0] == '/' ? basename.substr(1) : basename;
  return d + b;
}

}  // namespace util
}  // namespace vpd