[kirkwood] Fix mv_cesa module dependencies and .ko file location
[openwrt.git] / package / lua / patches / 400-luaposix_5.1.4-embedded.patch
1 --- a/src/Makefile
2 +++ b/src/Makefile
3 @@ -12,7 +12,7 @@ CFLAGS= -O2 -Wall $(MYCFLAGS)
4 AR= ar rcu
5 RANLIB= ranlib
6 RM= rm -f
7 -LIBS= -lm $(MYLIBS)
8 +LIBS= -lm -lcrypt $(MYLIBS)
9
10 MYCFLAGS=
11 MYLDFLAGS=
12 @@ -29,7 +29,7 @@ CORE_O= lapi.o lcode.o ldebug.o ldo.o ld
13 lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o \
14 lundump.o lvm.o lzio.o lnum.o
15 LIB_O= lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \
16 - lstrlib.o loadlib.o linit.o
17 + lstrlib.o loadlib.o linit.o lposix.o
18
19 LUA_T= lua
20 LUA_O= lua.o
21 --- a/src/linit.c
22 +++ b/src/linit.c
23 @@ -23,6 +23,7 @@ static const luaL_Reg lualibs[] = {
24 {LUA_STRLIBNAME, luaopen_string},
25 {LUA_MATHLIBNAME, luaopen_math},
26 {LUA_DBLIBNAME, luaopen_debug},
27 + {LUA_POSIXLIBNAME, luaopen_posix},
28 {NULL, NULL}
29 };
30
31 --- /dev/null
32 +++ b/src/lposix.c
33 @@ -0,0 +1,1139 @@
34 +/*
35 +* lposix.c
36 +* POSIX library for Lua 5.1.
37 +* Luiz Henrique de Figueiredo <lhf@tecgraf.puc-rio.br>
38 +* 07 Apr 2006 23:17:49
39 +* Clean up and bug fixes by Leo Razoumov <slonik.az@gmail.com> 2006-10-11 <!LR>
40 +* Based on original by Claudio Terra for Lua 3.x.
41 +* With contributions by Roberto Ierusalimschy.
42 +*/
43 +
44 +#include <sys/stat.h>
45 +#include <sys/times.h>
46 +#include <sys/types.h>
47 +#include <sys/utsname.h>
48 +#include <sys/wait.h>
49 +
50 +#include <dirent.h>
51 +#include <errno.h>
52 +#include <fcntl.h>
53 +#include <glob.h>
54 +#include <grp.h>
55 +#include <libgen.h>
56 +#include <limits.h>
57 +#include <poll.h>
58 +#include <pwd.h>
59 +#include <signal.h>
60 +#include <stdio.h>
61 +#include <stdlib.h>
62 +#include <string.h>
63 +#include <syslog.h>
64 +#include <time.h>
65 +#include <unistd.h>
66 +#include <utime.h>
67 +
68 +#define MYNAME "posix"
69 +#define MYVERSION MYNAME " library for " LUA_VERSION " / Jan 2008"
70 +
71 +#ifndef ENABLE_SYSLOG
72 +#define ENABLE_SYSLOG 1
73 +#endif
74 +
75 +#include "lua.h"
76 +#include "lualib.h"
77 +#include "lauxlib.h"
78 +
79 +#include "modemuncher.c"
80 +
81 +/* compatibility with Lua 5.0 */
82 +#ifndef LUA_VERSION_NUM
83 +static int luaL_checkoption (lua_State *L, int narg, const char *def,
84 + const char *const lst[]) {
85 + const char *name = (def) ? luaL_optstring(L, narg, def) :
86 + luaL_checkstring(L, narg);
87 + int i = luaL_findstring(name, lst);
88 + if (i == -1)
89 + luaL_argerror(L, narg, lua_pushfstring(L, "invalid option '%s'", name));
90 + return i;
91 +}
92 +#define lua_pushinteger lua_pushnumber
93 +#define lua_createtable(L,a,r) lua_newtable(L)
94 +#define LUA_FILEHANDLE "FILE*"
95 +
96 +#define lua_setfield(l,i,k)
97 +#define lua_getfield(l,i,k)
98 +
99 +#endif
100 +
101 +static const struct { char c; mode_t b; } M[] =
102 +{
103 + {'r', S_IRUSR}, {'w', S_IWUSR}, {'x', S_IXUSR},
104 + {'r', S_IRGRP}, {'w', S_IWGRP}, {'x', S_IXGRP},
105 + {'r', S_IROTH}, {'w', S_IWOTH}, {'x', S_IXOTH},
106 +};
107 +
108 +
109 +static void pushmode(lua_State *L, mode_t mode)
110 +{
111 + char m[9];
112 + int i;
113 + for (i=0; i<9; i++) m[i]= (mode & M[i].b) ? M[i].c : '-';
114 + if (mode & S_ISUID) m[2]= (mode & S_IXUSR) ? 's' : 'S';
115 + if (mode & S_ISGID) m[5]= (mode & S_IXGRP) ? 's' : 'S';
116 + lua_pushlstring(L, m, 9);
117 +}
118 +
119 +typedef void (*Selector)(lua_State *L, int i, const void *data);
120 +
121 +static int doselection(lua_State *L, int i, int n,
122 + const char *const S[],
123 + Selector F,
124 + const void *data)
125 +{
126 + if (lua_isnone(L, i) || lua_istable(L, i))
127 + {
128 + int j;
129 + if (lua_isnone(L, i)) lua_createtable(L,0,n); else lua_settop(L, i);
130 + for (j=0; S[j]!=NULL; j++)
131 + {
132 + lua_pushstring(L, S[j]);
133 + F(L, j, data);
134 + lua_settable(L, -3);
135 + }
136 + return 1;
137 + }
138 + else
139 + {
140 + int k,n=lua_gettop(L);
141 + for (k=i; k<=n; k++)
142 + {
143 + int j=luaL_checkoption(L, k, NULL, S);
144 + F(L, j, data);
145 + lua_replace(L, k);
146 + }
147 + return n-i+1;
148 + }
149 +}
150 +#define doselection(L,i,S,F,d) (doselection)(L,i,sizeof(S)/sizeof(*S)-1,S,F,d)
151 +
152 +static int pusherror(lua_State *L, const char *info)
153 +{
154 + lua_pushnil(L);
155 + if (info==NULL)
156 + lua_pushstring(L, strerror(errno));
157 + else
158 + lua_pushfstring(L, "%s: %s", info, strerror(errno));
159 + lua_pushinteger(L, errno);
160 + return 3;
161 +}
162 +
163 +static int pushresult(lua_State *L, int i, const char *info)
164 +{
165 + if (i==-1) return pusherror(L, info);
166 + lua_pushinteger(L, i);
167 + return 1;
168 +}
169 +
170 +static void badoption(lua_State *L, int i, const char *what, int option)
171 +{
172 + luaL_argerror(L, 2,
173 + lua_pushfstring(L, "unknown %s option '%c'", what, option));
174 +}
175 +
176 +static uid_t mygetuid(lua_State *L, int i)
177 +{
178 + if (lua_isnone(L, i))
179 + return -1;
180 + else if (lua_isnumber(L, i))
181 + return (uid_t) lua_tonumber(L, i);
182 + else if (lua_isstring(L, i))
183 + {
184 + struct passwd *p=getpwnam(lua_tostring(L, i));
185 + return (p==NULL) ? -1 : p->pw_uid;
186 + }
187 + else
188 + return luaL_typerror(L, i, "string or number");
189 +}
190 +
191 +static gid_t mygetgid(lua_State *L, int i)
192 +{
193 + if (lua_isnone(L, i))
194 + return -1;
195 + else if (lua_isnumber(L, i))
196 + return (gid_t) lua_tonumber(L, i);
197 + else if (lua_isstring(L, i))
198 + {
199 + struct group *g=getgrnam(lua_tostring(L, i));
200 + return (g==NULL) ? -1 : g->gr_gid;
201 + }
202 + else
203 + return luaL_typerror(L, i, "string or number");
204 +}
205 +
206 +
207 +static int Perrno(lua_State *L) /** errno([n]) */
208 +{
209 + int n = luaL_optint(L, 1, errno);
210 + lua_pushstring(L, strerror(n));
211 + lua_pushinteger(L, n);
212 + return 2;
213 +}
214 +
215 +
216 +static int Pbasename(lua_State *L) /** basename(path) */
217 +{
218 + char b[PATH_MAX];
219 + size_t len;
220 + const char *path = luaL_checklstring(L, 1, &len);
221 + if (len>=sizeof(b)) luaL_argerror(L, 1, "too long");
222 + lua_pushstring(L, basename(strcpy(b,path)));
223 + return 1;
224 +}
225 +
226 +
227 +static int Pdirname(lua_State *L) /** dirname(path) */
228 +{
229 + char b[PATH_MAX];
230 + size_t len;
231 + const char *path = luaL_checklstring(L, 1, &len);
232 + if (len>=sizeof(b)) luaL_argerror(L, 1, "too long");
233 + lua_pushstring(L, dirname(strcpy(b,path)));
234 + return 1;
235 +}
236 +
237 +
238 +static int Pdir(lua_State *L) /** dir([path]) */
239 +{
240 + const char *path = luaL_optstring(L, 1, ".");
241 + DIR *d = opendir(path);
242 + if (d == NULL)
243 + return pusherror(L, path);
244 + else
245 + {
246 + int i;
247 + struct dirent *entry;
248 + lua_newtable(L);
249 + for (i=1; (entry = readdir(d)) != NULL; i++)
250 + {
251 + lua_pushstring(L, entry->d_name);
252 + lua_rawseti(L, -2, i);
253 + }
254 + closedir(d);
255 + lua_pushinteger(L, i-1);
256 + return 2;
257 + }
258 +}
259 +
260 +static int Pglob(lua_State *L) /** glob(pattern) */
261 +{
262 + const char *pattern = luaL_optstring(L, 1, "*");
263 + glob_t globres;
264 +
265 + if (glob(pattern, 0, NULL, &globres))
266 + return pusherror(L, pattern);
267 + else
268 + {
269 + int i;
270 + lua_newtable(L);
271 + for (i=1; i<=globres.gl_pathc; i++) {
272 + lua_pushstring(L, globres.gl_pathv[i-1]);
273 + lua_rawseti(L, -2, i);
274 + }
275 + globfree(&globres);
276 + return 1;
277 + }
278 +}
279 +
280 +static int aux_files(lua_State *L)
281 +{
282 + DIR **p = (DIR **)lua_touserdata(L, lua_upvalueindex(1));
283 + DIR *d = *p;
284 + struct dirent *entry;
285 + if (d == NULL) return 0;
286 + entry = readdir(d);
287 + if (entry == NULL)
288 + {
289 + closedir(d);
290 + *p=NULL;
291 + return 0;
292 + }
293 + else
294 + {
295 + lua_pushstring(L, entry->d_name);
296 + return 1;
297 + }
298 +}
299 +
300 +static int dir_gc (lua_State *L)
301 +{
302 + DIR *d = *(DIR **)lua_touserdata(L, 1);
303 + if (d!=NULL) closedir(d);
304 + return 0;
305 +}
306 +
307 +static int Pfiles(lua_State *L) /** files([path]) */
308 +{
309 + const char *path = luaL_optstring(L, 1, ".");
310 + DIR **d = (DIR **)lua_newuserdata(L, sizeof(DIR *));
311 + if (luaL_newmetatable(L, MYNAME " dir handle"))
312 + {
313 + lua_pushliteral(L, "__gc");
314 + lua_pushcfunction(L, dir_gc);
315 + lua_settable(L, -3);
316 + }
317 + lua_setmetatable(L, -2);
318 + *d = opendir(path);
319 + if (*d == NULL) return pusherror(L, path);
320 + lua_pushcclosure(L, aux_files, 1);
321 + return 1;
322 +}
323 +
324 +
325 +static int Pgetcwd(lua_State *L) /** getcwd() */
326 +{
327 + char b[PATH_MAX];
328 + if (getcwd(b, sizeof(b)) == NULL) return pusherror(L, ".");
329 + lua_pushstring(L, b);
330 + return 1;
331 +}
332 +
333 +
334 +static int Pmkdir(lua_State *L) /** mkdir(path) */
335 +{
336 + const char *path = luaL_checkstring(L, 1);
337 + return pushresult(L, mkdir(path, 0777), path);
338 +}
339 +
340 +
341 +static int Pchdir(lua_State *L) /** chdir(path) */
342 +{
343 + const char *path = luaL_checkstring(L, 1);
344 + return pushresult(L, chdir(path), path);
345 +}
346 +
347 +static int Prmdir(lua_State *L) /** rmdir(path) */
348 +{
349 + const char *path = luaL_checkstring(L, 1);
350 + return pushresult(L, rmdir(path), path);
351 +}
352 +
353 +
354 +static int Punlink(lua_State *L) /** unlink(path) */
355 +{
356 + const char *path = luaL_checkstring(L, 1);
357 + return pushresult(L, unlink(path), path);
358 +}
359 +
360 +static int Plink(lua_State *L) /** link(old,new,[symbolic]) */
361 +{
362 + const char *oldpath = luaL_checkstring(L, 1);
363 + const char *newpath = luaL_checkstring(L, 2);
364 + return pushresult(L,
365 + (lua_toboolean(L,3) ? symlink : link)(oldpath, newpath), NULL);
366 +}
367 +
368 +
369 +static int Preadlink(lua_State *L) /** readlink(path) */
370 +{
371 + char b[PATH_MAX];
372 + const char *path = luaL_checkstring(L, 1);
373 + int n = readlink(path, b, sizeof(b));
374 + if (n==-1) return pusherror(L, path);
375 + lua_pushlstring(L, b, n);
376 + return 1;
377 +}
378 +
379 +
380 +static int Paccess(lua_State *L) /** access(path,[mode]) */
381 +{
382 + int mode=F_OK;
383 + const char *path=luaL_checkstring(L, 1);
384 + const char *s;
385 + for (s=luaL_optstring(L, 2, "f"); *s!=0 ; s++)
386 + switch (*s)
387 + {
388 + case ' ': break;
389 + case 'r': mode |= R_OK; break;
390 + case 'w': mode |= W_OK; break;
391 + case 'x': mode |= X_OK; break;
392 + case 'f': mode |= F_OK; break;
393 + default: badoption(L, 2, "mode", *s); break;
394 + }
395 + return pushresult(L, access(path, mode), path);
396 +}
397 +
398 +
399 +static int myfclose (lua_State *L) {
400 + FILE **p = (FILE **)lua_touserdata(L, 1);
401 + int rc = fclose(*p);
402 + if (rc == 0) *p = NULL;
403 + return pushresult(L, rc, NULL);
404 +}
405 +
406 +static int pushfile (lua_State *L, int id, const char *mode) {
407 + FILE **f = (FILE **)lua_newuserdata(L, sizeof(FILE *));
408 + *f = NULL;
409 + luaL_getmetatable(L, LUA_FILEHANDLE);
410 + lua_setmetatable(L, -2);
411 + lua_getfield(L, LUA_REGISTRYINDEX, "POSIX_PIPEFILE");
412 + if (lua_isnil(L, -1)) {
413 + lua_pop(L, 1);
414 + lua_newtable(L);
415 + lua_pushvalue(L, -1);
416 + lua_pushcfunction(L, myfclose);
417 + lua_setfield(L, -2, "__close");
418 + lua_setfield(L, LUA_REGISTRYINDEX, "POSIX_PIPEFILE");
419 + }
420 + lua_setfenv(L, -2);
421 + *f = fdopen(id, mode);
422 + return (*f != NULL);
423 +}
424 +
425 +static int Ppipe(lua_State *L) /** pipe() */
426 +{
427 + int fd[2];
428 + if (pipe(fd)==-1) return pusherror(L, NULL);
429 + if (!pushfile(L, fd[0], "r") || !pushfile(L, fd[1], "w"))
430 + return pusherror(L, "pipe");
431 + return 2;
432 +}
433 +
434 +
435 +static int Pfileno(lua_State *L) /** fileno(filehandle) */
436 +{
437 + FILE *f = *(FILE**) luaL_checkudata(L, 1, LUA_FILEHANDLE);
438 + return pushresult(L, fileno(f), NULL);
439 +}
440 +
441 +
442 +static int Pfdopen(lua_State *L) /** fdopen(fd, mode) */
443 +{
444 + int fd = luaL_checkint(L, 1);
445 + const char *mode = luaL_checkstring(L, 2);
446 + if (!pushfile(L, fd, mode))
447 + return pusherror(L, "fdpoen");
448 + return 1;
449 +}
450 +
451 +
452 +/* helper func for Pdup */
453 +static const char *filemode(int fd)
454 +{
455 + const char *m;
456 + int mode = fcntl(fd, F_GETFL);
457 + if (mode < 0)
458 + return NULL;
459 + switch (mode & O_ACCMODE) {
460 + case O_RDONLY: m = "r"; break;
461 + case O_WRONLY: m = "w"; break;
462 + default: m = "rw"; break;
463 + }
464 + return m;
465 +}
466 +
467 +static int Pdup(lua_State *L) /** dup(old,[new]) */
468 +{
469 + FILE **oldf = (FILE**)luaL_checkudata(L, 1, LUA_FILEHANDLE);
470 + FILE **newf = (FILE **)lua_touserdata(L, 2);
471 + int fd;
472 + const char *msg = "dup2";
473 + fflush(*newf);
474 + if (newf == NULL) {
475 + fd = dup(fileno(*oldf));
476 + msg = "dup";
477 + } else {
478 + fflush(*newf);
479 + fd = dup2(fileno(*oldf), fileno(*newf));
480 + }
481 +
482 + if ((fd < 0) || !pushfile(L, fd, filemode(fd)))
483 + return pusherror(L, msg);
484 + return 1;
485 +}
486 +
487 +
488 +static int Pmkfifo(lua_State *L) /** mkfifo(path) */
489 +{
490 + const char *path = luaL_checkstring(L, 1);
491 + return pushresult(L, mkfifo(path, 0777), path);
492 +}
493 +
494 +
495 +static int runexec(lua_State *L, int use_shell)
496 +{
497 + const char *path = luaL_checkstring(L, 1);
498 + int i,n=lua_gettop(L);
499 + char **argv = lua_newuserdata(L,(n+1)*sizeof(char*));
500 + argv[0] = (char*)path;
501 + for (i=1; i<n; i++) argv[i] = (char*)luaL_checkstring(L, i+1);
502 + argv[n] = NULL;
503 + if (use_shell) {
504 + execvp(path, argv);
505 + } else {
506 + execv(path, argv);
507 + }
508 + return pusherror(L, path);
509 +}
510 +
511 +
512 +static int Pexec(lua_State *L) /** exec(path,[args]) */
513 +{
514 + return runexec(L, 0);
515 +}
516 +
517 +
518 +static int Pexecp(lua_State *L) /** execp(path,[args]) */
519 +{
520 + return runexec(L, 1);
521 +}
522 +
523 +
524 +static int Pfork(lua_State *L) /** fork() */
525 +{
526 + return pushresult(L, fork(), NULL);
527 +}
528 +
529 +/* from http://lua-users.org/lists/lua-l/2007-11/msg00346.html */
530 +static int Ppoll(lua_State *L) /** poll(filehandle, timeout) */
531 +{
532 + struct pollfd fds;
533 + FILE* file = *(FILE**)luaL_checkudata(L,1,LUA_FILEHANDLE);
534 + int timeout = luaL_checkint(L,2);
535 + fds.fd = fileno(file);
536 + fds.events = POLLIN;
537 + return pushresult(L, poll(&fds,1,timeout), NULL);
538 +}
539 +
540 +static int Pwait(lua_State *L) /** wait([pid]) */
541 +{
542 + int status;
543 + pid_t pid = luaL_optint(L, 1, -1);
544 + pid = waitpid(pid, &status, 0);
545 + if (pid == -1) return pusherror(L, NULL);
546 + lua_pushinteger(L, pid);
547 + if (WIFEXITED(status))
548 + {
549 + lua_pushliteral(L,"exited");
550 + lua_pushinteger(L, WEXITSTATUS(status));
551 + return 3;
552 + }
553 + else if (WIFSIGNALED(status))
554 + {
555 + lua_pushliteral(L,"killed");
556 + lua_pushinteger(L, WTERMSIG(status));
557 + return 3;
558 + }
559 + else if (WIFSTOPPED(status))
560 + {
561 + lua_pushliteral(L,"stopped");
562 + lua_pushinteger(L, WSTOPSIG(status));
563 + return 3;
564 + }
565 + return 1;
566 +}
567 +
568 +
569 +static int Pkill(lua_State *L) /** kill(pid,[sig]) */
570 +{
571 + pid_t pid = luaL_checkint(L, 1);
572 + int sig = luaL_optint(L, 2, SIGTERM);
573 + return pushresult(L, kill(pid, sig), NULL);
574 +}
575 +
576 +static int Psetpid(lua_State *L) /** setpid(option,...) */
577 +{
578 + const char *what=luaL_checkstring(L, 1);
579 + switch (*what)
580 + {
581 + case 'U':
582 + return pushresult(L, seteuid(mygetuid(L, 2)), NULL);
583 + case 'u':
584 + return pushresult(L, setuid(mygetuid(L, 2)), NULL);
585 + case 'G':
586 + return pushresult(L, setegid(mygetgid(L, 2)), NULL);
587 + case 'g':
588 + return pushresult(L, setgid(mygetgid(L, 2)), NULL);
589 + case 's':
590 + return pushresult(L, setsid(), NULL);
591 + case 'p':
592 + {
593 + pid_t pid = luaL_checkint(L, 2);
594 + pid_t pgid = luaL_checkint(L, 3);
595 + return pushresult(L, setpgid(pid,pgid), NULL);
596 + }
597 + default:
598 + badoption(L, 2, "id", *what);
599 + return 0;
600 + }
601 +}
602 +
603 +
604 +static int Psleep(lua_State *L) /** sleep(seconds) */
605 +{
606 + unsigned int seconds = luaL_checkint(L, 1);
607 + lua_pushinteger(L, sleep(seconds));
608 + return 1;
609 +}
610 +
611 +
612 +static int Psetenv(lua_State *L) /** setenv(name,value,[over]) */
613 +{
614 + const char *name=luaL_checkstring(L, 1);
615 + const char *value=luaL_optstring(L, 2, NULL);
616 + if (value==NULL)
617 + {
618 + unsetenv(name);
619 + return pushresult(L, 0, NULL);
620 + }
621 + else
622 + {
623 + int overwrite=lua_isnoneornil(L, 3) || lua_toboolean(L, 3);
624 + return pushresult(L, setenv(name,value,overwrite), NULL);
625 + }
626 +}
627 +
628 +
629 +static int Pgetenv(lua_State *L) /** getenv([name]) */
630 +{
631 + if (lua_isnone(L, 1))
632 + {
633 + extern char **environ;
634 + char **e;
635 + lua_newtable(L);
636 + for (e=environ; *e!=NULL; e++)
637 + {
638 + char *s=*e;
639 + char *eq=strchr(s, '=');
640 + if (eq==NULL) /* will this ever happen? */
641 + {
642 + lua_pushstring(L,s);
643 + lua_pushboolean(L,1);
644 + }
645 + else
646 + {
647 + lua_pushlstring(L,s,eq-s);
648 + lua_pushstring(L,eq+1);
649 + }
650 + lua_settable(L,-3);
651 + }
652 + }
653 + else
654 + lua_pushstring(L, getenv(luaL_checkstring(L, 1)));
655 + return 1;
656 +}
657 +
658 +static int Pumask(lua_State *L) /** umask([mode]) */
659 +{/* <!LR> from old lposix-5.0 version */
660 + char m[10];
661 + mode_t mode;
662 + umask(mode=umask(0));
663 + mode=(~mode)&0777;
664 + if (!lua_isnone(L, 1))
665 + {
666 + if (mode_munch(&mode, luaL_checkstring(L, 1)))
667 + {
668 + lua_pushnil(L);
669 + return 1;
670 + }
671 + mode&=0777;
672 + umask(~mode);
673 + }
674 + modechopper(mode, m);
675 + lua_pushstring(L, m);
676 + return 1;
677 +}
678 +
679 +
680 +static int Pchmod(lua_State *L) /** chmod(path,mode) */
681 +{
682 + mode_t mode;
683 + struct stat s;
684 + const char *path = luaL_checkstring(L, 1);
685 + const char *modestr = luaL_checkstring(L, 2);
686 + if (stat(path, &s)) return pusherror(L, path);
687 + mode = s.st_mode;
688 + if (mode_munch(&mode, modestr)) luaL_argerror(L, 2, "bad mode");
689 + return pushresult(L, chmod(path, mode), path);
690 +}
691 +
692 +
693 +static int Pchown(lua_State *L) /** chown(path,uid,gid) */
694 +{
695 + const char *path = luaL_checkstring(L, 1);
696 + uid_t uid = mygetuid(L, 2);
697 + gid_t gid = mygetgid(L, 3);
698 + return pushresult(L, chown(path, uid, gid), path);
699 +}
700 +
701 +
702 +static int Putime(lua_State *L) /** utime(path,[mtime,atime]) */
703 +{
704 + struct utimbuf times;
705 + time_t currtime = time(NULL);
706 + const char *path = luaL_checkstring(L, 1);
707 + times.modtime = luaL_optnumber(L, 2, currtime);
708 + times.actime = luaL_optnumber(L, 3, currtime);
709 + return pushresult(L, utime(path, &times), path);
710 +}
711 +
712 +
713 +static void FgetID(lua_State *L, int i, const void *data)
714 +{
715 + switch (i)
716 + {
717 + case 0: lua_pushinteger(L, getegid()); break;
718 + case 1: lua_pushinteger(L, geteuid()); break;
719 + case 2: lua_pushinteger(L, getgid()); break;
720 + case 3: lua_pushinteger(L, getuid()); break;
721 + case 4: lua_pushinteger(L, getpgrp()); break;
722 + case 5: lua_pushinteger(L, getpid()); break;
723 + case 6: lua_pushinteger(L, getppid()); break;
724 + }
725 +}
726 +
727 +static const char *const SgetID[] =
728 +{
729 + "egid", "euid", "gid", "uid", "pgrp", "pid", "ppid", NULL
730 +};
731 +
732 +static int Pgetpid(lua_State *L) /** getpid([options]) */
733 +{
734 + return doselection(L, 1, SgetID, FgetID, NULL);
735 +}
736 +
737 +
738 +static int Phostid(lua_State *L) /** hostid() */
739 +{
740 + char b[32];
741 + sprintf(b,"%ld",gethostid());
742 + lua_pushstring(L, b);
743 + return 1;
744 +}
745 +
746 +
747 +static int Pttyname(lua_State *L) /** ttyname([fd]) */
748 +{
749 + int fd=luaL_optint(L, 1, 0);
750 + lua_pushstring(L, ttyname(fd));
751 + return 1;
752 +}
753 +
754 +
755 +static int Pctermid(lua_State *L) /** ctermid() */
756 +{
757 + char b[L_ctermid];
758 + lua_pushstring(L, ctermid(b));
759 + return 1;
760 +}
761 +
762 +
763 +static int Pgetlogin(lua_State *L) /** getlogin() */
764 +{
765 + lua_pushstring(L, getlogin());
766 + return 1;
767 +}
768 +
769 +
770 +static void Fgetpasswd(lua_State *L, int i, const void *data)
771 +{
772 + const struct passwd *p=data;
773 + switch (i)
774 + {
775 + case 0: lua_pushstring(L, p->pw_name); break;
776 + case 1: lua_pushinteger(L, p->pw_uid); break;
777 + case 2: lua_pushinteger(L, p->pw_gid); break;
778 + case 3: lua_pushstring(L, p->pw_dir); break;
779 + case 4: lua_pushstring(L, p->pw_shell); break;
780 +/* not strictly POSIX */
781 + case 5: lua_pushstring(L, p->pw_gecos); break;
782 + case 6: lua_pushstring(L, p->pw_passwd); break;
783 + }
784 +}
785 +
786 +static const char *const Sgetpasswd[] =
787 +{
788 + "name", "uid", "gid", "dir", "shell", "gecos", "passwd", NULL
789 +};
790 +
791 +
792 +static int Pgetpasswd(lua_State *L) /** getpasswd(name|id,[sel]) */
793 +{
794 + struct passwd *p=NULL;
795 + if (lua_isnoneornil(L, 1))
796 + p = getpwuid(geteuid());
797 + else if (lua_isnumber(L, 1))
798 + p = getpwuid((uid_t)lua_tonumber(L, 1));
799 + else if (lua_isstring(L, 1))
800 + p = getpwnam(lua_tostring(L, 1));
801 + else
802 + luaL_typerror(L, 1, "string or number");
803 + if (p==NULL)
804 + lua_pushnil(L);
805 + else
806 + return doselection(L, 2, Sgetpasswd, Fgetpasswd, p);
807 + return 1;
808 +}
809 +
810 +
811 +static int Pgetgroup(lua_State *L) /** getgroup(name|id) */
812 +{
813 + struct group *g=NULL;
814 + if (lua_isnumber(L, 1))
815 + g = getgrgid((gid_t)lua_tonumber(L, 1));
816 + else if (lua_isstring(L, 1))
817 + g = getgrnam(lua_tostring(L, 1));
818 + else
819 + luaL_typerror(L, 1, "string or number");
820 + if (g==NULL)
821 + lua_pushnil(L);
822 + else
823 + {
824 + int i;
825 + lua_newtable(L);
826 + lua_pushliteral(L, "name");
827 + lua_pushstring(L, g->gr_name);
828 + lua_settable(L, -3);
829 + lua_pushliteral(L, "gid");
830 + lua_pushinteger(L, g->gr_gid);
831 + lua_settable(L, -3);
832 + for (i=0; g->gr_mem[i]!=NULL; i++)
833 + {
834 + lua_pushstring(L, g->gr_mem[i]);
835 + lua_rawseti(L, -2, i);
836 + }
837 + }
838 + return 1;
839 +}
840 +
841 +
842 +struct mytimes
843 +{
844 + struct tms t;
845 + clock_t elapsed;
846 +};
847 +
848 +/* #define pushtime(L,x) lua_pushnumber(L,((lua_Number)x)/CLOCKS_PER_SEC) */
849 +#define pushtime(L,x) lua_pushnumber(L, ((lua_Number)x)/clk_tck)
850 +
851 +static void Ftimes(lua_State *L, int i, const void *data)
852 +{
853 + static long clk_tck = 0;
854 + const struct mytimes *t=data;
855 +
856 + if( !clk_tck){ clk_tck= sysconf(_SC_CLK_TCK);}
857 + switch (i)
858 + {
859 + case 0: pushtime(L, t->t.tms_utime); break;
860 + case 1: pushtime(L, t->t.tms_stime); break;
861 + case 2: pushtime(L, t->t.tms_cutime); break;
862 + case 3: pushtime(L, t->t.tms_cstime); break;
863 + case 4: pushtime(L, t->elapsed); break;
864 + }
865 +}
866 +
867 +static const char *const Stimes[] =
868 +{
869 + "utime", "stime", "cutime", "cstime", "elapsed", NULL
870 +};
871 +
872 +static int Ptimes(lua_State *L) /** times([options]) */
873 +{
874 + struct mytimes t;
875 + t.elapsed = times(&t.t);
876 + return doselection(L, 1, Stimes, Ftimes, &t);
877 +}
878 +
879 +
880 +static const char *filetype(mode_t m)
881 +{
882 + if (S_ISREG(m)) return "regular";
883 + else if (S_ISLNK(m)) return "link";
884 + else if (S_ISDIR(m)) return "directory";
885 + else if (S_ISCHR(m)) return "character device";
886 + else if (S_ISBLK(m)) return "block device";
887 + else if (S_ISFIFO(m)) return "fifo";
888 + else if (S_ISSOCK(m)) return "socket";
889 + else return "?";
890 +}
891 +
892 +static void Fstat(lua_State *L, int i, const void *data)
893 +{
894 + const struct stat *s=data;
895 + switch (i)
896 + {
897 + case 0: pushmode(L, s->st_mode); break;
898 + case 1: lua_pushinteger(L, s->st_ino); break;
899 + case 2: lua_pushinteger(L, s->st_dev); break;
900 + case 3: lua_pushinteger(L, s->st_nlink); break;
901 + case 4: lua_pushinteger(L, s->st_uid); break;
902 + case 5: lua_pushinteger(L, s->st_gid); break;
903 + case 6: lua_pushinteger(L, s->st_size); break;
904 + case 7: lua_pushinteger(L, s->st_atime); break;
905 + case 8: lua_pushinteger(L, s->st_mtime); break;
906 + case 9: lua_pushinteger(L, s->st_ctime); break;
907 + case 10:lua_pushstring(L, filetype(s->st_mode)); break;
908 + }
909 +}
910 +
911 +static const char *const Sstat[] =
912 +{
913 + "mode", "ino", "dev", "nlink", "uid", "gid",
914 + "size", "atime", "mtime", "ctime", "type",
915 + NULL
916 +};
917 +
918 +static int Pstat(lua_State *L) /** stat(path,[options]) */
919 +{
920 + struct stat s;
921 + const char *path=luaL_checkstring(L, 1);
922 + if (lstat(path,&s)==-1) return pusherror(L, path);
923 + return doselection(L, 2, Sstat, Fstat, &s);
924 +}
925 +
926 +
927 +static int Puname(lua_State *L) /** uname([string]) */
928 +{
929 + struct utsname u;
930 + luaL_Buffer b;
931 + const char *s;
932 + if (uname(&u)==-1) return pusherror(L, NULL);
933 + luaL_buffinit(L, &b);
934 + for (s=luaL_optstring(L, 1, "%s %n %r %v %m"); *s; s++)
935 + if (*s!='%')
936 + luaL_putchar(&b, *s);
937 + else switch (*++s)
938 + {
939 + case '%': luaL_putchar(&b, *s); break;
940 + case 'm': luaL_addstring(&b,u.machine); break;
941 + case 'n': luaL_addstring(&b,u.nodename); break;
942 + case 'r': luaL_addstring(&b,u.release); break;
943 + case 's': luaL_addstring(&b,u.sysname); break;
944 + case 'v': luaL_addstring(&b,u.version); break;
945 + default: badoption(L, 2, "format", *s); break;
946 + }
947 + luaL_pushresult(&b);
948 + return 1;
949 +}
950 +
951 +
952 +static const int Kpathconf[] =
953 +{
954 + _PC_LINK_MAX, _PC_MAX_CANON, _PC_MAX_INPUT, _PC_NAME_MAX, _PC_PATH_MAX,
955 + _PC_PIPE_BUF, _PC_CHOWN_RESTRICTED, _PC_NO_TRUNC, _PC_VDISABLE,
956 + -1
957 +};
958 +
959 +static void Fpathconf(lua_State *L, int i, const void *data)
960 +{
961 + const char *path=data;
962 + lua_pushinteger(L, pathconf(path, Kpathconf[i]));
963 +}
964 +
965 +static const char *const Spathconf[] =
966 +{
967 + "link_max", "max_canon", "max_input", "name_max", "path_max",
968 + "pipe_buf", "chown_restricted", "no_trunc", "vdisable",
969 + NULL
970 +};
971 +
972 +static int Ppathconf(lua_State *L) /** pathconf([path,options]) */
973 +{
974 + const char *path = luaL_optstring(L, 1, ".");
975 + return doselection(L, 2, Spathconf, Fpathconf, path);
976 +}
977 +
978 +
979 +static const int Ksysconf[] =
980 +{
981 + _SC_ARG_MAX, _SC_CHILD_MAX, _SC_CLK_TCK, _SC_NGROUPS_MAX, _SC_STREAM_MAX,
982 + _SC_TZNAME_MAX, _SC_OPEN_MAX, _SC_JOB_CONTROL, _SC_SAVED_IDS, _SC_VERSION,
983 + -1
984 +};
985 +
986 +static void Fsysconf(lua_State *L, int i, const void *data)
987 +{
988 + lua_pushinteger(L, sysconf(Ksysconf[i]));
989 +}
990 +
991 +static const char *const Ssysconf[] =
992 +{
993 + "arg_max", "child_max", "clk_tck", "ngroups_max", "stream_max",
994 + "tzname_max", "open_max", "job_control", "saved_ids", "version",
995 + NULL
996 +};
997 +
998 +static int Psysconf(lua_State *L) /** sysconf([options]) */
999 +{
1000 + return doselection(L, 1, Ssysconf, Fsysconf, NULL);
1001 +}
1002 +
1003 +#if ENABLE_SYSLOG
1004 +/* syslog funcs */
1005 +static int Popenlog(lua_State *L) /** openlog(ident, [option], [facility]) */
1006 +{
1007 + const char *ident = luaL_checkstring(L, 1);
1008 + int option = 0;
1009 + int facility = luaL_optint(L, 3, LOG_USER);
1010 + const char *s = luaL_optstring(L, 2, "");
1011 + while (*s) {
1012 + switch (*s) {
1013 + case ' ': break;
1014 + case 'c': option |= LOG_CONS; break;
1015 + case 'n': option |= LOG_NDELAY; break;
1016 + case 'e': option |= LOG_PERROR; break;
1017 + case 'p': option |= LOG_PID; break;
1018 + default: badoption(L, 2, "option", *s); break;
1019 + }
1020 + s++;
1021 + }
1022 + openlog(ident, option, facility);
1023 + return 0;
1024 +}
1025 +
1026 +
1027 +static int Psyslog(lua_State *L) /** syslog(priority, message) */
1028 +{
1029 + int priority = luaL_checkint(L, 1);
1030 + const char *msg = luaL_checkstring(L, 2);
1031 + syslog(priority, "%s", msg);
1032 + return 0;
1033 +}
1034 +
1035 +
1036 +static int Pcloselog(lua_State *L) /** closelog() */
1037 +{
1038 + closelog();
1039 + return 0;
1040 +}
1041 +#endif
1042 +
1043 +/*
1044 + * XXX: GNU and BSD handle the forward declaration of crypt() in different
1045 + * and annoying ways (especially GNU). Declare it here just to make sure
1046 + * that it's there
1047 + */
1048 +char *crypt(const char *, const char *);
1049 +
1050 +static int Pcrypt(lua_State *L)
1051 +{
1052 + const char *str, *salt;
1053 + char *res;
1054 +
1055 + str = luaL_checkstring(L, 1);
1056 + salt = luaL_checkstring(L, 2);
1057 + if (strlen(salt) < 2)
1058 + luaL_error(L, "not enough salt");
1059 +
1060 + res = crypt(str, salt);
1061 + lua_pushstring(L, res);
1062 +
1063 + return 1;
1064 +}
1065 +
1066 +static const luaL_reg R[] =
1067 +{
1068 + {"access", Paccess},
1069 + {"basename", Pbasename},
1070 + {"chdir", Pchdir},
1071 + {"chmod", Pchmod},
1072 + {"chown", Pchown},
1073 + {"crypt", Pcrypt},
1074 + {"ctermid", Pctermid},
1075 + {"dirname", Pdirname},
1076 + {"dir", Pdir},
1077 + {"dup", Pdup},
1078 + {"errno", Perrno},
1079 + {"exec", Pexec},
1080 + {"execp", Pexecp},
1081 + {"fdopen", Pfdopen},
1082 + {"fileno", Pfileno},
1083 + {"files", Pfiles},
1084 + {"fork", Pfork},
1085 + {"getcwd", Pgetcwd},
1086 + {"getenv", Pgetenv},
1087 + {"getgroup", Pgetgroup},
1088 + {"getlogin", Pgetlogin},
1089 + {"getpasswd", Pgetpasswd},
1090 + {"getpid", Pgetpid},
1091 + {"glob", Pglob},
1092 + {"hostid", Phostid},
1093 + {"kill", Pkill},
1094 + {"link", Plink},
1095 + {"mkdir", Pmkdir},
1096 + {"mkfifo", Pmkfifo},
1097 + {"pathconf", Ppathconf},
1098 + {"pipe", Ppipe},
1099 + {"readlink", Preadlink},
1100 + {"rmdir", Prmdir},
1101 + {"rpoll", Ppoll},
1102 + {"setenv", Psetenv},
1103 + {"setpid", Psetpid},
1104 + {"sleep", Psleep},
1105 + {"stat", Pstat},
1106 + {"sysconf", Psysconf},
1107 + {"times", Ptimes},
1108 + {"ttyname", Pttyname},
1109 + {"unlink", Punlink},
1110 + {"umask", Pumask},
1111 + {"uname", Puname},
1112 + {"utime", Putime},
1113 + {"wait", Pwait},
1114 +
1115 +#if ENABLE_SYSLOG
1116 + {"openlog", Popenlog},
1117 + {"syslog", Psyslog},
1118 + {"closelog", Pcloselog},
1119 +#endif
1120 +
1121 + {NULL, NULL}
1122 +};
1123 +
1124 +#define set_const(key, value) \
1125 + lua_pushliteral(L, key); \
1126 + lua_pushnumber(L, value); \
1127 + lua_settable(L, -3)
1128 +
1129 +LUALIB_API int luaopen_posix (lua_State *L)
1130 +{
1131 + luaL_register(L,MYNAME,R);
1132 + lua_pushliteral(L,"version"); /** version */
1133 + lua_pushliteral(L,MYVERSION);
1134 + lua_settable(L,-3);
1135 +
1136 +#if ENABLE_SYSLOG
1137 + set_const("LOG_AUTH", LOG_AUTH);
1138 + set_const("LOG_AUTHPRIV", LOG_AUTHPRIV);
1139 + set_const("LOG_CRON", LOG_CRON);
1140 + set_const("LOG_DAEMON", LOG_DAEMON);
1141 + set_const("LOG_FTP", LOG_FTP);
1142 + set_const("LOG_KERN", LOG_KERN);
1143 + set_const("LOG_LOCAL0", LOG_LOCAL0);
1144 + set_const("LOG_LOCAL1", LOG_LOCAL1);
1145 + set_const("LOG_LOCAL2", LOG_LOCAL2);
1146 + set_const("LOG_LOCAL3", LOG_LOCAL3);
1147 + set_const("LOG_LOCAL4", LOG_LOCAL4);
1148 + set_const("LOG_LOCAL5", LOG_LOCAL5);
1149 + set_const("LOG_LOCAL6", LOG_LOCAL6);
1150 + set_const("LOG_LOCAL7", LOG_LOCAL7);
1151 + set_const("LOG_LPR", LOG_LPR);
1152 + set_const("LOG_MAIL", LOG_MAIL);
1153 + set_const("LOG_NEWS", LOG_NEWS);
1154 + set_const("LOG_SYSLOG", LOG_SYSLOG);
1155 + set_const("LOG_USER", LOG_USER);
1156 + set_const("LOG_UUCP", LOG_UUCP);
1157 +
1158 + set_const("LOG_EMERG", LOG_EMERG);
1159 + set_const("LOG_ALERT", LOG_ALERT);
1160 + set_const("LOG_CRIT", LOG_CRIT);
1161 + set_const("LOG_ERR", LOG_ERR);
1162 + set_const("LOG_WARNING", LOG_WARNING);
1163 + set_const("LOG_NOTICE", LOG_NOTICE);
1164 + set_const("LOG_INFO", LOG_INFO);
1165 + set_const("LOG_DEBUG", LOG_DEBUG);
1166 +#endif
1167 +
1168 +
1169 + return 1;
1170 +}
1171 +
1172 +/*EOF*/
1173 --- a/src/lualib.h
1174 +++ b/src/lualib.h
1175 @@ -39,6 +39,9 @@ LUALIB_API int (luaopen_debug) (lua_Stat
1176 #define LUA_LOADLIBNAME "package"
1177 LUALIB_API int (luaopen_package) (lua_State *L);
1178
1179 +#define LUA_POSIXLIBNAME "posix"
1180 +LUALIB_API int (luaopen_posix) (lua_State *L);
1181 +
1182
1183 /* open all previous libraries */
1184 LUALIB_API void (luaL_openlibs) (lua_State *L);
1185 --- /dev/null
1186 +++ b/src/modemuncher.c
1187 @@ -0,0 +1,261 @@
1188 +/*
1189 + Mode Muncher -- modemuncher.c
1190 + 961110 Claudio Terra
1191 +
1192 + munch vb
1193 + [ME monchen, perh. influenced by MF mangier to eat --more at MANGER]
1194 + :to chew with a crunching sound: eat with relish
1195 + :to chew food with a crunching sound: eat food with relish
1196 + --munch-er n
1197 +
1198 + The NeXT Digital Edition of Webster's Ninth New Collegiate Dictionary
1199 + and Webster's Collegiate Thesaurus
1200 +*/
1201 +
1202 +/* struct for rwx <-> POSIX constant lookup tables */
1203 +struct modeLookup
1204 +{
1205 + char rwx;
1206 + mode_t bits;
1207 +};
1208 +
1209 +typedef struct modeLookup modeLookup;
1210 +
1211 +static modeLookup modesel[] =
1212 +{
1213 + /* RWX char Posix Constant */
1214 + {'r', S_IRUSR},
1215 + {'w', S_IWUSR},
1216 + {'x', S_IXUSR},
1217 +
1218 + {'r', S_IRGRP},
1219 + {'w', S_IWGRP},
1220 + {'x', S_IXGRP},
1221 +
1222 + {'r', S_IROTH},
1223 + {'w', S_IWOTH},
1224 + {'x', S_IXOTH},
1225 + {0, (mode_t)-1} /* do not delete this line */
1226 +};
1227 +
1228 +
1229 +
1230 +static int rwxrwxrwx(mode_t *mode, const char *p)
1231 +{
1232 + int count;
1233 + mode_t tmp_mode = *mode;
1234 +
1235 + tmp_mode &= ~(S_ISUID | S_ISGID); /* turn off suid and sgid flags */
1236 + for (count=0; count<9; count ++)
1237 + {
1238 + if (*p == modesel[count].rwx) tmp_mode |= modesel[count].bits; /* set a bit */
1239 + else if (*p == '-') tmp_mode &= ~modesel[count].bits; /* clear a bit */
1240 + else if (*p=='s') switch(count)
1241 + {
1242 + case 2: /* turn on suid flag */
1243 + tmp_mode |= S_ISUID | S_IXUSR;
1244 + break;
1245 +
1246 + case 5: /* turn on sgid flag */
1247 + tmp_mode |= S_ISGID | S_IXGRP;
1248 + break;
1249 +
1250 + default:
1251 + return -4; /* failed! -- bad rwxrwxrwx mode change */
1252 + break;
1253 + }
1254 + p++;
1255 + }
1256 + *mode = tmp_mode;
1257 + return 0;
1258 +}
1259 +
1260 +static void modechopper(mode_t mode, char *p)
1261 +{
1262 + /* requires char p[10] */
1263 + int count;
1264 + char *pp;
1265 +
1266 + pp=p;
1267 +
1268 + for (count=0; count<9; count ++)
1269 + {
1270 + if (mode & modesel[count].bits) *p = modesel[count].rwx;
1271 + else *p='-';
1272 +
1273 + p++;
1274 + }
1275 + *p=0; /* to finish the string */
1276 +
1277 + /* dealing with suid and sgid flags */
1278 + if (mode & S_ISUID) pp[2] = (mode & S_IXUSR) ? 's' : 'S';
1279 + if (mode & S_ISGID) pp[5] = (mode & S_IXGRP) ? 's' : 'S';
1280 +
1281 +}
1282 +
1283 +static int mode_munch(mode_t *mode, const char* p)
1284 +{
1285 +
1286 + char op=0;
1287 + mode_t affected_bits, ch_mode;
1288 + int doneFlag = 0;
1289 +#ifdef DEBUG
1290 +char tmp[10];
1291 +#endif
1292 +
1293 +#ifdef DEBUG
1294 +modechopper(*mode, tmp);
1295 +printf("modemuncher: got base mode = %s\n", tmp);
1296 +#endif
1297 +
1298 + while (!doneFlag)
1299 + {
1300 + /* step 0 -- clear temporary variables */
1301 + affected_bits=0;
1302 + ch_mode=0;
1303 +
1304 + /* step 1 -- who's affected? */
1305 +
1306 +#ifdef DEBUG
1307 +printf("modemuncher step 1\n");
1308 +#endif
1309 +
1310 + /* mode string given in rwxrwxrwx format */
1311 + if (*p== 'r' || *p == '-') return rwxrwxrwx(mode, p);
1312 +
1313 + /* mode string given in ugoa+-=rwx format */
1314 + for ( ; ; p++)
1315 + switch (*p)
1316 + {
1317 + case 'u':
1318 + affected_bits |= 04700;
1319 + break;
1320 +
1321 + case 'g':
1322 + affected_bits |= 02070;
1323 + break;
1324 +
1325 + case 'o':
1326 + affected_bits |= 01007;
1327 + break;
1328 +
1329 + case 'a':
1330 + affected_bits |= 07777;
1331 + break;
1332 +
1333 + /* ignore spaces */
1334 + case ' ':
1335 + break;
1336 +
1337 +
1338 + default:
1339 + goto no_more_affected;
1340 + }
1341 +
1342 + no_more_affected:
1343 + /* If none specified, affect all bits. */
1344 + if (affected_bits == 0) affected_bits = 07777;
1345 +
1346 + /* step 2 -- how is it changed? */
1347 +
1348 +#ifdef DEBUG
1349 +printf("modemuncher step 2 (*p='%c')\n", *p);
1350 +#endif
1351 +
1352 + switch (*p)
1353 + {
1354 + case '+':
1355 + case '-':
1356 + case '=':
1357 + op = *p;
1358 + break;
1359 +
1360 + /* ignore spaces */
1361 + case ' ':
1362 + break;
1363 +
1364 + default:
1365 + return -1; /* failed! -- bad operator */
1366 + }
1367 +
1368 +
1369 + /* step 3 -- what are the changes? */
1370 +
1371 +#ifdef DEBUG
1372 +printf("modemuncher step 3\n");
1373 +#endif
1374 +
1375 + for (p++ ; *p!=0 ; p++)
1376 + switch (*p)
1377 + {
1378 + case 'r':
1379 + ch_mode |= 00444;
1380 + break;
1381 +
1382 + case 'w':
1383 + ch_mode |= 00222;
1384 + break;
1385 +
1386 + case 'x':
1387 + ch_mode |= 00111;
1388 + break;
1389 +
1390 + case 's':
1391 + /* Set the setuid/gid bits if `u' or `g' is selected. */
1392 + ch_mode |= 06000;
1393 + break;
1394 +
1395 + /* ignore spaces */
1396 + case ' ':
1397 + break;
1398 +
1399 + default:
1400 + goto specs_done;
1401 + }
1402 +
1403 + specs_done:
1404 + /* step 4 -- apply the changes */
1405 +
1406 +#ifdef DEBUG
1407 + printf("modemuncher step 4\n");
1408 +#endif
1409 + if (*p != ',') doneFlag = 1;
1410 + if (*p != 0 && *p != ' ' && *p != ',')
1411 + {
1412 +
1413 +#ifdef DEBUG
1414 +printf("modemuncher: comma error!\n");
1415 +printf("modemuncher: doneflag = %u\n", doneFlag);
1416 +#endif
1417 + return -2; /* failed! -- bad mode change */
1418 +
1419 + }
1420 + p++;
1421 + /*if (!ch_mode) return -2;*/ /* failed! -- bad mode change */
1422 + if (ch_mode) switch (op)
1423 + {
1424 + case '+':
1425 + *mode = *mode |= ch_mode & affected_bits;
1426 + break;
1427 +
1428 + case '-':
1429 + *mode = *mode &= ~(ch_mode & affected_bits);
1430 + break;
1431 +
1432 + case '=':
1433 + *mode = ch_mode & affected_bits;
1434 + break;
1435 +
1436 + default:
1437 + return -3; /* failed! -- unknown error */
1438 + }
1439 + }
1440 +#ifdef DEBUG
1441 +modechopper(*mode, tmp);
1442 +printf("modemuncher: returning mode = %s\n", tmp);
1443 +#endif
1444 +
1445 + return 0; /* successful call */
1446 +}
1447 +
1448 +
This page took 0.136226 seconds and 5 git commands to generate.