/home/uke/oil/cpp/stdlib.cc
Line | Count | Source (jump to first uncovered line) |
1 | | // stdlib.cc: Replacement for standard library modules |
2 | | // and native/posixmodule.c |
3 | | |
4 | | #include "stdlib.h" |
5 | | |
6 | | #include <dirent.h> // closedir(), opendir(), readdir() |
7 | | #include <errno.h> |
8 | | #include <fcntl.h> // open |
9 | | #include <signal.h> // kill |
10 | | #include <sys/stat.h> // umask |
11 | | #include <sys/types.h> // umask |
12 | | #include <sys/wait.h> // WUNTRACED |
13 | | #include <time.h> |
14 | | #include <unistd.h> |
15 | | |
16 | | #include "mycpp/runtime.h" |
17 | | // To avoid circular dependency with e_die() |
18 | | #include "prebuilt/core/error.mycpp.h" |
19 | | |
20 | | using error::e_die; |
21 | | |
22 | | namespace fcntl_ { |
23 | | |
24 | 0 | int fcntl(int fd, int cmd) { |
25 | 0 | int result = ::fcntl(fd, cmd); |
26 | 0 | if (result < 0) { |
27 | 0 | throw Alloc<IOError>(errno); |
28 | 0 | } |
29 | 0 | return result; |
30 | 0 | } |
31 | | |
32 | 0 | int fcntl(int fd, int cmd, int arg) { |
33 | 0 | int result = ::fcntl(fd, cmd, arg); |
34 | 0 | if (result < 0) { |
35 | 0 | throw Alloc<IOError>(errno); |
36 | 0 | } |
37 | 0 | return result; |
38 | 0 | } |
39 | | |
40 | | } // namespace fcntl_ |
41 | | |
42 | | namespace posix { |
43 | | |
44 | 0 | mode_t umask(mode_t mask) { |
45 | | // No error case: always succeeds |
46 | 0 | return ::umask(mask); |
47 | 0 | } |
48 | | |
49 | 2 | int open(BigStr* path, int flags, int perms) { |
50 | 2 | int result = ::open(path->data_, flags, perms); |
51 | 2 | if (result < 0) { |
52 | 1 | throw Alloc<OSError>(errno); |
53 | 1 | } |
54 | 1 | return result; |
55 | 2 | } |
56 | | |
57 | 0 | void dup2(int oldfd, int newfd) { |
58 | 0 | if (::dup2(oldfd, newfd) < 0) { |
59 | 0 | throw Alloc<OSError>(errno); |
60 | 0 | } |
61 | 0 | } |
62 | 1 | void putenv(BigStr* name, BigStr* value) { |
63 | 1 | int overwrite = 1; |
64 | 1 | int ret = ::setenv(name->data_, value->data_, overwrite); |
65 | 1 | if (ret < 0) { |
66 | 0 | throw Alloc<IOError>(errno); |
67 | 0 | } |
68 | 1 | } |
69 | | |
70 | 0 | mylib::File* fdopen(int fd, BigStr* c_mode) { |
71 | | // CPython checks if it's a directory first |
72 | 0 | struct stat buf; |
73 | 0 | if (fstat(fd, &buf) == 0 && S_ISDIR(buf.st_mode)) { |
74 | 0 | throw Alloc<OSError>(EISDIR); |
75 | 0 | } |
76 | | |
77 | | // CPython does some fcntl() stuff with mode == 'a', which we don't support |
78 | 0 | DCHECK(c_mode->data_[0] != 'a'); |
79 | | |
80 | 0 | FILE* f = ::fdopen(fd, c_mode->data_); |
81 | 0 | if (f == nullptr) { |
82 | 0 | throw Alloc<OSError>(errno); |
83 | 0 | } |
84 | | |
85 | 0 | return Alloc<mylib::CFile>(f); |
86 | 0 | } |
87 | | |
88 | | void execve(BigStr* argv0, List<BigStr*>* argv, |
89 | 0 | Dict<BigStr*, BigStr*>* environ) { |
90 | 0 | int n_args = len(argv); |
91 | 0 | int n_env = len(environ); |
92 | 0 | int combined_size = 0; |
93 | 0 | for (DictIter<BigStr*, BigStr*> it(environ); !it.Done(); it.Next()) { |
94 | 0 | BigStr* k = it.Key(); |
95 | 0 | BigStr* v = it.Value(); |
96 | |
|
97 | 0 | int joined_len = len(k) + len(v) + 2; // = and NUL terminator |
98 | 0 | combined_size += joined_len; |
99 | 0 | } |
100 | 0 | const int argv_size = (n_args + 1) * sizeof(char*); |
101 | 0 | const int env_size = (n_env + 1) * sizeof(char*); |
102 | 0 | combined_size += argv_size; |
103 | 0 | combined_size += env_size; |
104 | 0 | char* combined_buf = static_cast<char*>(malloc(combined_size)); |
105 | | |
106 | | // never deallocated |
107 | 0 | char** _argv = reinterpret_cast<char**>(combined_buf); |
108 | 0 | combined_buf += argv_size; |
109 | | |
110 | | // Annoying const_cast |
111 | | // https://stackoverflow.com/questions/190184/execv-and-const-ness |
112 | 0 | for (int i = 0; i < n_args; ++i) { |
113 | 0 | _argv[i] = const_cast<char*>(argv->at(i)->data_); |
114 | 0 | } |
115 | 0 | _argv[n_args] = nullptr; |
116 | | |
117 | | // Convert environ into an array of pointers to strings of the form: "k=v". |
118 | 0 | char** envp = reinterpret_cast<char**>(combined_buf); |
119 | 0 | combined_buf += env_size; |
120 | 0 | int env_index = 0; |
121 | 0 | for (DictIter<BigStr*, BigStr*> it(environ); !it.Done(); it.Next()) { |
122 | 0 | BigStr* k = it.Key(); |
123 | 0 | BigStr* v = it.Value(); |
124 | |
|
125 | 0 | char* buf = combined_buf; |
126 | 0 | int joined_len = len(k) + len(v) + 1; |
127 | 0 | combined_buf += joined_len + 1; |
128 | 0 | memcpy(buf, k->data_, len(k)); |
129 | 0 | buf[len(k)] = '='; |
130 | 0 | memcpy(buf + len(k) + 1, v->data_, len(v)); |
131 | 0 | buf[joined_len] = '\0'; |
132 | |
|
133 | 0 | envp[env_index++] = buf; |
134 | 0 | } |
135 | 0 | envp[n_env] = nullptr; |
136 | |
|
137 | 0 | int ret = ::execve(argv0->data_, _argv, envp); |
138 | 0 | if (ret == -1) { |
139 | 0 | throw Alloc<OSError>(errno); |
140 | 0 | } |
141 | | |
142 | | // ::execve() never returns on success |
143 | 0 | FAIL(kShouldNotGetHere); |
144 | 0 | } |
145 | | |
146 | 0 | void kill(int pid, int sig) { |
147 | 0 | if (::kill(pid, sig) != 0) { |
148 | 0 | throw Alloc<OSError>(errno); |
149 | 0 | } |
150 | 0 | } |
151 | | |
152 | 0 | void killpg(int pgid, int sig) { |
153 | 0 | if (::killpg(pgid, sig) != 0) { |
154 | 0 | throw Alloc<OSError>(errno); |
155 | 0 | } |
156 | 0 | } |
157 | | |
158 | 2 | List<BigStr*>* listdir(BigStr* path) { |
159 | 2 | DIR* dirp = opendir(path->data()); |
160 | 2 | if (dirp == NULL) { |
161 | 1 | throw Alloc<OSError>(errno); |
162 | 1 | } |
163 | | |
164 | 1 | auto* ret = Alloc<List<BigStr*>>(); |
165 | 24 | while (true) { |
166 | 24 | errno = 0; |
167 | 24 | struct dirent* ep = readdir(dirp); |
168 | 24 | if (ep == NULL) { |
169 | 1 | if (errno != 0) { |
170 | 0 | closedir(dirp); |
171 | 0 | throw Alloc<OSError>(errno); |
172 | 0 | } |
173 | 1 | break; // no more files |
174 | 1 | } |
175 | | // Skip . and .. |
176 | 23 | int name_len = strlen(ep->d_name); |
177 | 23 | if (ep->d_name[0] == '.' && |
178 | 23 | (name_len == 1 || (ep->d_name[1] == '.' && name_len == 2))) { |
179 | 2 | continue; |
180 | 2 | } |
181 | 21 | ret->append(StrFromC(ep->d_name, name_len)); |
182 | 21 | } |
183 | | |
184 | 1 | closedir(dirp); |
185 | | |
186 | 1 | return ret; |
187 | 1 | } |
188 | | |
189 | | } // namespace posix |
190 | | |
191 | | namespace time_ { |
192 | | |
193 | 1 | void tzset() { |
194 | | // No error case: no return value |
195 | 1 | ::tzset(); |
196 | 1 | } |
197 | | |
198 | 1 | time_t time() { |
199 | 1 | time_t result = ::time(nullptr); |
200 | 1 | if (result < 0) { |
201 | 0 | throw Alloc<IOError>(errno); |
202 | 0 | } |
203 | 1 | return result; |
204 | 1 | } |
205 | | |
206 | | // NOTE(Jesse): time_t is specified to be an arithmetic type by C++. On most |
207 | | // systems it's a 64-bit integer. 64 bits is used because 32 will overflow in |
208 | | // 2038. Someone on a committee somewhere thought of that when moving to |
209 | | // 64-bit architectures to prevent breaking ABI again; on 32-bit systems it's |
210 | | // usually 32 bits. Point being, using anything but the time_t typedef here |
211 | | // could (unlikely, but possible) produce weird behavior. |
212 | 0 | time_t localtime(time_t ts) { |
213 | | // localtime returns a pointer to a static buffer |
214 | 0 | tm* loc_time = ::localtime(&ts); |
215 | |
|
216 | 0 | time_t result = mktime(loc_time); |
217 | 0 | if (result < 0) { |
218 | 0 | throw Alloc<IOError>(errno); |
219 | 0 | } |
220 | 0 | return result; |
221 | 0 | } |
222 | | |
223 | 3 | BigStr* strftime(BigStr* s, time_t ts) { |
224 | 3 | tm* loc_time = ::localtime(&ts); |
225 | | |
226 | 3 | const int max_len = 1024; |
227 | 3 | BigStr* result = OverAllocatedStr(max_len); |
228 | 3 | int n = strftime(result->data(), max_len, s->data_, loc_time); |
229 | 3 | if (n == 0) { |
230 | | // bash silently truncates on large format string like |
231 | | // printf '%(%Y)T' |
232 | | // Oil doesn't mask errors |
233 | | // Leaving out location info points to 'printf' builtin |
234 | |
|
235 | 0 | e_die(StrFromC("strftime() result exceeds 1024 bytes")); |
236 | 0 | } |
237 | 3 | result->MaybeShrink(n); |
238 | 3 | return result; |
239 | 3 | } |
240 | | |
241 | 1 | void sleep(int seconds) { |
242 | 1 | ::sleep(seconds); |
243 | 1 | } |
244 | | |
245 | | } // namespace time_ |