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