1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/os_compat_android.h"
6
7 #include <asm/unistd.h>
8 #include <errno.h>
9 #include <limits.h>
10 #include <math.h>
11 #include <sys/stat.h>
12 #include <sys/syscall.h>
13
14 #if !defined(__LP64__)
15 #include <time64.h>
16 #endif
17
18 #include "base/rand_util.h"
19 #include "base/strings/string_piece.h"
20 #include "base/strings/stringprintf.h"
21
22 extern "C" {
23 // There is no futimes() avaiable in Bionic, so we provide our own
24 // implementation until it is there.
futimes(int fd,const struct timeval tv[2])25 int futimes(int fd, const struct timeval tv[2]) {
26 if (tv == NULL)
27 return syscall(__NR_utimensat, fd, NULL, NULL, 0);
28
29 if (tv[0].tv_usec < 0 || tv[0].tv_usec >= 1000000 ||
30 tv[1].tv_usec < 0 || tv[1].tv_usec >= 1000000) {
31 errno = EINVAL;
32 return -1;
33 }
34
35 // Convert timeval to timespec.
36 struct timespec ts[2];
37 ts[0].tv_sec = tv[0].tv_sec;
38 ts[0].tv_nsec = tv[0].tv_usec * 1000;
39 ts[1].tv_sec = tv[1].tv_sec;
40 ts[1].tv_nsec = tv[1].tv_usec * 1000;
41 return syscall(__NR_utimensat, fd, NULL, ts, 0);
42 }
43
44 #if !defined(__LP64__)
45 // 32-bit Android has only timegm64() and not timegm().
46 // We replicate the behaviour of timegm() when the result overflows time_t.
timegm(struct tm * const t)47 time_t timegm(struct tm* const t) {
48 // time_t is signed on Android.
49 static const time_t kTimeMax = ~(1L << (sizeof(time_t) * CHAR_BIT - 1));
50 static const time_t kTimeMin = (1L << (sizeof(time_t) * CHAR_BIT - 1));
51 time64_t result = timegm64(t);
52 if (result < kTimeMin || result > kTimeMax)
53 return -1;
54 return result;
55 }
56 #endif
57
58 // The following is only needed when building with GCC 4.6 or higher
59 // (i.e. not with Android GCC 4.4.3, nor with Clang).
60 //
61 // GCC is now capable of optimizing successive calls to sin() and cos() into
62 // a single call to sincos(). This means that source code that looks like:
63 //
64 // double c, s;
65 // c = cos(angle);
66 // s = sin(angle);
67 //
68 // Will generate machine code that looks like:
69 //
70 // double c, s;
71 // sincos(angle, &s, &c);
72 //
73 // Unfortunately, sincos() and friends are not part of the Android libm.so
74 // library provided by the NDK for API level 9. When the optimization kicks
75 // in, it makes the final build fail with a puzzling message (puzzling
76 // because 'sincos' doesn't appear anywhere in the sources!).
77 //
78 // To solve this, we provide our own implementation of the sincos() function
79 // and related friends. Note that we must also explicitely tell GCC to disable
80 // optimizations when generating these. Otherwise, the generated machine code
81 // for each function would simply end up calling itself, resulting in a
82 // runtime crash due to stack overflow.
83 //
84 #if defined(__GNUC__) && !defined(__clang__) && \
85 !defined(ANDROID_SINCOS_PROVIDED)
86
87 // For the record, Clang does not support the 'optimize' attribute.
88 // In the unlikely event that it begins performing this optimization too,
89 // we'll have to find a different way to achieve this. NOTE: Tested with O1
90 // which still performs the optimization.
91 //
92 #define GCC_NO_OPTIMIZE __attribute__((optimize("O0")))
93
94 GCC_NO_OPTIMIZE
sincos(double angle,double * s,double * c)95 void sincos(double angle, double* s, double *c) {
96 *c = cos(angle);
97 *s = sin(angle);
98 }
99
100 GCC_NO_OPTIMIZE
sincosf(float angle,float * s,float * c)101 void sincosf(float angle, float* s, float* c) {
102 *c = cosf(angle);
103 *s = sinf(angle);
104 }
105
106 #endif // __GNUC__ && !__clang__
107
108 // An implementation of mkdtemp, since it is not exposed by the NDK
109 // for native API level 9 that we target.
110 //
111 // For any changes in the mkdtemp function, you should manually run the unittest
112 // OsCompatAndroidTest.DISABLED_TestMkdTemp in your local machine to check if it
113 // passes. Please don't enable it, since it creates a directory and may be
114 // source of flakyness.
mkdtemp(char * path)115 char* mkdtemp(char* path) {
116 if (path == NULL) {
117 errno = EINVAL;
118 return NULL;
119 }
120
121 const int path_len = strlen(path);
122
123 // The last six characters of 'path' must be XXXXXX.
124 const base::StringPiece kSuffix("XXXXXX");
125 const int kSuffixLen = kSuffix.length();
126 if (!base::StringPiece(path, path_len).ends_with(kSuffix)) {
127 errno = EINVAL;
128 return NULL;
129 }
130
131 // If the path contains a directory, as in /tmp/foo/XXXXXXXX, make sure
132 // that /tmp/foo exists, otherwise we're going to loop a really long
133 // time for nothing below
134 char* dirsep = strrchr(path, '/');
135 if (dirsep != NULL) {
136 struct stat st;
137 int ret;
138
139 *dirsep = '\0'; // Terminating directory path temporarily
140
141 ret = stat(path, &st);
142
143 *dirsep = '/'; // Restoring directory separator
144 if (ret < 0) // Directory probably does not exist
145 return NULL;
146 if (!S_ISDIR(st.st_mode)) { // Not a directory
147 errno = ENOTDIR;
148 return NULL;
149 }
150 }
151
152 // Max number of tries using different random suffixes.
153 const int kMaxTries = 100;
154
155 // Now loop until we CAN create a directory by that name or we reach the max
156 // number of tries.
157 for (int i = 0; i < kMaxTries; ++i) {
158 // Fill the suffix XXXXXX with a random string composed of a-z chars.
159 for (int pos = 0; pos < kSuffixLen; ++pos) {
160 char rand_char = static_cast<char>(base::RandInt('a', 'z'));
161 path[path_len - kSuffixLen + pos] = rand_char;
162 }
163 if (mkdir(path, 0700) == 0) {
164 // We just created the directory succesfully.
165 return path;
166 }
167 if (errno != EEXIST) {
168 // The directory doesn't exist, but an error occured
169 return NULL;
170 }
171 }
172
173 // We reached the max number of tries.
174 return NULL;
175 }
176
177 } // extern "C"
178