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
22extern "C" {
23// There is no futimes() avaiable in Bionic, so we provide our own
24// implementation until it is there.
25int 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.
47time_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
94GCC_NO_OPTIMIZE
95void sincos(double angle, double* s, double *c) {
96  *c = cos(angle);
97  *s = sin(angle);
98}
99
100GCC_NO_OPTIMIZE
101void 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.
115char* 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