lxmppd-hg-xmllex: util-src/pposix.c

/* Prosody IM
-- Copyright (C) 2008-2010 Matthew Wild
-- Copyright (C) 2008-2010 Waqas Hussain
-- Copyright (C) 2009 Tobias Markmann
--
-- This project is MIT/X11 licensed. Please see the
-- COPYING file in the source package for more information.
--
*/
 
/*
* pposix.c
* POSIX support functions for Lua
*/
 
#define MODULE_VERSION "0.3.5"
 
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <libgen.h>
#include <sys/resource.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/utsname.h>
#include <fcntl.h>
 
#include <syslog.h>
#include <pwd.h>
#include <grp.h>
 
#include <string.h>
#include <errno.h>
#include "lua.h"
#include "lauxlib.h"
 
/* Daemonization support */
 
static int lc_daemonize(lua_State *L)
{
 
	pid_t pid;
 
	if ( getppid() == 1 )
	{
		lua_pushboolean(L, 0);
		lua_pushstring(L, "already-daemonized");
		return 2;
	}
 
	/* Attempt initial fork */
	if((pid = fork()) < 0)
	{
		/* Forking failed */
		lua_pushboolean(L, 0);
		lua_pushstring(L, "fork-failed");
		return 2;
	}
	else if(pid != 0)
	{
		/* We are the parent process */
		lua_pushboolean(L, 1);
		lua_pushnumber(L, pid);
		return 2;
	}
 
	/* and we are the child process */
	if(setsid() == -1)
	{
		/* We failed to become session leader */
		/* (we probably already were) */
		lua_pushboolean(L, 0);
		lua_pushstring(L, "setsid-failed");
		return 2;
	}
 
	/* Close stdin, stdout, stderr */
	close(0);
	close(1);
	close(2);
 
	/* Final fork, use it wisely */
	if(fork())
		exit(0);
 
	/* Show's over, let's continue */
	lua_pushboolean(L, 1);
	lua_pushnil(L);
	return 2;
}
 
/* Syslog support */
 
const char * const facility_strings[] = {
					"auth",
#if !(defined(sun) || defined(__sun))
					"authpriv",
#endif
					"cron",
					"daemon",
#if !(defined(sun) || defined(__sun))
					"ftp",
#endif
					"kern",
					"local0",
					"local1",
					"local2",
					"local3",
					"local4",
					"local5",
					"local6",
					"local7",
					"lpr",
					"mail",
					"syslog",
					"user",
					"uucp",
					NULL
				};
int facility_constants[] =	{
					LOG_AUTH,
#if !(defined(sun) || defined(__sun))
					LOG_AUTHPRIV,
#endif
					LOG_CRON,
					LOG_DAEMON,
#if !(defined(sun) || defined(__sun))
					LOG_FTP,
#endif
					LOG_KERN,
					LOG_LOCAL0,
					LOG_LOCAL1,
					LOG_LOCAL2,
					LOG_LOCAL3,
					LOG_LOCAL4,
					LOG_LOCAL5,
					LOG_LOCAL6,
					LOG_LOCAL7,
					LOG_LPR,
					LOG_MAIL,
					LOG_NEWS,
					LOG_SYSLOG,
					LOG_USER,
					LOG_UUCP,
					-1
				};
 
/* "
       The parameter ident in the call of openlog() is probably stored  as-is.
       Thus,  if  the  string  it  points  to  is  changed, syslog() may start
       prepending the changed string, and if the string it points to ceases to
       exist,  the  results  are  undefined.  Most portable is to use a string
       constant.
   " -- syslog manpage
*/
char* syslog_ident = NULL;
 
int lc_syslog_open(lua_State* L)
{
	int facility = luaL_checkoption(L, 2, "daemon", facility_strings);
	facility = facility_constants[facility];
 
	luaL_checkstring(L, 1);
 
	if(syslog_ident)
		free(syslog_ident);
 
	syslog_ident = strdup(lua_tostring(L, 1));
 
	openlog(syslog_ident, LOG_PID, facility);
	return 0;
}
 
const char * const level_strings[] = {
				"debug",
				"info",
				"notice",
				"warn",
				"error",
				NULL
			};
int level_constants[] = 	{
				LOG_DEBUG,
				LOG_INFO,
				LOG_NOTICE,
				LOG_WARNING,
				LOG_CRIT,
				-1
			};
int lc_syslog_log(lua_State* L)
{
	int level = luaL_checkoption(L, 1, "notice", level_strings);
	level = level_constants[level];
 
	luaL_checkstring(L, 2);
 
	syslog(level, "%s", lua_tostring(L, 2));
	return 0;
}
 
int lc_syslog_close(lua_State* L)
{
	closelog();
	if(syslog_ident)
	{
		free(syslog_ident);
		syslog_ident = NULL;
	}
	return 0;
}
 
int lc_syslog_setmask(lua_State* L)
{
	int level_idx = luaL_checkoption(L, 1, "notice", level_strings);
	int mask = 0;
	do
	{
		mask |= LOG_MASK(level_constants[level_idx]);
	} while (++level_idx<=4);
 
	setlogmask(mask);
	return 0;
}
 
/* getpid */
 
int lc_getpid(lua_State* L)
{
	lua_pushinteger(L, getpid());
	return 1;
}
 
/* UID/GID functions */
 
int lc_getuid(lua_State* L)
{
	lua_pushinteger(L, getuid());
	return 1;
}
 
int lc_getgid(lua_State* L)
{
	lua_pushinteger(L, getgid());
	return 1;
}
 
int lc_setuid(lua_State* L)
{
	int uid = -1;
	if(lua_gettop(L) < 1)
		return 0;
	if(!lua_isnumber(L, 1) && lua_tostring(L, 1))
	{
		/* Passed UID is actually a string, so look up the UID */
		struct passwd *p;
		p = getpwnam(lua_tostring(L, 1));
		if(!p)
		{
			lua_pushboolean(L, 0);
			lua_pushstring(L, "no-such-user");
			return 2;
		}
		uid = p->pw_uid;
	}
	else
	{
		uid = lua_tonumber(L, 1);
	}
 
	if(uid>-1)
	{
		/* Ok, attempt setuid */
		errno = 0;
		if(setuid(uid))
		{
			/* Fail */
			lua_pushboolean(L, 0);
			switch(errno)
			{
			case EINVAL:
				lua_pushstring(L, "invalid-uid");
				break;
			case EPERM:
				lua_pushstring(L, "permission-denied");
				break;
			default:
				lua_pushstring(L, "unknown-error");
			}
			return 2;
		}
		else
		{
			/* Success! */
			lua_pushboolean(L, 1);
			return 1;
		}
	}
 
	/* Seems we couldn't find a valid UID to switch to */
	lua_pushboolean(L, 0);
	lua_pushstring(L, "invalid-uid");
	return 2;
}
 
int lc_setgid(lua_State* L)
{
	int gid = -1;
	if(lua_gettop(L) < 1)
		return 0;
	if(!lua_isnumber(L, 1) && lua_tostring(L, 1))
	{
		/* Passed GID is actually a string, so look up the GID */
		struct group *g;
		g = getgrnam(lua_tostring(L, 1));
		if(!g)
		{
			lua_pushboolean(L, 0);
			lua_pushstring(L, "no-such-group");
			return 2;
		}
		gid = g->gr_gid;
	}
	else
	{
		gid = lua_tonumber(L, 1);
	}
 
	if(gid>-1)
	{
		/* Ok, attempt setgid */
		errno = 0;
		if(setgid(gid))
		{
			/* Fail */
			lua_pushboolean(L, 0);
			switch(errno)
			{
			case EINVAL:
				lua_pushstring(L, "invalid-gid");
				break;
			case EPERM:
				lua_pushstring(L, "permission-denied");
				break;
			default:
				lua_pushstring(L, "unknown-error");
			}
			return 2;
		}
		else
		{
			/* Success! */
			lua_pushboolean(L, 1);
			return 1;
		}
	}
 
	/* Seems we couldn't find a valid GID to switch to */
	lua_pushboolean(L, 0);
	lua_pushstring(L, "invalid-gid");
	return 2;
}
 
int lc_initgroups(lua_State* L)
{
	int ret;
	gid_t gid;
	struct passwd *p;
 
	if(!lua_isstring(L, 1))
	{
		lua_pushnil(L);
		lua_pushstring(L, "invalid-username");
		return 2;
	}
	p = getpwnam(lua_tostring(L, 1));
	if(!p)
	{
		lua_pushnil(L);
		lua_pushstring(L, "no-such-user");
		return 2;
	}
	if(lua_gettop(L) < 2)
		lua_pushnil(L);
	switch(lua_type(L, 2))
	{
	case LUA_TNIL:
		gid = p->pw_gid;
		break;
	case LUA_TNUMBER:
		gid = lua_tointeger(L, 2);
		break;
	default:
		lua_pushnil(L);
		lua_pushstring(L, "invalid-gid");
		return 2;
	}
	ret = initgroups(lua_tostring(L, 1), gid);
	switch(errno)
	{
	case 0:
		lua_pushboolean(L, 1);
		lua_pushnil(L);
		break;
	case ENOMEM:
		lua_pushnil(L);
		lua_pushstring(L, "no-memory");
		break;
	case EPERM:
		lua_pushnil(L);
		lua_pushstring(L, "permission-denied");
		break;
	default:
		lua_pushnil(L);
		lua_pushstring(L, "unknown-error");
	}
	return 2;
}
 
int lc_umask(lua_State* L)
{
	char old_mode_string[7];
	mode_t old_mode = umask(strtoul(luaL_checkstring(L, 1), NULL, 8));
 
	snprintf(old_mode_string, sizeof(old_mode_string), "%03o", old_mode);
	old_mode_string[sizeof(old_mode_string)-1] = 0;
	lua_pushstring(L, old_mode_string);
 
	return 1;
}
 
int lc_mkdir(lua_State* L)
{
	int ret = mkdir(luaL_checkstring(L, 1), S_IRUSR | S_IWUSR | S_IXUSR
		| S_IRGRP | S_IWGRP | S_IXGRP
		| S_IROTH | S_IXOTH); /* mode 775 */
 
	lua_pushboolean(L, ret==0);
	if(ret)
	{
		lua_pushstring(L, strerror(errno));
		return 2;
	}
	return 1;
}
 
/*	Like POSIX's setrlimit()/getrlimit() API functions.
 *
 *	Syntax:
 *	pposix.setrlimit( resource, soft limit, hard limit)
 *
 *	Any negative limit will be replace with the current limit by an additional call of getrlimit().
 *
 *	Example usage:
 *	pposix.setrlimit("NOFILE", 1000, 2000)
 */
int string2resource(const char *s) {
	if (!strcmp(s, "CORE")) return RLIMIT_CORE;
	if (!strcmp(s, "CPU")) return RLIMIT_CPU;
	if (!strcmp(s, "DATA")) return RLIMIT_DATA;
	if (!strcmp(s, "FSIZE")) return RLIMIT_FSIZE;
	if (!strcmp(s, "NOFILE")) return RLIMIT_NOFILE;
	if (!strcmp(s, "STACK")) return RLIMIT_STACK;
#if !(defined(sun) || defined(__sun))
	if (!strcmp(s, "MEMLOCK")) return RLIMIT_MEMLOCK;
	if (!strcmp(s, "NPROC")) return RLIMIT_NPROC;
	if (!strcmp(s, "RSS")) return RLIMIT_RSS;
#endif
	return -1;
}
 
int lc_setrlimit(lua_State *L) {
	int arguments = lua_gettop(L);
	int softlimit = -1;
	int hardlimit = -1;
	const char *resource = NULL;
	int rid = -1;
	if(arguments < 1 || arguments > 3) {
		lua_pushboolean(L, 0);
		lua_pushstring(L, "incorrect-arguments");
	}
 
	resource = luaL_checkstring(L, 1);
	softlimit = luaL_checkinteger(L, 2);
	hardlimit = luaL_checkinteger(L, 3);
 
	rid = string2resource(resource);
	if (rid != -1) {
		struct rlimit lim;
		struct rlimit lim_current;
 
		if (softlimit < 0 || hardlimit < 0) {
			if (getrlimit(rid, &lim_current)) {
				lua_pushboolean(L, 0);
				lua_pushstring(L, "getrlimit-failed");
				return 2;
			}
		}
 
		if (softlimit < 0) lim.rlim_cur = lim_current.rlim_cur;
			else lim.rlim_cur = softlimit;
		if (hardlimit < 0) lim.rlim_max = lim_current.rlim_max;
			else lim.rlim_max = hardlimit;
 
		if (setrlimit(rid, &lim)) {
			lua_pushboolean(L, 0);
			lua_pushstring(L, "setrlimit-failed");
			return 2;
		}
	} else {
		/* Unsupported resoucrce. Sorry I'm pretty limited by POSIX standard. */
		lua_pushboolean(L, 0);
		lua_pushstring(L, "invalid-resource");
		return 2;
	}
	lua_pushboolean(L, 1);
	return 1;
}
 
int lc_getrlimit(lua_State *L) {
	int arguments = lua_gettop(L);
	const char *resource = NULL;
	int rid = -1;
	struct rlimit lim;
 
	if (arguments != 1) {
		lua_pushboolean(L, 0);
		lua_pushstring(L, "invalid-arguments");
		return 2;
	}
 
	resource = luaL_checkstring(L, 1);
	rid = string2resource(resource);
	if (rid != -1) {
		if (getrlimit(rid, &lim)) {
			lua_pushboolean(L, 0);
			lua_pushstring(L, "getrlimit-failed.");
			return 2;
		}
	} else {
		/* Unsupported resoucrce. Sorry I'm pretty limited by POSIX standard. */
		lua_pushboolean(L, 0);
		lua_pushstring(L, "invalid-resource");
		return 2;
	}
	lua_pushboolean(L, 1);
	lua_pushnumber(L, lim.rlim_cur);
	lua_pushnumber(L, lim.rlim_max);
	return 3;
}
 
int lc_abort(lua_State* L)
{
	abort();
	return 0;
}
 
int lc_uname(lua_State* L)
{
	struct utsname uname_info;
	if(uname(&uname_info) != 0)
	{
		lua_pushnil(L);
		lua_pushstring(L, strerror(errno));
		return 2;
	}
	lua_newtable(L);
	lua_pushstring(L, uname_info.sysname);
	lua_setfield(L, -2, "sysname");
	lua_pushstring(L, uname_info.nodename);
	lua_setfield(L, -2, "nodename");
	lua_pushstring(L, uname_info.release);
	lua_setfield(L, -2, "release");
	lua_pushstring(L, uname_info.version);
	lua_setfield(L, -2, "version");
	lua_pushstring(L, uname_info.machine);
	lua_setfield(L, -2, "machine");
	return 1;
}
 
/* Register functions */
 
int luaopen_util_pposix(lua_State *L)
{
	luaL_Reg exports[] = {
		{ "abort", lc_abort },
 
		{ "daemonize", lc_daemonize },
 
		{ "syslog_open", lc_syslog_open },
		{ "syslog_close", lc_syslog_close },
		{ "syslog_log", lc_syslog_log },
		{ "syslog_setminlevel", lc_syslog_setmask },
 
		{ "getpid", lc_getpid },
		{ "getuid", lc_getuid },
		{ "getgid", lc_getgid },
 
		{ "setuid", lc_setuid },
		{ "setgid", lc_setgid },
		{ "initgroups", lc_initgroups },
 
		{ "umask", lc_umask },
 
		{ "mkdir", lc_mkdir },
 
		{ "setrlimit", lc_setrlimit },
		{ "getrlimit", lc_getrlimit },
 
		{ "uname", lc_uname },
 
		{ NULL, NULL }
	};
 
	luaL_register(L, "pposix",  exports);
 
	lua_pushliteral(L, "pposix");
	lua_setfield(L, -2, "_NAME");
 
	lua_pushliteral(L, MODULE_VERSION);
	lua_setfield(L, -2, "_VERSION");
 
	return 1;
}

1	/* Prosody IM
2	-- Copyright (C) 2008-2010 Matthew Wild
3	-- Copyright (C) 2008-2010 Waqas Hussain
4	-- Copyright (C) 2009 Tobias Markmann
5	--
6	-- This project is MIT/X11 licensed. Please see the
7	-- COPYING file in the source package for more information.
8	--
9	*/
10
11	/*
12	* pposix.c
13	* POSIX support functions for Lua
14	*/
15
16	#define MODULE_VERSION "0.3.5"
17
18	#include <stdlib.h>
19	#include <math.h>
20	#include <unistd.h>
21	#include <libgen.h>
22	#include <sys/resource.h>
23	#include <sys/types.h>
24	#include <sys/stat.h>
25	#include <sys/utsname.h>
26	#include <fcntl.h>
27
28	#include <syslog.h>
29	#include <pwd.h>
30	#include <grp.h>
31
32	#include <string.h>
33	#include <errno.h>
34	#include "lua.h"
35	#include "lauxlib.h"
36
37	/* Daemonization support */
38
39	static int lc_daemonize(lua_State *L)
40	{
41
42	pid_t pid;
43
44	if ( getppid() == 1 )
45	{
46	lua_pushboolean(L, 0);
47	lua_pushstring(L, "already-daemonized");
48	return 2;
49	}
50
51	/* Attempt initial fork */
52	if((pid = fork()) < 0)
53	{
54	/* Forking failed */
55	lua_pushboolean(L, 0);
56	lua_pushstring(L, "fork-failed");
57	return 2;
58	}
59	else if(pid != 0)
60	{
61	/* We are the parent process */
62	lua_pushboolean(L, 1);
63	lua_pushnumber(L, pid);
64	return 2;
65	}
66
67	/* and we are the child process */
68	if(setsid() == -1)
69	{
70	/* We failed to become session leader */
71	/* (we probably already were) */
72	lua_pushboolean(L, 0);
73	lua_pushstring(L, "setsid-failed");
74	return 2;
75	}
76
77	/* Close stdin, stdout, stderr */
78	close(0);
79	close(1);
80	close(2);
81
82	/* Final fork, use it wisely */
83	if(fork())
84	exit(0);
85
86	/* Show's over, let's continue */
87	lua_pushboolean(L, 1);
88	lua_pushnil(L);
89	return 2;
90	}
91
92	/* Syslog support */
93
94	const char * const facility_strings[] = {
95	"auth",
96	#if !(defined(sun) \|\| defined(__sun))
97	"authpriv",
98	#endif
99	"cron",
100	"daemon",
101	#if !(defined(sun) \|\| defined(__sun))
102	"ftp",
103	#endif
104	"kern",
105	"local0",
106	"local1",
107	"local2",
108	"local3",
109	"local4",
110	"local5",
111	"local6",
112	"local7",
113	"lpr",
114	"mail",
115	"syslog",
116	"user",
117	"uucp",
118	NULL
119	};
120	int facility_constants[] = {
121	LOG_AUTH,
122	#if !(defined(sun) \|\| defined(__sun))
123	LOG_AUTHPRIV,
124	#endif
125	LOG_CRON,
126	LOG_DAEMON,
127	#if !(defined(sun) \|\| defined(__sun))
128	LOG_FTP,
129	#endif
130	LOG_KERN,
131	LOG_LOCAL0,
132	LOG_LOCAL1,
133	LOG_LOCAL2,
134	LOG_LOCAL3,
135	LOG_LOCAL4,
136	LOG_LOCAL5,
137	LOG_LOCAL6,
138	LOG_LOCAL7,
139	LOG_LPR,
140	LOG_MAIL,
141	LOG_NEWS,
142	LOG_SYSLOG,
143	LOG_USER,
144	LOG_UUCP,
145	-1
146	};
147
148	/* "
149	The parameter ident in the call of openlog() is probably stored as-is.
150	Thus, if the string it points to is changed, syslog() may start
151	prepending the changed string, and if the string it points to ceases to
152	exist, the results are undefined. Most portable is to use a string
153	constant.
154	" -- syslog manpage
155	*/
156	char* syslog_ident = NULL;
157
158	int lc_syslog_open(lua_State* L)
159	{
160	int facility = luaL_checkoption(L, 2, "daemon", facility_strings);
161	facility = facility_constants[facility];
162
163	luaL_checkstring(L, 1);
164
165	if(syslog_ident)
166	free(syslog_ident);
167
168	syslog_ident = strdup(lua_tostring(L, 1));
169
170	openlog(syslog_ident, LOG_PID, facility);
171	return 0;
172	}
173
174	const char * const level_strings[] = {
175	"debug",
176	"info",
177	"notice",
178	"warn",
179	"error",
180	NULL
181	};
182	int level_constants[] = {
183	LOG_DEBUG,
184	LOG_INFO,
185	LOG_NOTICE,
186	LOG_WARNING,
187	LOG_CRIT,
188	-1
189	};
190	int lc_syslog_log(lua_State* L)
191	{
192	int level = luaL_checkoption(L, 1, "notice", level_strings);
193	level = level_constants[level];
194
195	luaL_checkstring(L, 2);
196
197	syslog(level, "%s", lua_tostring(L, 2));
198	return 0;
199	}
200
201	int lc_syslog_close(lua_State* L)
202	{
203	closelog();
204	if(syslog_ident)
205	{
206	free(syslog_ident);
207	syslog_ident = NULL;
208	}
209	return 0;
210	}
211
212	int lc_syslog_setmask(lua_State* L)
213	{
214	int level_idx = luaL_checkoption(L, 1, "notice", level_strings);
215	int mask = 0;
216	do
217	{
218	mask \|= LOG_MASK(level_constants[level_idx]);
219	} while (++level_idx<=4);
220
221	setlogmask(mask);
222	return 0;
223	}
224
225	/* getpid */
226
227	int lc_getpid(lua_State* L)
228	{
229	lua_pushinteger(L, getpid());
230	return 1;
231	}
232
233	/* UID/GID functions */
234
235	int lc_getuid(lua_State* L)
236	{
237	lua_pushinteger(L, getuid());
238	return 1;
239	}
240
241	int lc_getgid(lua_State* L)
242	{
243	lua_pushinteger(L, getgid());
244	return 1;
245	}
246
247	int lc_setuid(lua_State* L)
248	{
249	int uid = -1;
250	if(lua_gettop(L) < 1)
251	return 0;
252	if(!lua_isnumber(L, 1) && lua_tostring(L, 1))
253	{
254	/* Passed UID is actually a string, so look up the UID */
255	struct passwd *p;
256	p = getpwnam(lua_tostring(L, 1));
257	if(!p)
258	{
259	lua_pushboolean(L, 0);
260	lua_pushstring(L, "no-such-user");
261	return 2;
262	}
263	uid = p->pw_uid;
264	}
265	else
266	{
267	uid = lua_tonumber(L, 1);
268	}
269
270	if(uid>-1)
271	{
272	/* Ok, attempt setuid */
273	errno = 0;
274	if(setuid(uid))
275	{
276	/* Fail */
277	lua_pushboolean(L, 0);
278	switch(errno)
279	{
280	case EINVAL:
281	lua_pushstring(L, "invalid-uid");
282	break;
283	case EPERM:
284	lua_pushstring(L, "permission-denied");
285	break;
286	default:
287	lua_pushstring(L, "unknown-error");
288	}
289	return 2;
290	}
291	else
292	{
293	/* Success! */
294	lua_pushboolean(L, 1);
295	return 1;
296	}
297	}
298
299	/* Seems we couldn't find a valid UID to switch to */
300	lua_pushboolean(L, 0);
301	lua_pushstring(L, "invalid-uid");
302	return 2;
303	}
304
305	int lc_setgid(lua_State* L)
306	{
307	int gid = -1;
308	if(lua_gettop(L) < 1)
309	return 0;
310	if(!lua_isnumber(L, 1) && lua_tostring(L, 1))
311	{
312	/* Passed GID is actually a string, so look up the GID */
313	struct group *g;
314	g = getgrnam(lua_tostring(L, 1));
315	if(!g)
316	{
317	lua_pushboolean(L, 0);
318	lua_pushstring(L, "no-such-group");
319	return 2;
320	}
321	gid = g->gr_gid;
322	}
323	else
324	{
325	gid = lua_tonumber(L, 1);
326	}
327
328	if(gid>-1)
329	{
330	/* Ok, attempt setgid */
331	errno = 0;
332	if(setgid(gid))
333	{
334	/* Fail */
335	lua_pushboolean(L, 0);
336	switch(errno)
337	{
338	case EINVAL:
339	lua_pushstring(L, "invalid-gid");
340	break;
341	case EPERM:
342	lua_pushstring(L, "permission-denied");
343	break;
344	default:
345	lua_pushstring(L, "unknown-error");
346	}
347	return 2;
348	}
349	else
350	{
351	/* Success! */
352	lua_pushboolean(L, 1);
353	return 1;
354	}
355	}
356
357	/* Seems we couldn't find a valid GID to switch to */
358	lua_pushboolean(L, 0);
359	lua_pushstring(L, "invalid-gid");
360	return 2;
361	}
362
363	int lc_initgroups(lua_State* L)
364	{
365	int ret;
366	gid_t gid;
367	struct passwd *p;
368
369	if(!lua_isstring(L, 1))
370	{
371	lua_pushnil(L);
372	lua_pushstring(L, "invalid-username");
373	return 2;
374	}
375	p = getpwnam(lua_tostring(L, 1));
376	if(!p)
377	{
378	lua_pushnil(L);
379	lua_pushstring(L, "no-such-user");
380	return 2;
381	}
382	if(lua_gettop(L) < 2)
383	lua_pushnil(L);
384	switch(lua_type(L, 2))
385	{
386	case LUA_TNIL:
387	gid = p->pw_gid;
388	break;
389	case LUA_TNUMBER:
390	gid = lua_tointeger(L, 2);
391	break;
392	default:
393	lua_pushnil(L);
394	lua_pushstring(L, "invalid-gid");
395	return 2;
396	}
397	ret = initgroups(lua_tostring(L, 1), gid);
398	switch(errno)
399	{
400	case 0:
401	lua_pushboolean(L, 1);
402	lua_pushnil(L);
403	break;
404	case ENOMEM:
405	lua_pushnil(L);
406	lua_pushstring(L, "no-memory");
407	break;
408	case EPERM:
409	lua_pushnil(L);
410	lua_pushstring(L, "permission-denied");
411	break;
412	default:
413	lua_pushnil(L);
414	lua_pushstring(L, "unknown-error");
415	}
416	return 2;
417	}
418
419	int lc_umask(lua_State* L)
420	{
421	char old_mode_string[7];
422	mode_t old_mode = umask(strtoul(luaL_checkstring(L, 1), NULL, 8));
423
424	snprintf(old_mode_string, sizeof(old_mode_string), "%03o", old_mode);
425	old_mode_string[sizeof(old_mode_string)-1] = 0;
426	lua_pushstring(L, old_mode_string);
427
428	return 1;
429	}
430
431	int lc_mkdir(lua_State* L)
432	{
433	int ret = mkdir(luaL_checkstring(L, 1), S_IRUSR \| S_IWUSR \| S_IXUSR
434	\| S_IRGRP \| S_IWGRP \| S_IXGRP
435	\| S_IROTH \| S_IXOTH); /* mode 775 */
436
437	lua_pushboolean(L, ret==0);
438	if(ret)
439	{
440	lua_pushstring(L, strerror(errno));
441	return 2;
442	}
443	return 1;
444	}
445
446	/* Like POSIX's setrlimit()/getrlimit() API functions.
447	*
448	* Syntax:
449	* pposix.setrlimit( resource, soft limit, hard limit)
450	*
451	* Any negative limit will be replace with the current limit by an additional call of getrlimit().
452	*
453	* Example usage:
454	* pposix.setrlimit("NOFILE", 1000, 2000)
455	*/
456	int string2resource(const char *s) {
457	if (!strcmp(s, "CORE")) return RLIMIT_CORE;
458	if (!strcmp(s, "CPU")) return RLIMIT_CPU;
459	if (!strcmp(s, "DATA")) return RLIMIT_DATA;
460	if (!strcmp(s, "FSIZE")) return RLIMIT_FSIZE;
461	if (!strcmp(s, "NOFILE")) return RLIMIT_NOFILE;
462	if (!strcmp(s, "STACK")) return RLIMIT_STACK;
463	#if !(defined(sun) \|\| defined(__sun))
464	if (!strcmp(s, "MEMLOCK")) return RLIMIT_MEMLOCK;
465	if (!strcmp(s, "NPROC")) return RLIMIT_NPROC;
466	if (!strcmp(s, "RSS")) return RLIMIT_RSS;
467	#endif
468	return -1;
469	}
470
471	int lc_setrlimit(lua_State *L) {
472	int arguments = lua_gettop(L);
473	int softlimit = -1;
474	int hardlimit = -1;
475	const char *resource = NULL;
476	int rid = -1;
477	if(arguments < 1 \|\| arguments > 3) {
478	lua_pushboolean(L, 0);
479	lua_pushstring(L, "incorrect-arguments");
480	}
481
482	resource = luaL_checkstring(L, 1);
483	softlimit = luaL_checkinteger(L, 2);
484	hardlimit = luaL_checkinteger(L, 3);
485
486	rid = string2resource(resource);
487	if (rid != -1) {
488	struct rlimit lim;
489	struct rlimit lim_current;
490
491	if (softlimit < 0 \|\| hardlimit < 0) {
492	if (getrlimit(rid, &lim_current)) {
493	lua_pushboolean(L, 0);
494	lua_pushstring(L, "getrlimit-failed");
495	return 2;
496	}
497	}
498
499	if (softlimit < 0) lim.rlim_cur = lim_current.rlim_cur;
500	else lim.rlim_cur = softlimit;
501	if (hardlimit < 0) lim.rlim_max = lim_current.rlim_max;
502	else lim.rlim_max = hardlimit;
503
504	if (setrlimit(rid, &lim)) {
505	lua_pushboolean(L, 0);
506	lua_pushstring(L, "setrlimit-failed");
507	return 2;
508	}
509	} else {
510	/* Unsupported resoucrce. Sorry I'm pretty limited by POSIX standard. */
511	lua_pushboolean(L, 0);
512	lua_pushstring(L, "invalid-resource");
513	return 2;
514	}
515	lua_pushboolean(L, 1);
516	return 1;
517	}
518
519	int lc_getrlimit(lua_State *L) {
520	int arguments = lua_gettop(L);
521	const char *resource = NULL;
522	int rid = -1;
523	struct rlimit lim;
524
525	if (arguments != 1) {
526	lua_pushboolean(L, 0);
527	lua_pushstring(L, "invalid-arguments");
528	return 2;
529	}
530
531	resource = luaL_checkstring(L, 1);
532	rid = string2resource(resource);
533	if (rid != -1) {
534	if (getrlimit(rid, &lim)) {
535	lua_pushboolean(L, 0);
536	lua_pushstring(L, "getrlimit-failed.");
537	return 2;
538	}
539	} else {
540	/* Unsupported resoucrce. Sorry I'm pretty limited by POSIX standard. */
541	lua_pushboolean(L, 0);
542	lua_pushstring(L, "invalid-resource");
543	return 2;
544	}
545	lua_pushboolean(L, 1);
546	lua_pushnumber(L, lim.rlim_cur);
547	lua_pushnumber(L, lim.rlim_max);
548	return 3;
549	}
550
551	int lc_abort(lua_State* L)
552	{
553	abort();
554	return 0;
555	}
556
557	int lc_uname(lua_State* L)
558	{
559	struct utsname uname_info;
560	if(uname(&uname_info) != 0)
561	{
562	lua_pushnil(L);
563	lua_pushstring(L, strerror(errno));
564	return 2;
565	}
566	lua_newtable(L);
567	lua_pushstring(L, uname_info.sysname);
568	lua_setfield(L, -2, "sysname");
569	lua_pushstring(L, uname_info.nodename);
570	lua_setfield(L, -2, "nodename");
571	lua_pushstring(L, uname_info.release);
572	lua_setfield(L, -2, "release");
573	lua_pushstring(L, uname_info.version);
574	lua_setfield(L, -2, "version");
575	lua_pushstring(L, uname_info.machine);
576	lua_setfield(L, -2, "machine");
577	return 1;
578	}
579
580	/* Register functions */
581
582	int luaopen_util_pposix(lua_State *L)
583	{
584	luaL_Reg exports[] = {
585	{ "abort", lc_abort },
586
587	{ "daemonize", lc_daemonize },
588
589	{ "syslog_open", lc_syslog_open },
590	{ "syslog_close", lc_syslog_close },
591	{ "syslog_log", lc_syslog_log },
592	{ "syslog_setminlevel", lc_syslog_setmask },
593
594	{ "getpid", lc_getpid },
595	{ "getuid", lc_getuid },
596	{ "getgid", lc_getgid },
597
598	{ "setuid", lc_setuid },
599	{ "setgid", lc_setgid },
600	{ "initgroups", lc_initgroups },
601
602	{ "umask", lc_umask },
603
604	{ "mkdir", lc_mkdir },
605
606	{ "setrlimit", lc_setrlimit },
607	{ "getrlimit", lc_getrlimit },
608
609	{ "uname", lc_uname },
610
611	{ NULL, NULL }
612	};
613
614	luaL_register(L, "pposix", exports);
615
616	lua_pushliteral(L, "pposix");
617	lua_setfield(L, -2, "_NAME");
618
619	lua_pushliteral(L, MODULE_VERSION);
620	lua_setfield(L, -2, "_VERSION");
621
622	return 1;
623	}