1 /*
2 ** dir.c - Dir
3 **
4 ** See Copyright Notice in mruby.h
5 */
6
7 #include "mruby.h"
8 #include "mruby/class.h"
9 #include "mruby/data.h"
10 #include "mruby/string.h"
11 #include "error.h"
12 #include <sys/types.h>
13 #if defined(_WIN32) || defined(_WIN64)
14 #define MAXPATHLEN 1024
15 #if !defined(PATH_MAX)
16 #define PATH_MAX MAX_PATH
17 #endif
18 #define S_ISDIR(B) ((B)&_S_IFDIR)
19 #include "Win/dirent.c"
20 #include <direct.h>
21 #define rmdir _rmdir
22 #define getcwd _getcwd
23 #define mkdir _mkdir
24 #define chdir _chdir
25 #else
26 #include <sys/param.h>
27 #include <dirent.h>
28 #include <unistd.h>
29 #endif
30 #include <sys/stat.h>
31 #include <fcntl.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <signal.h>
35 #include <string.h>
36
37 /* with/without IO module */
38 #ifdef ENABLE_IO
39 #include "mruby/ext/io.h"
40 #else
41 #define E_IO_ERROR E_RUNTIME_ERROR
42 #endif
43
44 struct mrb_dir {
45 DIR *dir;
46 };
47
48 void
mrb_dir_free(mrb_state * mrb,void * ptr)49 mrb_dir_free(mrb_state *mrb, void *ptr)
50 {
51 struct mrb_dir *mdir = (struct mrb_dir *)ptr;
52
53 if (mdir->dir) {
54 closedir(mdir->dir);
55 mdir->dir = NULL;
56 }
57 mrb_free(mrb, mdir);
58 }
59
60 static struct mrb_data_type mrb_dir_type = { "DIR", mrb_dir_free };
61
62 mrb_value
mrb_dir_close(mrb_state * mrb,mrb_value self)63 mrb_dir_close(mrb_state *mrb, mrb_value self)
64 {
65 struct mrb_dir *mdir;
66 mdir = (struct mrb_dir *)mrb_get_datatype(mrb, self, &mrb_dir_type);
67 if (!mdir) return mrb_nil_value();
68 if (!mdir->dir) {
69 mrb_raise(mrb, E_IO_ERROR, "closed directory");
70 }
71 if (closedir(mdir->dir) == -1) {
72 mrb_sys_fail(mrb, "closedir");
73 }
74 mdir->dir = NULL;
75 return mrb_nil_value();
76 }
77
78 mrb_value
mrb_dir_init(mrb_state * mrb,mrb_value self)79 mrb_dir_init(mrb_state *mrb, mrb_value self)
80 {
81 DIR *dir;
82 struct mrb_dir *mdir;
83 mrb_value path;
84 char *cpath;
85
86 mdir = (struct mrb_dir *)DATA_PTR(self);
87 if (mdir) {
88 mrb_dir_free(mrb, mdir);
89 }
90 DATA_TYPE(self) = &mrb_dir_type;
91 DATA_PTR(self) = NULL;
92
93 mdir = (struct mrb_dir *)mrb_malloc(mrb, sizeof(*mdir));
94 mdir->dir = NULL;
95 DATA_PTR(self) = mdir;
96
97 mrb_get_args(mrb, "S", &path);
98 cpath = mrb_str_to_cstr(mrb, path);
99 if ((dir = opendir(cpath)) == NULL) {
100 mrb_sys_fail(mrb, cpath);
101 }
102 mdir->dir = dir;
103 return self;
104 }
105
106 mrb_value
mrb_dir_delete(mrb_state * mrb,mrb_value klass)107 mrb_dir_delete(mrb_state *mrb, mrb_value klass)
108 {
109 mrb_value path;
110 char *cpath;
111
112 mrb_get_args(mrb, "S", &path);
113 cpath = mrb_str_to_cstr(mrb, path);
114 if (rmdir(cpath) == -1) {
115 mrb_sys_fail(mrb, cpath);
116 }
117 return mrb_fixnum_value(0);
118 }
119
120 mrb_value
mrb_dir_existp(mrb_state * mrb,mrb_value klass)121 mrb_dir_existp(mrb_state *mrb, mrb_value klass)
122 {
123 mrb_value path;
124 struct stat sb;
125 char *cpath;
126
127 mrb_get_args(mrb, "S", &path);
128 cpath = mrb_str_to_cstr(mrb, path);
129 if (stat(cpath, &sb) == 0 && S_ISDIR(sb.st_mode)) {
130 return mrb_true_value();
131 } else {
132 return mrb_false_value();
133 }
134 }
135
136 mrb_value
mrb_dir_getwd(mrb_state * mrb,mrb_value klass)137 mrb_dir_getwd(mrb_state *mrb, mrb_value klass)
138 {
139 mrb_value path;
140
141 path = mrb_str_buf_new(mrb, MAXPATHLEN);
142 if (getcwd(RSTRING_PTR(path), MAXPATHLEN) == NULL) {
143 mrb_sys_fail(mrb, "getcwd(2)");
144 }
145 mrb_str_resize(mrb, path, strlen(RSTRING_PTR(path)));
146 return path;
147 }
148
149 mrb_value
mrb_dir_mkdir(mrb_state * mrb,mrb_value klass)150 mrb_dir_mkdir(mrb_state *mrb, mrb_value klass)
151 {
152 mrb_int mode;
153 mrb_value spath;
154 char *path;
155
156 mode = 0777;
157 mrb_get_args(mrb, "S|i", &spath, &mode);
158 path = mrb_str_to_cstr(mrb, spath);
159 #ifndef _WIN32
160 if (mkdir(path, mode) == -1) {
161 #else
162 if (mkdir(path) == -1) {
163 #endif
164 mrb_sys_fail(mrb, path);
165 }
166 return mrb_fixnum_value(0);
167 }
168
169 mrb_value
170 mrb_dir_chdir(mrb_state *mrb, mrb_value klass)
171 {
172 mrb_value spath;
173 char *path;
174
175 mrb_get_args(mrb, "S", &spath);
176 path = mrb_str_to_cstr(mrb, spath);
177 if (chdir(path) == -1) {
178 mrb_sys_fail(mrb, path);
179 }
180 return mrb_fixnum_value(0);
181 }
182
183 mrb_value
184 mrb_dir_chroot(mrb_state *mrb, mrb_value self)
185 {
186 #if defined(_WIN32) || defined(_WIN64) || defined(__android__)
187 mrb_raise(mrb, E_NOTIMP_ERROR, "chroot() unreliable on Win platforms");
188 return mrb_fixnum_value(0);
189 #else
190 mrb_value spath;
191 char *path;
192 int res;
193
194 mrb_get_args(mrb, "S", &spath);
195 path = mrb_str_to_cstr(mrb, spath);
196 res = chroot(path);
197 if (res == -1) {
198 mrb_sys_fail(mrb, path);
199 }
200
201 return mrb_fixnum_value(res);
202 #endif
203 }
204
205 mrb_value
206 mrb_dir_read(mrb_state *mrb, mrb_value self)
207 {
208 struct mrb_dir *mdir;
209 struct dirent *dp;
210
211 mdir = (struct mrb_dir *)mrb_get_datatype(mrb, self, &mrb_dir_type);
212 if (!mdir) return mrb_nil_value();
213 if (!mdir->dir) {
214 mrb_raise(mrb, E_IO_ERROR, "closed directory");
215 }
216 dp = readdir(mdir->dir);
217 if (dp != NULL) {
218 return mrb_str_new_cstr(mrb, dp->d_name);
219 } else {
220 return mrb_nil_value();
221 }
222 }
223
224 mrb_value
225 mrb_dir_rewind(mrb_state *mrb, mrb_value self)
226 {
227 struct mrb_dir *mdir;
228
229 mdir = (struct mrb_dir *)mrb_get_datatype(mrb, self, &mrb_dir_type);
230 if (!mdir) return mrb_nil_value();
231 if (!mdir->dir) {
232 mrb_raise(mrb, E_IO_ERROR, "closed directory");
233 }
234 rewinddir(mdir->dir);
235 return self;
236 }
237
238 mrb_value
239 mrb_dir_seek(mrb_state *mrb, mrb_value self)
240 {
241 #if defined(_WIN32) || defined(_WIN64) || defined(__android__)
242 mrb_raise(mrb, E_NOTIMP_ERROR, "dirseek() unreliable on Win platforms");
243 return self;
244 #else
245 struct mrb_dir *mdir;
246 mrb_int pos;
247
248 mdir = (struct mrb_dir *)mrb_get_datatype(mrb, self, &mrb_dir_type);
249 if (!mdir) return mrb_nil_value();
250 if (!mdir->dir) {
251 mrb_raise(mrb, E_IO_ERROR, "closed directory");
252 }
253 mrb_get_args(mrb, "i", &pos);
254 seekdir(mdir->dir, (long)pos);
255 return self;
256 #endif
257 }
258
259 mrb_value
260 mrb_dir_tell(mrb_state *mrb, mrb_value self)
261 {
262 #if defined(_WIN32) || defined(_WIN64) || defined(__android__)
263 mrb_raise(mrb, E_NOTIMP_ERROR, "dirtell() unreliable on Win platforms");
264 return mrb_fixnum_value(0);
265 #else
266 struct mrb_dir *mdir;
267 mrb_int pos;
268
269 mdir = (struct mrb_dir *)mrb_get_datatype(mrb, self, &mrb_dir_type);
270 if (!mdir) return mrb_nil_value();
271 if (!mdir->dir) {
272 mrb_raise(mrb, E_IO_ERROR, "closed directory");
273 }
274 pos = (mrb_int)telldir(mdir->dir);
275 return mrb_fixnum_value(pos);
276 #endif
277 }
278
279 void
280 mrb_mruby_dir_gem_init(mrb_state *mrb)
281 {
282 struct RClass *d;
283
284 d = mrb_define_class(mrb, "Dir", mrb->object_class);
285 MRB_SET_INSTANCE_TT(d, MRB_TT_DATA);
286 mrb_define_class_method(mrb, d, "delete", mrb_dir_delete, MRB_ARGS_REQ(1));
287 mrb_define_class_method(mrb, d, "exist?", mrb_dir_existp, MRB_ARGS_REQ(1));
288 mrb_define_class_method(mrb, d, "getwd", mrb_dir_getwd, MRB_ARGS_NONE());
289 mrb_define_class_method(mrb, d, "mkdir", mrb_dir_mkdir, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
290 mrb_define_class_method(mrb, d, "_chdir", mrb_dir_chdir, MRB_ARGS_REQ(1));
291 mrb_define_class_method(mrb, d, "chroot", mrb_dir_chroot, MRB_ARGS_REQ(1));
292
293 mrb_define_method(mrb, d, "close", mrb_dir_close, MRB_ARGS_NONE());
294 mrb_define_method(mrb, d, "initialize", mrb_dir_init, MRB_ARGS_REQ(1));
295 mrb_define_method(mrb, d, "read", mrb_dir_read, MRB_ARGS_NONE());
296 mrb_define_method(mrb, d, "rewind", mrb_dir_rewind, MRB_ARGS_NONE());
297 mrb_define_method(mrb, d, "seek", mrb_dir_seek, MRB_ARGS_REQ(1));
298 mrb_define_method(mrb, d, "tell", mrb_dir_tell, MRB_ARGS_NONE());
299 }
300
301 void
302 mrb_mruby_dir_gem_final(mrb_state *mrb)
303 {
304 }
305