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