blob: 721ab2f7fc144910981dd985b165333f2d150024 [file] [log] [blame]
Elliott Hughesdec12b22015-02-02 17:31:27 -08001/*
2 * Copyright (C) 2015 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
Elliott Hughes4f713192015-12-04 22:00:26 -080017#include "android-base/file.h"
Elliott Hughesdec12b22015-02-02 17:31:27 -080018
19#include <errno.h>
20#include <fcntl.h>
21#include <sys/stat.h>
22#include <sys/types.h>
Elliott Hughesd3ff6e52016-08-23 15:53:45 -070023#include <unistd.h>
Elliott Hughesdec12b22015-02-02 17:31:27 -080024
Josh Gao7307f092016-09-01 12:31:42 -070025#include <memory>
Dan Albertc007bc32015-03-16 10:08:46 -070026#include <string>
Elliott Hughesd3ff6e52016-08-23 15:53:45 -070027#include <vector>
Elliott Hughesaf4885a2015-02-03 13:02:57 -080028
Elliott Hughes4f713192015-12-04 22:00:26 -080029#include "android-base/macros.h" // For TEMP_FAILURE_RETRY on Darwin.
Elliott Hughese5dd71a2016-07-28 15:15:28 -070030#include "android-base/logging.h"
Elliott Hughes4f713192015-12-04 22:00:26 -080031#include "android-base/utf8.h"
Dan Albert94d13602015-03-26 23:33:28 -070032#include "utils/Compat.h"
Dan Albertc007bc32015-03-16 10:08:46 -070033
Elliott Hughes82ff3152016-08-31 15:07:18 -070034#if defined(__APPLE__)
Josh Gao7307f092016-09-01 12:31:42 -070035#include <mach-o/dyld.h>
Elliott Hughes82ff3152016-08-31 15:07:18 -070036#endif
37#if defined(_WIN32)
38#include <windows.h>
39#endif
40
Dan Albertc007bc32015-03-16 10:08:46 -070041namespace android {
42namespace base {
43
Elliott Hughesc1fd4922015-11-11 18:02:29 +000044// Versions of standard library APIs that support UTF-8 strings.
45using namespace android::base::utf8;
46
Dan Albertc007bc32015-03-16 10:08:46 -070047bool ReadFdToString(int fd, std::string* content) {
Elliott Hughesf682b472015-02-06 12:19:48 -080048 content->clear();
49
50 char buf[BUFSIZ];
51 ssize_t n;
52 while ((n = TEMP_FAILURE_RETRY(read(fd, &buf[0], sizeof(buf)))) > 0) {
53 content->append(buf, n);
54 }
55 return (n == 0) ? true : false;
56}
57
Dan Albertc007bc32015-03-16 10:08:46 -070058bool ReadFileToString(const std::string& path, std::string* content) {
Elliott Hughesdec12b22015-02-02 17:31:27 -080059 content->clear();
60
Elliott Hughes470d79a2015-09-01 13:35:44 -070061 int fd = TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_BINARY));
Elliott Hughesdec12b22015-02-02 17:31:27 -080062 if (fd == -1) {
63 return false;
64 }
Elliott Hughesf682b472015-02-06 12:19:48 -080065 bool result = ReadFdToString(fd, content);
Nick Kralevich95db36e2015-05-20 08:59:21 -070066 close(fd);
Elliott Hughesf682b472015-02-06 12:19:48 -080067 return result;
Elliott Hughesdec12b22015-02-02 17:31:27 -080068}
69
Dan Albertc007bc32015-03-16 10:08:46 -070070bool WriteStringToFd(const std::string& content, int fd) {
Elliott Hughesdec12b22015-02-02 17:31:27 -080071 const char* p = content.data();
72 size_t left = content.size();
73 while (left > 0) {
74 ssize_t n = TEMP_FAILURE_RETRY(write(fd, p, left));
75 if (n == -1) {
Elliott Hughesdec12b22015-02-02 17:31:27 -080076 return false;
77 }
78 p += n;
79 left -= n;
80 }
Elliott Hughesdec12b22015-02-02 17:31:27 -080081 return true;
82}
Elliott Hughes202f0242015-02-04 13:19:13 -080083
84static bool CleanUpAfterFailedWrite(const std::string& path) {
85 // Something went wrong. Let's not leave a corrupt file lying around.
86 int saved_errno = errno;
87 unlink(path.c_str());
88 errno = saved_errno;
89 return false;
90}
91
Elliott Hughes31fa09c2015-02-04 19:38:28 -080092#if !defined(_WIN32)
Dan Albertc007bc32015-03-16 10:08:46 -070093bool WriteStringToFile(const std::string& content, const std::string& path,
94 mode_t mode, uid_t owner, gid_t group) {
Elliott Hughes470d79a2015-09-01 13:35:44 -070095 int flags = O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW | O_BINARY;
96 int fd = TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode));
Elliott Hughes202f0242015-02-04 13:19:13 -080097 if (fd == -1) {
Elliott Hughese5dd71a2016-07-28 15:15:28 -070098 PLOG(ERROR) << "android::WriteStringToFile open failed";
Elliott Hughes202f0242015-02-04 13:19:13 -080099 return false;
100 }
Elliott Hughesf682b472015-02-06 12:19:48 -0800101
Dan Albertc007bc32015-03-16 10:08:46 -0700102 // We do an explicit fchmod here because we assume that the caller really
103 // meant what they said and doesn't want the umask-influenced mode.
Elliott Hughes9d1f5152015-02-17 10:16:04 -0800104 if (fchmod(fd, mode) == -1) {
Elliott Hughese5dd71a2016-07-28 15:15:28 -0700105 PLOG(ERROR) << "android::WriteStringToFile fchmod failed";
Elliott Hughes9d1f5152015-02-17 10:16:04 -0800106 return CleanUpAfterFailedWrite(path);
107 }
108 if (fchown(fd, owner, group) == -1) {
Elliott Hughese5dd71a2016-07-28 15:15:28 -0700109 PLOG(ERROR) << "android::WriteStringToFile fchown failed";
Elliott Hughes9d1f5152015-02-17 10:16:04 -0800110 return CleanUpAfterFailedWrite(path);
111 }
112 if (!WriteStringToFd(content, fd)) {
Elliott Hughese5dd71a2016-07-28 15:15:28 -0700113 PLOG(ERROR) << "android::WriteStringToFile write failed";
Elliott Hughes9d1f5152015-02-17 10:16:04 -0800114 return CleanUpAfterFailedWrite(path);
115 }
Nick Kralevich95db36e2015-05-20 08:59:21 -0700116 close(fd);
Elliott Hughes9d1f5152015-02-17 10:16:04 -0800117 return true;
Elliott Hughes202f0242015-02-04 13:19:13 -0800118}
Elliott Hughes31fa09c2015-02-04 19:38:28 -0800119#endif
Elliott Hughes202f0242015-02-04 13:19:13 -0800120
Dan Albertc007bc32015-03-16 10:08:46 -0700121bool WriteStringToFile(const std::string& content, const std::string& path) {
Elliott Hughes470d79a2015-09-01 13:35:44 -0700122 int flags = O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW | O_BINARY;
123 int fd = TEMP_FAILURE_RETRY(open(path.c_str(), flags, DEFFILEMODE));
Elliott Hughes202f0242015-02-04 13:19:13 -0800124 if (fd == -1) {
125 return false;
126 }
Elliott Hughesf682b472015-02-06 12:19:48 -0800127
128 bool result = WriteStringToFd(content, fd);
Nick Kralevich95db36e2015-05-20 08:59:21 -0700129 close(fd);
Elliott Hughesf682b472015-02-06 12:19:48 -0800130 return result || CleanUpAfterFailedWrite(path);
Elliott Hughes202f0242015-02-04 13:19:13 -0800131}
Dan Albertc007bc32015-03-16 10:08:46 -0700132
Elliott Hughes56085ed2015-04-24 21:57:16 -0700133bool ReadFully(int fd, void* data, size_t byte_count) {
134 uint8_t* p = reinterpret_cast<uint8_t*>(data);
135 size_t remaining = byte_count;
136 while (remaining > 0) {
137 ssize_t n = TEMP_FAILURE_RETRY(read(fd, p, remaining));
138 if (n <= 0) return false;
139 p += n;
140 remaining -= n;
141 }
142 return true;
143}
144
145bool WriteFully(int fd, const void* data, size_t byte_count) {
146 const uint8_t* p = reinterpret_cast<const uint8_t*>(data);
147 size_t remaining = byte_count;
148 while (remaining > 0) {
149 ssize_t n = TEMP_FAILURE_RETRY(write(fd, p, remaining));
150 if (n == -1) return false;
151 p += n;
152 remaining -= n;
153 }
154 return true;
155}
156
Yabin Cuib6e314a2016-01-29 17:25:54 -0800157bool RemoveFileIfExists(const std::string& path, std::string* err) {
158 struct stat st;
159#if defined(_WIN32)
160 //TODO: Windows version can't handle symbol link correctly.
161 int result = stat(path.c_str(), &st);
162 bool file_type_removable = (result == 0 && S_ISREG(st.st_mode));
163#else
164 int result = lstat(path.c_str(), &st);
165 bool file_type_removable = (result == 0 && (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)));
166#endif
167 if (result == 0) {
168 if (!file_type_removable) {
169 if (err != nullptr) {
170 *err = "is not a regular or symbol link file";
171 }
172 return false;
173 }
174 if (unlink(path.c_str()) == -1) {
175 if (err != nullptr) {
176 *err = strerror(errno);
177 }
178 return false;
179 }
180 }
181 return true;
182}
183
Elliott Hughesd3ff6e52016-08-23 15:53:45 -0700184#if !defined(_WIN32)
185bool Readlink(const std::string& path, std::string* result) {
186 result->clear();
187
188 // Most Linux file systems (ext2 and ext4, say) limit symbolic links to
189 // 4095 bytes. Since we'll copy out into the string anyway, it doesn't
190 // waste memory to just start there. We add 1 so that we can recognize
191 // whether it actually fit (rather than being truncated to 4095).
192 std::vector<char> buf(4095 + 1);
193 while (true) {
194 ssize_t size = readlink(path.c_str(), &buf[0], buf.size());
195 // Unrecoverable error?
196 if (size == -1) return false;
197 // It fit! (If size == buf.size(), it may have been truncated.)
198 if (static_cast<size_t>(size) < buf.size()) {
199 result->assign(&buf[0], size);
200 return true;
201 }
202 // Double our buffer and try again.
203 buf.resize(buf.size() * 2);
204 }
205}
206#endif
207
Elliott Hughes82ff3152016-08-31 15:07:18 -0700208std::string GetExecutablePath() {
209#if defined(__linux__)
210 std::string path;
211 android::base::Readlink("/proc/self/exe", &path);
212 return path;
213#elif defined(__APPLE__)
Elliott Hughes82ff3152016-08-31 15:07:18 -0700214 char path[PATH_MAX + 1];
Josh Gao7307f092016-09-01 12:31:42 -0700215 uint32_t path_len = sizeof(path);
216 int rc = _NSGetExecutablePath(path, &path_len);
217 if (rc < 0) {
218 std::unique_ptr<char> path_buf(new char[path_len]);
219 _NSGetExecutablePath(path_buf.get(), &path_len);
220 return path_buf.get();
221 }
Elliott Hughes82ff3152016-08-31 15:07:18 -0700222 return path;
223#elif defined(_WIN32)
224 char path[PATH_MAX + 1];
225 DWORD result = GetModuleFileName(NULL, path, sizeof(path) - 1);
226 if (result == 0 || result == sizeof(path) - 1) return "";
227 path[PATH_MAX - 1] = 0;
228 return path;
229#else
230#error unknown OS
231#endif
232}
233
Dan Albertc007bc32015-03-16 10:08:46 -0700234} // namespace base
235} // namespace android