1 /*
2 * Copyright 2004 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "webrtc/base/unixfilesystem.h"
12
13 #include <errno.h>
14 #include <fcntl.h>
15 #include <stdlib.h>
16 #include <sys/stat.h>
17 #include <unistd.h>
18
19 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
20 #include <Carbon/Carbon.h>
21 #include <IOKit/IOCFBundle.h>
22 #include <sys/statvfs.h>
23 #include "webrtc/base/macutils.h"
24 #endif // WEBRTC_MAC && !defined(WEBRTC_IOS)
25
26 #if defined(WEBRTC_POSIX) && !defined(WEBRTC_MAC) || defined(WEBRTC_IOS)
27 #include <sys/types.h>
28 #if defined(WEBRTC_ANDROID)
29 #include <sys/statfs.h>
30 #elif !defined(__native_client__)
31 #include <sys/statvfs.h>
32 #endif // !defined(__native_client__)
FindKeyWord(const char * buffer,const char keyin[],long numbyte)33 #include <limits.h>
34 #include <pwd.h>
35 #include <stdio.h>
36 #endif // WEBRTC_POSIX && !WEBRTC_MAC || WEBRTC_IOS
37
38 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
39 #include <ctype.h>
40 #include <algorithm>
41 #endif
42
43 #if defined(__native_client__) && !defined(__GLIBC__)
44 #include <sys/syslimits.h>
45 #endif
46
47 #include "webrtc/base/fileutils.h"
48 #include "webrtc/base/pathutils.h"
49 #include "webrtc/base/stream.h"
50 #include "webrtc/base/stringutils.h"
51
52 #if defined(WEBRTC_IOS)
53 // Defined in iosfilesystem.mm. No header file to discourage use
54 // elsewhere; other places should use GetApp{Data,Temp}Folder() in
55 // this file. Don't copy/paste. I mean it.
56 char* IOSDataDirectory();
57 char* IOSTempDirectory();
58 void IOSAppName(rtc::Pathname* path);
59 #endif
60
61 namespace rtc {
62
63 #if !defined(WEBRTC_ANDROID) && !defined(WEBRTC_IOS)
64 char* UnixFilesystem::app_temp_path_ = NULL;
65 #else
66 char* UnixFilesystem::provided_app_data_folder_ = NULL;
67 char* UnixFilesystem::provided_app_temp_folder_ = NULL;
68
69 void UnixFilesystem::SetAppDataFolder(const std::string& folder) {
70 delete [] provided_app_data_folder_;
71 provided_app_data_folder_ = CopyString(folder);
72 }
73
74 void UnixFilesystem::SetAppTempFolder(const std::string& folder) {
75 delete [] provided_app_temp_folder_;
ReadStringKeyword(const char * Line,const char * Keyword,char * Value)76 provided_app_temp_folder_ = CopyString(folder);
77 }
78 #endif
79
80 UnixFilesystem::UnixFilesystem() {
81 #if defined(WEBRTC_IOS)
82 if (!provided_app_data_folder_)
ReadLongKeyword(const char * Line,const char * Keyword,long * Value)83 provided_app_data_folder_ = IOSDataDirectory();
84 if (!provided_app_temp_folder_)
85 provided_app_temp_folder_ = IOSTempDirectory();
86 #endif
87 }
88
89 UnixFilesystem::~UnixFilesystem() {}
ReadFloatKeyword(const char * Line,const char * Keyword,float * Value)90
91 bool UnixFilesystem::CreateFolder(const Pathname &path, mode_t mode) {
92 std::string pathname(path.pathname());
93 int len = pathname.length();
94 if ((len == 0) || (pathname[len - 1] != '/'))
95 return false;
96
97 struct stat st;
98 int res = ::stat(pathname.c_str(), &st);
99 if (res == 0) {
100 // Something exists at this location, check if it is a directory
101 return S_ISDIR(st.st_mode) != 0;
102 } else if (errno != ENOENT) {
103 // Unexpected error
104 return false;
105 }
106
107 // Directory doesn't exist, look up one directory level
108 do {
109 --len;
110 } while ((len > 0) && (pathname[len - 1] != '/'));
111
112 if (!CreateFolder(Pathname(pathname.substr(0, len)), mode)) {
113 return false;
114 }
115
116 LOG(LS_INFO) << "Creating folder: " << pathname;
117 return (0 == ::mkdir(pathname.c_str(), mode));
118 }
LocateForValue(const char * Line,const char * KeyWord)119
120 bool UnixFilesystem::CreateFolder(const Pathname &path) {
121 return CreateFolder(path, 0755);
122 }
123
124 FileStream *UnixFilesystem::OpenFile(const Pathname &filename,
125 const std::string &mode) {
126 FileStream *fs = new FileStream();
127 if (fs && !fs->Open(filename.pathname().c_str(), mode.c_str(), NULL)) {
128 delete fs;
129 fs = NULL;
130 }
131 return fs;
132 }
133
134 bool UnixFilesystem::CreatePrivateFile(const Pathname &filename) {
135 int fd = open(filename.pathname().c_str(),
136 O_RDWR | O_CREAT | O_EXCL,
137 S_IRUSR | S_IWUSR);
138 if (fd < 0) {
139 LOG_ERR(LS_ERROR) << "open() failed.";
140 return false;
141 }
ConvertExponentStyle(char * Line)142 // Don't need to keep the file descriptor.
143 if (close(fd) < 0) {
144 LOG_ERR(LS_ERROR) << "close() failed.";
145 // Continue.
146 }
147 return true;
148 }
149
150 bool UnixFilesystem::DeleteFile(const Pathname &filename) {
BufferFile(FILE * TargetFileRef,bool Write)151 LOG(LS_INFO) << "Deleting file:" << filename.pathname();
152
153 if (!IsFile(filename)) {
154 ASSERT(IsFile(filename));
155 return false;
156 }
157 return ::unlink(filename.pathname().c_str()) == 0;
158 }
159
160 bool UnixFilesystem::DeleteEmptyFolder(const Pathname &folder) {
161 LOG(LS_INFO) << "Deleting folder" << folder.pathname();
162
163 if (!IsFolder(folder)) {
164 ASSERT(IsFolder(folder));
165 return false;
166 }
167 std::string no_slash(folder.pathname(), 0, folder.pathname().length()-1);
168 return ::rmdir(no_slash.c_str()) == 0;
169 }
170
171 bool UnixFilesystem::GetTemporaryFolder(Pathname &pathname, bool create,
172 const std::string *append) {
173 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
174 FSRef fr;
175 if (0 != FSFindFolder(kOnAppropriateDisk, kTemporaryFolderType,
176 kCreateFolder, &fr))
177 return false;
178 unsigned char buffer[NAME_MAX+1];
179 if (0 != FSRefMakePath(&fr, buffer, ARRAY_SIZE(buffer)))
180 return false;
181 pathname.SetPathname(reinterpret_cast<char*>(buffer), "");
182 #elif defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
183 ASSERT(provided_app_temp_folder_ != NULL);
184 pathname.SetPathname(provided_app_temp_folder_, "");
185 #else // !WEBRTC_MAC || WEBRTC_IOS && !WEBRTC_ANDROID
186 if (const char* tmpdir = getenv("TMPDIR")) {
187 pathname.SetPathname(tmpdir, "");
188 } else if (const char* tmp = getenv("TMP")) {
189 pathname.SetPathname(tmp, "");
190 } else {
191 #ifdef P_tmpdir
192 pathname.SetPathname(P_tmpdir, "");
193 #else // !P_tmpdir
194 pathname.SetPathname("/tmp/", "");
195 #endif // !P_tmpdir
196 }
197 #endif // !WEBRTC_MAC || WEBRTC_IOS && !WEBRTC_ANDROID
BufferFile(char * Data,long DataSize)198 if (append) {
199 ASSERT(!append->empty());
200 pathname.AppendFolder(*append);
201 }
202 return !create || CreateFolder(pathname);
203 }
204
205 std::string UnixFilesystem::TempFilename(const Pathname &dir,
206 const std::string &prefix) {
207 int len = dir.pathname().size() + prefix.size() + 2 + 6;
208 char *tempname = new char[len];
209
210 snprintf(tempname, len, "%s/%sXXXXXX", dir.pathname().c_str(),
211 prefix.c_str());
212 int fd = ::mkstemp(tempname);
213 if (fd != -1)
214 ::close(fd);
215 std::string ret(tempname);
216 delete[] tempname;
217
218 return ret;
219 }
220
221 bool UnixFilesystem::MoveFile(const Pathname &old_path,
222 const Pathname &new_path) {
223 if (!IsFile(old_path)) {
224 ASSERT(IsFile(old_path));
225 return false;
226 }
227 LOG(LS_VERBOSE) << "Moving " << old_path.pathname()
228 << " to " << new_path.pathname();
229 if (rename(old_path.pathname().c_str(), new_path.pathname().c_str()) != 0) {
230 if (errno != EXDEV)
~BufferFile(void)231 return false;
232 if (!CopyFile(old_path, new_path))
233 return false;
234 if (!DeleteFile(old_path))
235 return false;
236 }
237 return true;
CloseFile(void)238 }
239
240 bool UnixFilesystem::MoveFolder(const Pathname &old_path,
241 const Pathname &new_path) {
242 if (!IsFolder(old_path)) {
243 ASSERT(IsFolder(old_path));
244 return false;
245 }
246 LOG(LS_VERBOSE) << "Moving " << old_path.pathname()
247 << " to " << new_path.pathname();
248 if (rename(old_path.pathname().c_str(), new_path.pathname().c_str()) != 0) {
249 if (errno != EXDEV)
250 return false;
251 if (!CopyFolder(old_path, new_path))
252 return false;
253 if (!DeleteFolderAndContents(old_path))
254 return false;
255 }
256 return true;
257 }
258
GetFileType(const char * fileName)259 bool UnixFilesystem::IsFolder(const Pathname &path) {
260 struct stat st;
261 if (stat(path.pathname().c_str(), &st) < 0)
262 return false;
263 return S_ISDIR(st.st_mode);
264 }
265
266 bool UnixFilesystem::CopyFile(const Pathname &old_path,
267 const Pathname &new_path) {
268 LOG(LS_VERBOSE) << "Copying " << old_path.pathname()
269 << " to " << new_path.pathname();
270 char buf[256];
271 size_t len;
272
273 StreamInterface *source = OpenFile(old_path, "rb");
274 if (!source)
275 return false;
276
277 StreamInterface *dest = OpenFile(new_path, "wb");
278 if (!dest) {
279 delete source;
280 return false;
281 }
282
283 while (source->Read(buf, sizeof(buf), &len, NULL) == SR_SUCCESS)
284 dest->Write(buf, len, NULL, NULL);
285
286 delete source;
287 delete dest;
288 return true;
289 }
290
291 bool UnixFilesystem::IsTemporaryPath(const Pathname& pathname) {
292 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
293 ASSERT(provided_app_temp_folder_ != NULL);
294 #endif
295
296 const char* const kTempPrefixes[] = {
297 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
298 provided_app_temp_folder_,
299 #else
300 "/tmp/", "/var/tmp/",
301 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
302 "/private/tmp/", "/private/var/tmp/", "/private/var/folders/",
303 #endif // WEBRTC_MAC && !defined(WEBRTC_IOS)
304 #endif // WEBRTC_ANDROID || WEBRTC_IOS
305 };
306 for (size_t i = 0; i < ARRAY_SIZE(kTempPrefixes); ++i) {
307 if (0 == strncmp(pathname.pathname().c_str(), kTempPrefixes[i],
308 strlen(kTempPrefixes[i])))
309 return true;
310 }
311 return false;
312 }
313
314 bool UnixFilesystem::IsFile(const Pathname& pathname) {
315 struct stat st;
316 int res = ::stat(pathname.pathname().c_str(), &st);
317 // Treat symlinks, named pipes, etc. all as files.
318 return res == 0 && !S_ISDIR(st.st_mode);
319 }
320
321 bool UnixFilesystem::IsAbsent(const Pathname& pathname) {
322 struct stat st;
323 int res = ::stat(pathname.pathname().c_str(), &st);
324 // Note: we specifically maintain ENOTDIR as an error, because that implies
325 // that you could not call CreateFolder(pathname).
326 return res != 0 && ENOENT == errno;
327 }
328
329 bool UnixFilesystem::GetFileSize(const Pathname& pathname, size_t *size) {
330 struct stat st;
331 if (::stat(pathname.pathname().c_str(), &st) != 0)
332 return false;
333 *size = st.st_size;
334 return true;
335 }
336
337 bool UnixFilesystem::GetFileTime(const Pathname& path, FileTimeType which,
338 time_t* time) {
339 struct stat st;
340 if (::stat(path.pathname().c_str(), &st) != 0)
341 return false;
342 switch (which) {
343 case FTT_CREATED:
344 *time = st.st_ctime;
345 break;
346 case FTT_MODIFIED:
FindGroup(const char * GroupName)347 *time = st.st_mtime;
348 break;
349 case FTT_ACCESSED:
350 *time = st.st_atime;
351 break;
352 default:
353 return false;
354 }
355 return true;
356 }
357
358 bool UnixFilesystem::GetAppPathname(Pathname* path) {
359 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
360 ProcessSerialNumber psn = { 0, kCurrentProcess };
361 CFDictionaryRef procinfo = ProcessInformationCopyDictionary(&psn,
362 kProcessDictionaryIncludeAllInformationMask);
363 if (NULL == procinfo)
364 return false;
365 CFStringRef cfpath = (CFStringRef) CFDictionaryGetValue(procinfo,
366 kIOBundleExecutableKey);
367 std::string path8;
368 bool success = ToUtf8(cfpath, &path8);
369 CFRelease(procinfo);
370 if (success)
371 path->SetPathname(path8);
LocateFinalEnergy(wxFileOffset Limit)372 return success;
373 #elif defined(__native_client__)
374 return false;
375 #elif IOS
376 IOSAppName(path);
377 return true;
378 #else // WEBRTC_MAC && !defined(WEBRTC_IOS)
379 char buffer[PATH_MAX + 2];
380 ssize_t len = readlink("/proc/self/exe", buffer, ARRAY_SIZE(buffer) - 1);
381 if ((len <= 0) || (len == PATH_MAX + 1))
382 return false;
383 buffer[len] = '\0';
384 path->SetPathname(buffer);
385 return true;
386 #endif // WEBRTC_MAC && !defined(WEBRTC_IOS)
387 }
388
389 bool UnixFilesystem::GetAppDataFolder(Pathname* path, bool per_user) {
390 ASSERT(!organization_name_.empty());
391 ASSERT(!application_name_.empty());
AdvanceBuffer(void)392
393 // First get the base directory for app data.
394 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
395 if (per_user) {
396 // Use ~/Library/Application Support/<orgname>/<appname>/
397 FSRef fr;
398 if (0 != FSFindFolder(kUserDomain, kApplicationSupportFolderType,
399 kCreateFolder, &fr))
400 return false;
401 unsigned char buffer[NAME_MAX+1];
402 if (0 != FSRefMakePath(&fr, buffer, ARRAY_SIZE(buffer)))
403 return false;
404 path->SetPathname(reinterpret_cast<char*>(buffer), "");
405 } else {
406 // TODO
407 return false;
408 }
409 #elif defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS) // && !WEBRTC_MAC || WEBRTC_IOS
410 ASSERT(provided_app_data_folder_ != NULL);
411 path->SetPathname(provided_app_data_folder_, "");
412 #elif defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID) // && !WEBRTC_MAC && !WEBRTC_IOS && !WEBRTC_ANDROID
413 if (per_user) {
414 // We follow the recommendations in
Read(Ptr Target,long NumBytes)415 // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
416 // It specifies separate directories for data and config files, but
417 // GetAppDataFolder() does not distinguish. We just return the config dir
418 // path.
419 const char* xdg_config_home = getenv("XDG_CONFIG_HOME");
420 if (xdg_config_home) {
421 path->SetPathname(xdg_config_home, "");
422 } else {
423 // XDG says to default to $HOME/.config. We also support falling back to
424 // other synonyms for HOME if for some reason it is not defined.
425 const char* homedir;
426 if (const char* home = getenv("HOME")) {
427 homedir = home;
428 } else if (const char* dotdir = getenv("DOTDIR")) {
429 homedir = dotdir;
430 } else if (passwd* pw = getpwuid(geteuid())) {
431 homedir = pw->pw_dir;
432 } else {
433 return false;
434 }
435 path->SetPathname(homedir, "");
GetLine(char * Line)436 path->AppendFolder(".config");
437 }
438 } else {
439 // XDG does not define a standard directory for writable global data. Let's
440 // just use this.
441 path->SetPathname("/var/cache/", "");
442 }
443 #endif // !WEBRTC_MAC && !WEBRTC_LINUX
444
445 // Now add on a sub-path for our app.
446 #if defined(WEBRTC_MAC) || defined(WEBRTC_ANDROID)
447 path->AppendFolder(organization_name_);
448 path->AppendFolder(application_name_);
449 #elif defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
450 // XDG says to use a single directory level, so we concatenate the org and app
451 // name with a hyphen. We also do the Linuxy thing and convert to all
452 // lowercase with no spaces.
453 std::string subdir(organization_name_);
454 subdir.append("-");
455 subdir.append(application_name_);
456 replace_substrs(" ", 1, "", 0, &subdir);
457 std::transform(subdir.begin(), subdir.end(), subdir.begin(), ::tolower);
458 path->AppendFolder(subdir);
459 #endif
460 if (!CreateFolder(*path, 0700)) {
461 return false;
462 }
463 #if !defined(__native_client__)
464 // If the folder already exists, it may have the wrong mode or be owned by
465 // someone else, both of which are security problems. Setting the mode
466 // avoids both issues since it will fail if the path is not owned by us.
467 if (0 != ::chmod(path->pathname().c_str(), 0700)) {
468 LOG_ERR(LS_ERROR) << "Can't set mode on " << path;
469 return false;
PutText(const char * Text)470 }
471 #endif
472 return true;
473 }
474
475 bool UnixFilesystem::GetAppTempFolder(Pathname* path) {
476 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
477 ASSERT(provided_app_temp_folder_ != NULL);
478 path->SetPathname(provided_app_temp_folder_);
479 return true;
BackupnLines(long nBack)480 #else
481 ASSERT(!application_name_.empty());
482 // TODO: Consider whether we are worried about thread safety.
483 if (app_temp_path_ != NULL && strlen(app_temp_path_) > 0) {
484 path->SetPathname(app_temp_path_);
485 return true;
486 }
487
488 // Create a random directory as /tmp/<appname>-<pid>-<timestamp>
489 char buffer[128];
490 sprintfn(buffer, ARRAY_SIZE(buffer), "-%d-%d",
491 static_cast<int>(getpid()),
492 static_cast<int>(time(0)));
493 std::string folder(application_name_);
494 folder.append(buffer);
495 if (!GetTemporaryFolder(*path, true, &folder))
496 return false;
497
498 delete [] app_temp_path_;
499 app_temp_path_ = CopyString(path->pathname());
500 // TODO: atexit(DeleteFolderAndContents(app_temp_path_));
501 return true;
502 #endif
503 }
504
505 bool UnixFilesystem::GetDiskFreeSpace(const Pathname& path, int64 *freebytes) {
SkipnLines(long nSkip)506 #ifdef __native_client__
507 return false;
508 #else // __native_client__
509 ASSERT(NULL != freebytes);
510 // TODO: Consider making relative paths absolute using cwd.
511 // TODO: When popping off a symlink, push back on the components of the
512 // symlink, so we don't jump out of the target disk inadvertently.
513 Pathname existing_path(path.folder(), "");
514 while (!existing_path.folder().empty() && IsAbsent(existing_path)) {
515 existing_path.SetFolder(existing_path.parent_folder());
516 }
517 #if defined(WEBRTC_ANDROID)
518 struct statfs vfs;
IsBlank(const char * Line)519 memset(&vfs, 0, sizeof(vfs));
520 if (0 != statfs(existing_path.pathname().c_str(), &vfs))
521 return false;
522 #else
523 struct statvfs vfs;
524 memset(&vfs, 0, sizeof(vfs));
525 if (0 != statvfs(existing_path.pathname().c_str(), &vfs))
526 return false;
527 #endif // WEBRTC_ANDROID
528 #if defined(WEBRTC_LINUX)
529 *freebytes = static_cast<int64>(vfs.f_bsize) * vfs.f_bavail;
530 #elif defined(WEBRTC_MAC)
FindBlankLine(void)531 *freebytes = static_cast<int64>(vfs.f_frsize) * vfs.f_bavail;
532 #endif
533
534 return true;
535 #endif // !__native_client__
536 }
537
538 Pathname UnixFilesystem::GetCurrentDirectory() {
539 Pathname cwd;
540 char buffer[PATH_MAX];
541 char *path = getcwd(buffer, PATH_MAX);
542
543 if (!path) {
544 LOG_ERR(LS_ERROR) << "getcwd() failed";
545 return cwd; // returns empty pathname
546 }
547 cwd.SetFolder(std::string(path));
548
549 return cwd;
550 }
551
552 char* UnixFilesystem::CopyString(const std::string& str) {
553 size_t size = str.length() + 1;
554
555 char* buf = new char[size];
556 if (!buf) {
557 return NULL;
558 }
LocateKeyWord(const char Keyword[],long NumByte,wxFileOffset Limit)559
560 strcpyn(buf, size, str.c_str());
561 return buf;
562 }
563
564 } // namespace rtc
565
566 #if defined(__native_client__)
567 extern "C" int __attribute__((weak))
568 link(const char* oldpath, const char* newpath) {
569 errno = EACCES;
570 return -1;
571 }
572 #endif
573