cgi-bin/tek/posix.c
author tmueller@vstst.herrje.net
Mon, 12 Feb 2007 02:14:11 +0100
changeset 0 d4b36cfa50e8
child 18 88c92f1a3a96
permissions -rw-r--r--
initial import
tmueller@0
     1
tmueller@0
     2
#include <stdlib.h>
tmueller@0
     3
#include <string.h>
tmueller@0
     4
#include <sys/types.h>
tmueller@0
     5
#include <sys/stat.h>
tmueller@0
     6
#include <unistd.h>
tmueller@0
     7
#include <dirent.h>
tmueller@0
     8
#include <errno.h>
tmueller@0
     9
#include <lua.h>
tmueller@0
    10
#include <lualib.h>
tmueller@0
    11
#include <lauxlib.h>
tmueller@0
    12
tmueller@0
    13
tmueller@0
    14
#define DIRCLASSNAME "dir*"
tmueller@0
    15
tmueller@0
    16
tmueller@0
    17
static void
tmueller@0
    18
setfield(lua_State *L, const char *attr, const char *key, lua_Integer n)
tmueller@0
    19
{
tmueller@0
    20
	if (attr == NULL || strcmp(attr, key) == 0)
tmueller@0
    21
		lua_pushinteger(L, n);
tmueller@0
    22
	if (attr == NULL)
tmueller@0
    23
		lua_setfield(L, -2, key);
tmueller@0
    24
}
tmueller@0
    25
tmueller@0
    26
static int
tmueller@0
    27
setstat(lua_State *L, int result, struct stat *s, const char *attr)
tmueller@0
    28
{
tmueller@0
    29
	if (result != 0)
tmueller@0
    30
	{
tmueller@0
    31
		lua_pushnil(L);
tmueller@0
    32
		lua_pushstring(L, strerror(errno));
tmueller@0
    33
		return 2;
tmueller@0
    34
	}
tmueller@0
    35
tmueller@0
    36
	if (attr == NULL)
tmueller@0
    37
		lua_newtable(L);
tmueller@0
    38
		
tmueller@0
    39
	setfield(L, attr, "dev", s->st_dev);
tmueller@0
    40
	setfield(L, attr, "ino", s->st_ino);
tmueller@0
    41
	
tmueller@0
    42
	if (attr == NULL || strcmp(attr, "mode") == 0)
tmueller@0
    43
	{
tmueller@0
    44
		if (S_ISREG(s->st_mode))
tmueller@0
    45
			lua_pushstring(L, "file");
tmueller@0
    46
		else if (S_ISDIR(s->st_mode))
tmueller@0
    47
			lua_pushstring(L, "directory");
tmueller@0
    48
		else if (S_ISLNK(s->st_mode))
tmueller@0
    49
			lua_pushstring(L, "link");
tmueller@0
    50
		else if (S_ISSOCK(s->st_mode))
tmueller@0
    51
			lua_pushstring(L, "socket");
tmueller@0
    52
		else if (S_ISFIFO(s->st_mode))
tmueller@0
    53
			lua_pushstring(L, "named pipe");
tmueller@0
    54
		else if (S_ISCHR(s->st_mode))
tmueller@0
    55
			lua_pushstring(L, "char device");
tmueller@0
    56
		else if (S_ISBLK(s->st_mode))
tmueller@0
    57
			lua_pushstring(L, "block device");
tmueller@0
    58
		else
tmueller@0
    59
			lua_pushstring(L, "other");
tmueller@0
    60
		if (attr == NULL)
tmueller@0
    61
			lua_setfield(L, -2, "mode");
tmueller@0
    62
	}
tmueller@0
    63
	
tmueller@0
    64
	setfield(L, attr, "nlink", s->st_nlink);
tmueller@0
    65
	setfield(L, attr, "uid", s->st_uid);
tmueller@0
    66
	setfield(L, attr, "gid", s->st_gid);
tmueller@0
    67
	setfield(L, attr, "rdev", s->st_rdev);
tmueller@0
    68
	setfield(L, attr, "access", s->st_atime);
tmueller@0
    69
	setfield(L, attr, "modifications", s->st_mtime);
tmueller@0
    70
	setfield(L, attr, "change", s->st_ctime);
tmueller@0
    71
	setfield(L, attr, "size", s->st_ctime);
tmueller@0
    72
	setfield(L, attr, "blocks", s->st_blocks);
tmueller@0
    73
	setfield(L, attr, "blksize", s->st_blksize);
tmueller@0
    74
	
tmueller@0
    75
	return 1;
tmueller@0
    76
}
tmueller@0
    77
tmueller@0
    78
tmueller@0
    79
static int 
tmueller@0
    80
posix_stat(lua_State *L)
tmueller@0
    81
{
tmueller@0
    82
	const char *path = luaL_checkstring(L, 1);
tmueller@0
    83
	const char *attr = luaL_optstring(L, 2, NULL);
tmueller@0
    84
	struct stat s;
tmueller@0
    85
	return setstat(L, stat(path, &s), &s, attr);
tmueller@0
    86
}	
tmueller@0
    87
tmueller@0
    88
tmueller@0
    89
static int 
tmueller@0
    90
posix_lstat(lua_State *L)
tmueller@0
    91
{
tmueller@0
    92
	const char *path = luaL_checkstring(L, 1);
tmueller@0
    93
	const char *attr = luaL_optstring(L, 2, NULL);
tmueller@0
    94
	struct stat s;
tmueller@0
    95
	return setstat(L, lstat(path, &s), &s, attr);
tmueller@0
    96
}
tmueller@0
    97
tmueller@0
    98
tmueller@0
    99
static int 
tmueller@0
   100
posix_opendir(lua_State *L)
tmueller@0
   101
{
tmueller@0
   102
	const char *path = luaL_checkstring(L, 1);
tmueller@0
   103
	DIR **pdir = lua_newuserdata(L, sizeof(void *));
tmueller@0
   104
	*pdir = NULL;
tmueller@0
   105
	lua_pushvalue(L, lua_upvalueindex(2)); /* class metatable */
tmueller@0
   106
	/* attach metatable to the userdata object */
tmueller@0
   107
	lua_setmetatable(L, -2); /* s: udata */
tmueller@0
   108
	/* create class instance */
tmueller@0
   109
	*pdir = opendir(path);
tmueller@0
   110
	if (*pdir == NULL)
tmueller@0
   111
	{
tmueller@0
   112
		lua_pushnil(L);
tmueller@0
   113
		lua_pushstring(L, strerror(errno));
tmueller@0
   114
		return 2;
tmueller@0
   115
	}
tmueller@0
   116
	return 1;
tmueller@0
   117
}
tmueller@0
   118
tmueller@0
   119
tmueller@0
   120
static DIR **
tmueller@0
   121
getinstptr(lua_State *L, int narg, const char *classname)
tmueller@0
   122
{
tmueller@0
   123
	DIR **pinst = luaL_checkudata(L, narg, classname);
tmueller@0
   124
	if (*pinst) return pinst;
tmueller@0
   125
	luaL_argerror(L, narg, "Closed handle");
tmueller@0
   126
	return NULL;
tmueller@0
   127
}
tmueller@0
   128
tmueller@0
   129
tmueller@0
   130
static int 
tmueller@0
   131
posix_closedir(lua_State *L)
tmueller@0
   132
{
tmueller@0
   133
	DIR **pdir = getinstptr(L, 1, DIRCLASSNAME);
tmueller@0
   134
	closedir(*pdir);
tmueller@0
   135
	*pdir = NULL;
tmueller@0
   136
	return 0;
tmueller@0
   137
}
tmueller@0
   138
tmueller@0
   139
tmueller@0
   140
static int 
tmueller@0
   141
posix_readdir(lua_State *L)
tmueller@0
   142
{
tmueller@0
   143
	DIR *dir = *getinstptr(L, 1, DIRCLASSNAME);
tmueller@0
   144
	struct dirent *de = readdir(dir);
tmueller@0
   145
	if (de)
tmueller@0
   146
		lua_pushstring(L, de->d_name);
tmueller@0
   147
	else
tmueller@0
   148
		lua_pushnil(L);
tmueller@0
   149
	return 1;
tmueller@0
   150
}
tmueller@0
   151
tmueller@0
   152
tmueller@0
   153
static int 
tmueller@0
   154
posix_readlink(lua_State *L)
tmueller@0
   155
{
tmueller@0
   156
	const char *path = luaL_checkstring(L, 1);
tmueller@0
   157
	char buf[PATH_MAX + 1];
tmueller@0
   158
	ssize_t len = readlink(path, buf, sizeof(buf) - 1);
tmueller@0
   159
	if (len < 0)
tmueller@0
   160
	{
tmueller@0
   161
		lua_pushnil(L);
tmueller@0
   162
		lua_pushstring(L, strerror(errno));
tmueller@0
   163
		return 2;
tmueller@0
   164
	}
tmueller@0
   165
	buf[len] = 0;
tmueller@0
   166
	lua_pushstring(L, buf);
tmueller@0
   167
	return 1;
tmueller@0
   168
}
tmueller@0
   169
tmueller@0
   170
tmueller@0
   171
static int 
tmueller@0
   172
posix_mkdir(lua_State *L)
tmueller@0
   173
{
tmueller@0
   174
	const char *path = luaL_checkstring(L, 1);
tmueller@0
   175
	if (mkdir(path, 0775) == 0)
tmueller@0
   176
	{
tmueller@0
   177
		lua_pushboolean(L, 1);
tmueller@0
   178
		return 1;
tmueller@0
   179
	}
tmueller@0
   180
	lua_pushnil(L);
tmueller@0
   181
	lua_pushstring(L, strerror(errno));
tmueller@0
   182
	return 2;
tmueller@0
   183
}
tmueller@0
   184
tmueller@0
   185
tmueller@0
   186
static int 
tmueller@0
   187
posix_symlink(lua_State *L)
tmueller@0
   188
{
tmueller@0
   189
	const char *oldpath = luaL_checkstring(L, 1);
tmueller@0
   190
	const char *newpath = luaL_checkstring(L, 2);
tmueller@0
   191
	if (symlink(oldpath, newpath) == 0)
tmueller@0
   192
	{
tmueller@0
   193
		lua_pushboolean(L, 1);
tmueller@0
   194
		return 1;
tmueller@0
   195
	}
tmueller@0
   196
	lua_pushnil(L);
tmueller@0
   197
	lua_pushstring(L, strerror(errno));
tmueller@0
   198
	return 2;
tmueller@0
   199
}
tmueller@0
   200
tmueller@0
   201
tmueller@0
   202
/*
tmueller@0
   203
**	POSIX realpath() is broken. We can do better
tmueller@0
   204
*/
tmueller@0
   205
tmueller@0
   206
static int
tmueller@0
   207
resolvepath(const char *src, char *dest)
tmueller@0
   208
{
tmueller@0
   209
	int len = strlen(src);
tmueller@0
   210
	const char *sp = src + len;
tmueller@0
   211
	char *dp = dest;
tmueller@0
   212
	int dc = 0, slc = 0, eac = 0, wc = 0;
tmueller@0
   213
	int i, c;
tmueller@0
   214
	
tmueller@0
   215
	while (len--)	
tmueller@0
   216
	{
tmueller@0
   217
		c = *(--sp);
tmueller@0
   218
		switch (c)
tmueller@0
   219
		{
tmueller@0
   220
			case '/':
tmueller@0
   221
				if (dc == 2)
tmueller@0
   222
					eac++;
tmueller@0
   223
				dc = 0;
tmueller@0
   224
				slc = 1;
tmueller@0
   225
				wc = 0;
tmueller@0
   226
				break;
tmueller@0
   227
tmueller@0
   228
			case '.':
tmueller@0
   229
				if (slc)
tmueller@0
   230
				{
tmueller@0
   231
					dc++;
tmueller@0
   232
					break;
tmueller@0
   233
				}
tmueller@0
   234
				/* fallthru: */
tmueller@0
   235
tmueller@0
   236
			default:
tmueller@0
   237
				if (wc)
tmueller@0
   238
					break;
tmueller@0
   239
			
tmueller@0
   240
				if (slc)
tmueller@0
   241
				{
tmueller@0
   242
					slc = 0;
tmueller@0
   243
					
tmueller@0
   244
					if (eac > 0)
tmueller@0
   245
					{
tmueller@0
   246
						/* resolve one eatcount */
tmueller@0
   247
						eac--;
tmueller@0
   248
						/* now wait for next path part */
tmueller@0
   249
						wc = 1;
tmueller@0
   250
						break;
tmueller@0
   251
					}
tmueller@0
   252
					
tmueller@0
   253
					*dp++ = '/';
tmueller@0
   254
				}
tmueller@0
   255
				
tmueller@0
   256
				while (dc == 2 || dc == 1)
tmueller@0
   257
				{
tmueller@0
   258
					*dp++ = '.';
tmueller@0
   259
					dc--;
tmueller@0
   260
				}
tmueller@0
   261
				dc = 0;
tmueller@0
   262
				
tmueller@0
   263
				*dp++ = c;
tmueller@0
   264
				break;
tmueller@0
   265
		}
tmueller@0
   266
	}
tmueller@0
   267
	
tmueller@0
   268
	/* unresolved eatcount */
tmueller@0
   269
	if (eac)
tmueller@0
   270
		return 0;
tmueller@0
   271
	
tmueller@0
   272
	/* resolve remaining slash */
tmueller@0
   273
	if (slc)
tmueller@0
   274
		*dp++ = '/';
tmueller@0
   275
	
tmueller@0
   276
	*dp = 0;
tmueller@0
   277
	
tmueller@0
   278
	len = dp - dest;
tmueller@0
   279
	for (i = 0; i < len / 2; ++i)
tmueller@0
   280
	{
tmueller@0
   281
		char t = dest[i];
tmueller@0
   282
		dest[i] = dest[len - i - 1]; 
tmueller@0
   283
		dest[len - i - 1] = t;
tmueller@0
   284
	}
tmueller@0
   285
tmueller@0
   286
	return 1;
tmueller@0
   287
}
tmueller@0
   288
tmueller@0
   289
tmueller@0
   290
static int 
tmueller@0
   291
posix_abspath(lua_State *L)
tmueller@0
   292
{
tmueller@0
   293
	const char *path = luaL_checkstring(L, 1);
tmueller@0
   294
	char *pwd = NULL;
tmueller@0
   295
	size_t pwdsize = 16;
tmueller@0
   296
	
tmueller@0
   297
	for (;;)
tmueller@0
   298
	{
tmueller@0
   299
		char *newpwd = realloc(pwd, pwdsize);
tmueller@0
   300
		if (newpwd == NULL)
tmueller@0
   301
			break;
tmueller@0
   302
		
tmueller@0
   303
		pwd = newpwd;
tmueller@0
   304
		if (getcwd(pwd, pwdsize))
tmueller@0
   305
		{
tmueller@0
   306
			size_t len1 = strlen(pwd);
tmueller@0
   307
			size_t len2 = strlen(path);
tmueller@0
   308
			char *srcpath = malloc(len1 + 1 + len2 + 1);
tmueller@0
   309
			char *dstpath = malloc(len1 + 1 + len2 + 1);
tmueller@0
   310
			if (srcpath && dstpath)
tmueller@0
   311
			{
tmueller@0
   312
				int res;
tmueller@0
   313
				
tmueller@0
   314
				strcpy(srcpath, pwd);
tmueller@0
   315
				free(pwd);
tmueller@0
   316
				srcpath[len1] = '/';
tmueller@0
   317
				strcpy(srcpath + len1 + 1, path);
tmueller@0
   318
				res = resolvepath(srcpath, dstpath);
tmueller@0
   319
				free(srcpath);
tmueller@0
   320
				
tmueller@0
   321
				if (res)
tmueller@0
   322
				{
tmueller@0
   323
					lua_pushstring(L, dstpath);
tmueller@0
   324
					free(dstpath);
tmueller@0
   325
					return 1;			
tmueller@0
   326
				}
tmueller@0
   327
				
tmueller@0
   328
				free(dstpath);
tmueller@0
   329
				lua_pushnil(L);
tmueller@0
   330
				lua_pushstring(L, "Not a valid path");
tmueller@0
   331
				return 2;
tmueller@0
   332
			}
tmueller@0
   333
			
tmueller@0
   334
			free(srcpath);
tmueller@0
   335
			free(dstpath);
tmueller@0
   336
			break;
tmueller@0
   337
		}
tmueller@0
   338
		
tmueller@0
   339
		if (errno == ERANGE)
tmueller@0
   340
		{
tmueller@0
   341
			pwdsize <<= 1;
tmueller@0
   342
			continue;
tmueller@0
   343
		}
tmueller@0
   344
		
tmueller@0
   345
		lua_pushnil(L);
tmueller@0
   346
		lua_pushstring(L, strerror(errno));
tmueller@0
   347
		return 2;
tmueller@0
   348
	}
tmueller@0
   349
	
tmueller@0
   350
	free(pwd);
tmueller@0
   351
	luaL_error(L, "Out of memory");
tmueller@0
   352
	return 0;
tmueller@0
   353
}
tmueller@0
   354
tmueller@0
   355
tmueller@0
   356
static const luaL_Reg lib[] =
tmueller@0
   357
{
tmueller@0
   358
	{ "stat", posix_stat },
tmueller@0
   359
	{ "lstat", posix_lstat },
tmueller@0
   360
	{ "opendir", posix_opendir },
tmueller@0
   361
	{ "closedir", posix_closedir },
tmueller@0
   362
	{ "readdir", posix_readdir },
tmueller@0
   363
	{ "mkdir", posix_mkdir },
tmueller@0
   364
	{ "readlink", posix_readlink },
tmueller@0
   365
	{ "symlink", posix_symlink },
tmueller@0
   366
	{ "abspath", posix_abspath },
tmueller@0
   367
	{ NULL, NULL }
tmueller@0
   368
};
tmueller@0
   369
tmueller@0
   370
tmueller@0
   371
static const luaL_Reg methods[] =
tmueller@0
   372
{
tmueller@0
   373
	{"read", posix_readdir },
tmueller@0
   374
	{"close", posix_closedir },
tmueller@0
   375
	{"__gc", posix_closedir },
tmueller@0
   376
	{NULL, NULL}
tmueller@0
   377
};
tmueller@0
   378
tmueller@0
   379
tmueller@0
   380
static void
tmueller@0
   381
addclass(lua_State *L, const char *libname, const char *classname,
tmueller@0
   382
	luaL_Reg *functions, luaL_Reg *methods, void *userdata)
tmueller@0
   383
{
tmueller@0
   384
	luaL_newmetatable(L, classname);		/* classtab */
tmueller@0
   385
	lua_pushliteral(L, "__index");			/* classtab, "__index" */
tmueller@0
   386
tmueller@0
   387
	/* insert self: classtab.__index = classtab */
tmueller@0
   388
	lua_pushvalue(L, -2);					/* classtab, "__index", classtab */
tmueller@0
   389
	lua_rawset(L, -3);						/* classtab */
tmueller@0
   390
tmueller@0
   391
	/* insert methods. consume 1 userdata. do not create a new tab */
tmueller@0
   392
	lua_pushlightuserdata(L, userdata);		/* classtab, userdata */
tmueller@0
   393
	luaL_openlib(L, NULL, methods, 1);		/* classtab */
tmueller@0
   394
tmueller@0
   395
	/* first upvalue: userdata */
tmueller@0
   396
	lua_pushlightuserdata(L, userdata);		/* classtab, userdata */
tmueller@0
   397
tmueller@0
   398
	/* duplicate table argument to be used as second upvalue for cclosure */
tmueller@0
   399
	lua_pushvalue(L, -2);					/* classtab, userdata, classtab */
tmueller@0
   400
tmueller@0
   401
	/* insert functions */
tmueller@0
   402
	luaL_openlib(L, libname, functions, 2);	/* classtab, libtab */
tmueller@0
   403
tmueller@0
   404
	/* adjust stack */	
tmueller@0
   405
	lua_pop(L, 2);	
tmueller@0
   406
}
tmueller@0
   407
tmueller@0
   408
tmueller@0
   409
int luaopen_tek_posix(lua_State *L)
tmueller@0
   410
{
tmueller@0
   411
	addclass(L, "tek.posix", DIRCLASSNAME,
tmueller@0
   412
		(luaL_Reg *) lib, (luaL_Reg *) methods, NULL);
tmueller@0
   413
	return 0;
tmueller@0
   414
}