lfs.c File Reference

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <fcntl.h>
#include <sys/types.h>
#include <utime.h>
#include <sys/param.h>
#include <limits.h>
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#include "lfs.h"

Go to the source code of this file.

Data Structures
struct	dir_data
struct	lfs_Lock
struct	_stat_members

Macros
#define	_FILE_OFFSET_BITS   64 /* Linux, Solaris and HP-UX */
#define	_LARGEFILE64_SOURCE
#define	LFS_MAXPATHLEN   _POSIX_PATH_MAX
#define	LFS_VERSION   "1.8.0"
#define	LFS_LIBNAME   "lfs"
#define	new_lib(L, l)   (lua_newtable(L), luaL_register(L, NULL, l))
#define	DIR_METATABLE   "directory metatable"
#define	LOCK_METATABLE   "lock metatable"
#define	_O_TEXT   0
#define	_O_BINARY   0
#define	lfs_setmode(file, m)   ((void)file, (void)m, 0)
#define	STAT_STRUCT   struct stat
#define	STAT_FUNC   stat
#define	LSTAT_FUNC   lstat
#define	lfs_mkdir(path)

Typedefs
typedef struct dir_data	dir_data
typedef struct lfs_Lock	lfs_Lock
typedef void(*	_push_function) (lua_State *L, STAT_STRUCT *info)

Functions
static int	pusherror (lua_State *L, const char *info)
static int	pushresult (lua_State *L, int res, const char *info)
static int	change_dir (lua_State *L)
static int	get_dir (lua_State *L)
static FILE *	check_file (lua_State *L, int idx, const char *funcname)
static int	_file_lock (lua_State *L, FILE *fh, const char *mode, const long start, long len, const char *funcname)
static int	lfs_lock_dir (lua_State *L)
static int	lfs_unlock_dir (lua_State *L)
static int	lfs_g_setmode (lua_State *L, FILE *f, int arg)
static int	lfs_f_setmode (lua_State *L)
static int	file_lock (lua_State *L)
static int	file_unlock (lua_State *L)
static int	make_link (lua_State *L)
static int	make_dir (lua_State *L)
static int	remove_dir (lua_State *L)
static int	dir_iter (lua_State *L)
static int	dir_close (lua_State *L)
static int	dir_iter_factory (lua_State *L)
static int	dir_create_meta (lua_State *L)
static int	lock_create_meta (lua_State *L)
static const char *	mode2string (mode_t mode)
static int	file_utime (lua_State *L)
static void	push_st_mode (lua_State *L, STAT_STRUCT *info)
static void	push_st_dev (lua_State *L, STAT_STRUCT *info)
static void	push_st_ino (lua_State *L, STAT_STRUCT *info)
static void	push_st_nlink (lua_State *L, STAT_STRUCT *info)
static void	push_st_uid (lua_State *L, STAT_STRUCT *info)
static void	push_st_gid (lua_State *L, STAT_STRUCT *info)
static void	push_st_rdev (lua_State *L, STAT_STRUCT *info)
static void	push_st_atime (lua_State *L, STAT_STRUCT *info)
static void	push_st_mtime (lua_State *L, STAT_STRUCT *info)
static void	push_st_ctime (lua_State *L, STAT_STRUCT *info)
static void	push_st_size (lua_State *L, STAT_STRUCT *info)
static void	push_st_blocks (lua_State *L, STAT_STRUCT *info)
static void	push_st_blksize (lua_State *L, STAT_STRUCT *info)
static const char *	perm2string (mode_t mode)
static void	push_st_perm (lua_State *L, STAT_STRUCT *info)
static int	_file_info_ (lua_State *L, int(*st)(const char *, STAT_STRUCT *))
static int	file_info (lua_State *L)
static int	push_link_target (lua_State *L)
static int	link_info (lua_State *L)
static void	set_info (lua_State *L)
LFS_EXPORT int	luaopen_lfs (lua_State *L)

Variables
struct _stat_members	members []
static const struct luaL_Reg	fslib []

Macro Definition Documentation

_FILE_OFFSET_BITS

#define _FILE_OFFSET_BITS   64 /* Linux, Solaris and HP-UX */

Definition at line 26 of file lfs.c.

_LARGEFILE64_SOURCE

#define _LARGEFILE64_SOURCE

Definition at line 38 of file lfs.c.

_O_BINARY

#define _O_BINARY   0

Definition at line 167 of file lfs.c.

Referenced by lfs_g_setmode().

_O_TEXT

#define _O_TEXT   0

Definition at line 166 of file lfs.c.

Referenced by lfs_g_setmode().

DIR_METATABLE

#define DIR_METATABLE   "directory metatable"

Definition at line 112 of file lfs.c.

Referenced by dir_create_meta(), dir_iter(), and dir_iter_factory().

LFS_LIBNAME

#define LFS_LIBNAME   "lfs"

Definition at line 91 of file lfs.c.

Referenced by luaopen_lfs().

LFS_MAXPATHLEN

#define LFS_MAXPATHLEN   _POSIX_PATH_MAX

Definition at line 79 of file lfs.c.

Referenced by get_dir().

lfs_mkdir

#define lfs_mkdir

(

path

)

Value:

    (mkdir((path), \
    S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH))

Definition at line 178 of file lfs.c.

#define lfs_mkdir(path) (mkdir((path), \
    S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH))

Referenced by make_dir().

lfs_setmode

#define lfs_setmode	(		file,
			m )   ((void)file, (void)m, 0)

Definition at line 168 of file lfs.c.

Referenced by lfs_g_setmode().

LFS_VERSION

#define LFS_VERSION   "1.8.0"

Definition at line 90 of file lfs.c.

Referenced by set_info().

LOCK_METATABLE

#define LOCK_METATABLE   "lock metatable"

Definition at line 123 of file lfs.c.

Referenced by lfs_lock_dir(), lfs_unlock_dir(), and lock_create_meta().

LSTAT_FUNC

#define LSTAT_FUNC   lstat

Definition at line 171 of file lfs.c.

Referenced by link_info().

new_lib

#define new_lib	(		L,
			l )   (lua_newtable(L), luaL_register(L, NULL, l))

Definition at line 104 of file lfs.c.

Referenced by luaopen_lfs().

STAT_FUNC

#define STAT_FUNC   stat

Definition at line 170 of file lfs.c.

Referenced by file_info(), and make_link().

STAT_STRUCT

#define STAT_STRUCT   struct stat

Definition at line 169 of file lfs.c.

Referenced by _file_info_(), and make_link().

Typedef Documentation

_push_function

typedef void(* _push_function) (lua_State *L, STAT_STRUCT *info)

Definition at line 980 of file lfs.c.

dir_data

typedef struct dir_data dir_data

lfs_Lock

typedef struct lfs_Lock lfs_Lock

Function Documentation

_file_info_()

static int _file_info_ ( lua_State * L, int(*)(const char *, STAT_STRUCT *) st )

static

Definition at line 1010 of file lfs.c.

{
  STAT_STRUCT info;
  const char *file = luaL_checkstring(L, 1);
  int i;
 
  if (st(file, &info)) {
    lua_pushnil(L);
    lua_pushfstring(L, "cannot obtain information from file '%s': %s",
                    file, strerror(errno));
    lua_pushinteger(L, errno);
    return 3;
  }
  if (lua_isstring(L, 2)) {
    const char *member = lua_tostring(L, 2);
    for (i = 0; members[i].name; i++) {
      if (strcmp(members[i].name, member) == 0) {
        /* push member value and return */
        members[i].push(L, &info);
        return 1;
      }
    }
    /* member not found */
    return luaL_error(L, "invalid attribute name '%s'", member);
  }
  /* creates a table if none is given, removes extra arguments */
  lua_settop(L, 2);
  if (!lua_istable(L, 2)) {
    lua_newtable(L);
  }
  /* stores all members in table on top of the stack */
  for (i = 0; members[i].name; i++) {
    lua_pushstring(L, members[i].name);
    members[i].push(L, &info);
    lua_rawset(L, -3);
  }
  return 1;
}

References lua_isstring(), lua_istable, lua_newtable, lua_pushfstring(), lua_pushinteger(), lua_pushnil(), lua_pushstring(), lua_rawset(), lua_settop(), lua_tostring, luaL_checkstring, luaL_error(), members, _stat_members::name, name, _stat_members::push, and STAT_STRUCT.

Referenced by file_info(), and link_info().

_file_lock()

static int _file_lock ( lua_State * L, FILE * fh, const char * mode, const long start, long len, const char * funcname )

static

Definition at line 343 of file lfs.c.

{
  int code;
#ifdef _WIN32
  /* lkmode valid values are:
     LK_LOCK    Locks the specified bytes. If the bytes cannot be locked,
     the program immediately tries again after 1 second.
     If, after 10 attempts, the bytes cannot be locked,
     the constant returns an error.
     LK_NBLCK   Locks the specified bytes. If the bytes cannot be locked,
     the constant returns an error.
     LK_NBRLCK  Same as _LK_NBLCK.
     LK_RLCK    Same as _LK_LOCK.
     LK_UNLCK   Unlocks the specified bytes, which must have been
     previously locked.
 
     Regions should be locked only briefly and should be unlocked
     before closing a file or exiting the program.
 
     http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt__locking.asp
   */
  int lkmode;
  switch (*mode) {
  case 'r':
    lkmode = LK_NBLCK;
    break;
  case 'w':
    lkmode = LK_NBLCK;
    break;
  case 'u':
    lkmode = LK_UNLCK;
    break;
  default:
    return luaL_error(L, "%s: invalid mode", funcname);
  }
  if (!len) {
    fseek(fh, 0L, SEEK_END);
    len = ftell(fh);
  }
  fseek(fh, start, SEEK_SET);
#ifdef __BORLANDC__
  code = locking(fileno(fh), lkmode, len);
#else
  code = _locking(fileno(fh), lkmode, len);
#endif
#else
  struct flock f;
  switch (*mode) {
  case 'w':
    f.l_type = F_WRLCK;
    break;
  case 'r':
    f.l_type = F_RDLCK;
    break;
  case 'u':
    f.l_type = F_UNLCK;
    break;
  default:
    return luaL_error(L, "%s: invalid mode", funcname);
  }
  f.l_whence = SEEK_SET;
  f.l_start = (off_t) start;
  f.l_len = (off_t) len;
  code = fcntl(fileno(fh), F_SETLK, &f);
#endif
  return (code != -1);
}

References funcname(), and luaL_error().

Referenced by file_lock(), and file_unlock().

change_dir()

static int change_dir ( lua_State * L )

static

Definition at line 259 of file lfs.c.

{
  const char *path = luaL_checkstring(L, 1);
  if (chdir(path)) {
    lua_pushnil(L);
    lua_pushfstring(L, "Unable to change working directory to '%s'\n%s\n",
                    path, chdir_error);
    return 2;
  } else {
    lua_pushboolean(L, 1);
    return 1;
  }
}

References chdir_error, lua_pushboolean(), lua_pushfstring(), lua_pushnil(), and luaL_checkstring.

check_file()

static FILE * check_file ( lua_State * L, int idx, const char * funcname )

static

Definition at line 318 of file lfs.c.

{
#if LUA_VERSION_NUM == 501
  FILE **fh = (FILE **) luaL_checkudata(L, idx, "FILE*");
  if (*fh == NULL) {
    luaL_error(L, "%s: closed file", funcname);
    return 0;
  } else
    return *fh;
#elif LUA_VERSION_NUM >= 502 && LUA_VERSION_NUM <= 504
  luaL_Stream *fh = (luaL_Stream *) luaL_checkudata(L, idx, "FILE*");
  if (fh->closef == 0 || fh->f == NULL) {
    luaL_error(L, "%s: closed file", funcname);
    return 0;
  } else
    return fh->f;
#else
#error unsupported Lua version
#endif
}

References funcname(), luaL_checkudata(), luaL_error(), and NULL.

Referenced by file_lock(), file_unlock(), and lfs_f_setmode().

dir_close()

static int dir_close ( lua_State * L )

static

Definition at line 688 of file lfs.c.

{
  dir_data *d = (dir_data *) lua_touserdata(L, 1);
#ifdef _WIN32
  if (!d->closed && d->hFile) {
    _findclose(d->hFile);
  }
#else
  if (!d->closed && d->dir) {
    closedir(d->dir);
  }
#endif
  d->closed = 1;
  return 0;
}

References dir_data::closed, dir_data::dir, and lua_touserdata().

Referenced by dir_create_meta().

dir_create_meta()

static int dir_create_meta ( lua_State * L )

static

Definition at line 741 of file lfs.c.

{
  luaL_newmetatable(L, DIR_METATABLE);
 
  /* Method table */
  lua_newtable(L);
  lua_pushcfunction(L, dir_iter);
  lua_setfield(L, -2, "next");
  lua_pushcfunction(L, dir_close);
  lua_setfield(L, -2, "close");
 
  /* Metamethods */
  lua_setfield(L, -2, "__index");
  lua_pushcfunction(L, dir_close);
  lua_setfield(L, -2, "__gc");
 
#if LUA_VERSION_NUM >= 504
  lua_pushcfunction(L, dir_close);
  lua_setfield(L, -2, "__close");
#endif
  return 1;
}

References dir_close(), dir_iter(), DIR_METATABLE, lua_newtable, lua_pushcfunction, lua_setfield(), and luaL_newmetatable().

Referenced by luaopen_lfs().

dir_iter()

static int dir_iter ( lua_State * L )

static

Definition at line 640 of file lfs.c.

{
#ifdef _WIN32
  struct _finddata_t c_file;
#else
  struct dirent *entry;
#endif
  dir_data *d = (dir_data *) luaL_checkudata(L, 1, DIR_METATABLE);
  luaL_argcheck(L, d->closed == 0, 1, "closed directory");
#ifdef _WIN32
  if (d->hFile == 0L) {         /* first entry */
    if ((d->hFile = _findfirst(d->pattern, &c_file)) == -1L) {
      lua_pushnil(L);
      lua_pushstring(L, strerror(errno));
      d->closed = 1;
      return 2;
    } else {
      lua_pushstring(L, c_file.name);
      return 1;
    }
  } else {                      /* next entry */
    if (_findnext(d->hFile, &c_file) == -1L) {
      /* no more entries => close directory */
      _findclose(d->hFile);
      d->closed = 1;
      return 0;
    } else {
      lua_pushstring(L, c_file.name);
      return 1;
    }
  }
#else
  if ((entry = readdir(d->dir)) != NULL) {
    lua_pushstring(L, entry->d_name);
    return 1;
  } else {
    /* no more entries => close directory */
    closedir(d->dir);
    d->closed = 1;
    return 0;
  }
#endif
}

References dir_data::closed, dir_data::dir, DIR_METATABLE, lua_pushnil(), lua_pushstring(), luaL_argcheck, luaL_checkudata(), and NULL.

Referenced by dir_create_meta(), and dir_iter_factory().

dir_iter_factory()

static int dir_iter_factory ( lua_State * L )

static

Definition at line 708 of file lfs.c.

{
  const char *path = luaL_checkstring(L, 1);
  dir_data *d;
  lua_pushcfunction(L, dir_iter);
  d = (dir_data *) lua_newuserdata(L, sizeof(dir_data));
  luaL_getmetatable(L, DIR_METATABLE);
  lua_setmetatable(L, -2);
  d->closed = 0;
#ifdef _WIN32
  d->hFile = 0L;
  if (strlen(path) > MAX_PATH - 2)
    luaL_error(L, "path too long: %s", path);
  else
    sprintf(d->pattern, "%s/*", path);
#else
  d->dir = opendir(path);
  if (d->dir == NULL)
    luaL_error(L, "cannot open %s: %s", path, strerror(errno));
#endif
#if LUA_VERSION_NUM >= 504
  lua_pushnil(L);
  lua_pushvalue(L, -2);
  return 4;
#else
  return 2;
#endif
}

References dir_data::closed, dir_data::dir, dir_iter(), DIR_METATABLE, lua_newuserdata, lua_pushcfunction, lua_pushnil(), lua_pushvalue(), lua_setmetatable(), luaL_checkstring, luaL_error(), luaL_getmetatable, and NULL.

file_info()

static int file_info ( lua_State * L )

static

Definition at line 1054 of file lfs.c.

{
  return _file_info_(L, STAT_FUNC);
}

References _file_info_(), and STAT_FUNC.

file_lock()

static int file_lock ( lua_State * L )

static

Definition at line 532 of file lfs.c.

{
  FILE *fh = check_file(L, 1, "lock");
  const char *mode = luaL_checkstring(L, 2);
  const long start = (long) luaL_optinteger(L, 3, 0);
  long len = (long) luaL_optinteger(L, 4, 0);
  if (_file_lock(L, fh, mode, start, len, "lock")) {
    lua_pushboolean(L, 1);
    return 1;
  } else {
    lua_pushnil(L);
    lua_pushfstring(L, "%s", strerror(errno));
    return 2;
  }
}

References _file_lock(), check_file(), lua_pushboolean(), lua_pushfstring(), lua_pushnil(), luaL_checkstring, and luaL_optinteger().

file_unlock()

static int file_unlock ( lua_State * L )

static

Definition at line 555 of file lfs.c.

{
  FILE *fh = check_file(L, 1, "unlock");
  const long start = (long) luaL_optinteger(L, 2, 0);
  long len = (long) luaL_optinteger(L, 3, 0);
  if (_file_lock(L, fh, "u", start, len, "unlock")) {
    lua_pushboolean(L, 1);
    return 1;
  } else {
    lua_pushnil(L);
    lua_pushfstring(L, "%s", strerror(errno));
    return 2;
  }
}

References _file_lock(), check_file(), lua_pushboolean(), lua_pushfstring(), lua_pushnil(), and luaL_optinteger().

file_utime()

static int file_utime ( lua_State * L )

static

Definition at line 820 of file lfs.c.

{
  const char *file = luaL_checkstring(L, 1);
  struct utimbuf utb, *buf;
 
  if (lua_gettop(L) == 1)       /* set to current date/time */
    buf = NULL;
  else {
    utb.actime = (time_t) luaL_optnumber(L, 2, 0);
    utb.modtime = (time_t) luaL_optinteger(L, 3, utb.actime);
    buf = &utb;
  }
 
  return pushresult(L, utime(file, buf), NULL);
}

References lua_gettop(), luaL_checkstring, luaL_optinteger(), luaL_optnumber(), NULL, and pushresult().

get_dir()

static int get_dir ( lua_State * L )

static

Definition at line 278 of file lfs.c.

{
#ifdef NO_GETCWD
  lua_pushnil(L);
  lua_pushstring(L, "Function 'getcwd' not provided by system");
  return 2;
#else
  char *path = NULL;
  /* Passing (NULL, 0) is not guaranteed to work.
     Use a temp buffer and size instead. */
  size_t size = LFS_MAXPATHLEN; /* initial buffer size */
  int result;
  while (1) {
    char *path2 = realloc(path, size);
    if (!path2) {               /* failed to allocate */
      result = pusherror(L, "get_dir realloc() failed");
      break;
    }
    path = path2;
    if (getcwd(path, size) != NULL) {
      /* success, push the path to the Lua stack */
      lua_pushstring(L, path);
      result = 1;
      break;
    }
    if (errno != ERANGE) {      /* unexpected error */
      result = pusherror(L, "get_dir getcwd() failed");
      break;
    }
    /* ERANGE = insufficient buffer capacity, double size and retry */
    size *= 2;
  }
  free(path);
  return result;
#endif
}

References free, LFS_MAXPATHLEN, lua_pushnil(), lua_pushstring(), NULL, pusherror(), and realloc.

lfs_f_setmode()

static int lfs_f_setmode ( lua_State * L )

static

Definition at line 520 of file lfs.c.

{
  return lfs_g_setmode(L, check_file(L, 1, "setmode"), 2);
}

References check_file(), and lfs_g_setmode().

lfs_g_setmode()

static int lfs_g_setmode ( lua_State * L, FILE * f, int arg )

static

Definition at line 498 of file lfs.c.

{
  static const int mode[] = { _O_BINARY, _O_TEXT };
  static const char *const modenames[] = { "binary", "text", NULL };
  int op = luaL_checkoption(L, arg, NULL, modenames);
  int res = lfs_setmode(f, mode[op]);
  if (res != -1) {
    int i;
    lua_pushboolean(L, 1);
    for (i = 0; modenames[i] != NULL; i++) {
      if (mode[i] == res) {
        lua_pushstring(L, modenames[i]);
        return 2;
      }
    }
    lua_pushnil(L);
    return 2;
  } else {
    return pusherror(L, NULL);
  }
}

References _O_BINARY, _O_TEXT, arg, lfs_setmode, lua_pushboolean(), lua_pushnil(), lua_pushstring(), luaL_checkoption(), NULL, and pusherror().

Referenced by lfs_f_setmode().

lfs_lock_dir()

static int lfs_lock_dir ( lua_State * L )

static

Definition at line 458 of file lfs.c.

{
  lfs_Lock *lock;
  size_t pathl;
  char *ln;
  const char *lockfile = "/lockfile.lfs";
  const char *path = luaL_checklstring(L, 1, &pathl);
  lock = (lfs_Lock *) lua_newuserdata(L, sizeof(lfs_Lock));
  ln = (char *) malloc(pathl + strlen(lockfile) + 1);
  if (!ln) {
    lua_pushnil(L);
    lua_pushstring(L, strerror(errno));
    return 2;
  }
  strcpy(ln, path);
  strcat(ln, lockfile);
  if (symlink("lock", ln) == -1) {
    free(ln);
    lua_pushnil(L);
    lua_pushstring(L, strerror(errno));
    return 2;
  }
  lock->ln = ln;
  luaL_getmetatable(L, LOCK_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

References free, lfs_Lock::ln, LOCK_METATABLE, lua_newuserdata, lua_pushnil(), lua_pushstring(), lua_setmetatable(), luaL_checklstring(), luaL_getmetatable, and malloc.

lfs_unlock_dir()

static int lfs_unlock_dir ( lua_State * L )

static

Definition at line 486 of file lfs.c.

{
  lfs_Lock *lock = (lfs_Lock *) luaL_checkudata(L, 1, LOCK_METATABLE);
  if (lock->ln) {
    unlink(lock->ln);
    free(lock->ln);
    lock->ln = NULL;
  }
  return 0;
}

References free, lfs_Lock::ln, LOCK_METATABLE, luaL_checkudata(), and NULL.

Referenced by lock_create_meta().

link_info()

static int link_info ( lua_State * L )

static

Definition at line 1121 of file lfs.c.

{
  int ret;
  if (lua_isstring(L, 2) && (strcmp(lua_tostring(L, 2), "target") == 0)) {
    int ok = push_link_target(L);
    return ok ? 1 : pusherror(L, "could not obtain link target");
  }
  ret = _file_info_(L, LSTAT_FUNC);
  if (ret == 1 && lua_type(L, -1) == LUA_TTABLE) {
    int ok = push_link_target(L);
    if (ok) {
      lua_setfield(L, -2, "target");
    }
  }
  return ret;
}

References _file_info_(), LSTAT_FUNC, lua_isstring(), lua_setfield(), lua_tostring, LUA_TTABLE, lua_type(), push_link_target(), and pusherror().

lock_create_meta()

static int lock_create_meta ( lua_State * L )

static

Definition at line 768 of file lfs.c.

{
  luaL_newmetatable(L, LOCK_METATABLE);
 
  /* Method table */
  lua_newtable(L);
  lua_pushcfunction(L, lfs_unlock_dir);
  lua_setfield(L, -2, "free");
 
  /* Metamethods */
  lua_setfield(L, -2, "__index");
  lua_pushcfunction(L, lfs_unlock_dir);
  lua_setfield(L, -2, "__gc");
  return 1;
}

References lfs_unlock_dir(), LOCK_METATABLE, lua_newtable, lua_pushcfunction, lua_setfield(), and luaL_newmetatable().

Referenced by luaopen_lfs().

luaopen_lfs()

LFS_EXPORT int luaopen_lfs

(

lua_State *

L

)

Definition at line 1173 of file lfs.c.

{
  dir_create_meta(L);
  lock_create_meta(L);
  new_lib(L, fslib);
  lua_pushvalue(L, -1);
  lua_setglobal(L, LFS_LIBNAME);
  set_info(L);
  return 1;
}

References dir_create_meta(), fslib, LFS_LIBNAME, lock_create_meta(), lua_pushvalue(), lua_setglobal, new_lib, and set_info().

make_dir()

static int make_dir ( lua_State * L )

static

Definition at line 619 of file lfs.c.

{
  const char *path = luaL_checkstring(L, 1);
  return pushresult(L, lfs_mkdir(path), NULL);
}

References lfs_mkdir, luaL_checkstring, NULL, and pushresult().

make_link()

static int make_link ( lua_State * L )

static

Definition at line 577 of file lfs.c.

{
  const char *oldpath = luaL_checkstring(L, 1);
  const char *newpath = luaL_checkstring(L, 2);
#ifndef _WIN32
  return pushresult(L,
                    (lua_toboolean(L, 3) ? symlink : link) (oldpath,
                                                            newpath),
                    NULL);
#else
  int symbolic = lua_toboolean(L, 3);
  STAT_STRUCT oldpathinfo;
  int is_dir = 0;
  if (STAT_FUNC(oldpath, &oldpathinfo) == 0) {
    is_dir = S_ISDIR(oldpathinfo.st_mode) != 0;
  }
  if (!symbolic && is_dir) {
    lua_pushnil(L);
    lua_pushstring(L,
                   "hard links to directories are not supported on Windows");
    return 2;
  }
 
  int result = symbolic ? CreateSymbolicLink(newpath, oldpath, is_dir)
      : CreateHardLink(newpath, oldpath, NULL);
 
  if (result) {
    return pushresult(L, result, NULL);
  } else {
    lua_pushnil(L);
    lua_pushstring(L, symbolic ? "make_link CreateSymbolicLink() failed"
                   : "make_link CreateHardLink() failed");
    return 2;
  }
#endif
}

References lua_pushnil(), lua_pushstring(), lua_toboolean(), luaL_checkstring, NULL, pushresult(), STAT_FUNC, and STAT_STRUCT.

mode2string()

static const char * mode2string ( mode_t mode )

static

Definition at line 792 of file lfs.c.

{
#endif
  if (S_ISREG(mode))
    return "file";
  else if (S_ISDIR(mode))
    return "directory";
  else if (S_ISLNK(mode))
    return "link";
  else if (S_ISSOCK(mode))
    return "socket";
  else if (S_ISFIFO(mode))
    return "named pipe";
  else if (S_ISCHR(mode))
    return "char device";
  else if (S_ISBLK(mode))
    return "block device";
  else
    return "other";
}

Referenced by push_st_mode().

perm2string()

static const char * perm2string ( mode_t mode )

static

Definition at line 946 of file lfs.c.

{
  static char perms[10] = "---------";
  int i;
  for (i = 0; i < 9; i++)
    perms[i] = '-';
  if (mode & S_IRUSR)
    perms[0] = 'r';
  if (mode & S_IWUSR)
    perms[1] = 'w';
  if (mode & S_IXUSR)
    perms[2] = 'x';
  if (mode & S_IRGRP)
    perms[3] = 'r';
  if (mode & S_IWGRP)
    perms[4] = 'w';
  if (mode & S_IXGRP)
    perms[5] = 'x';
  if (mode & S_IROTH)
    perms[6] = 'r';
  if (mode & S_IWOTH)
    perms[7] = 'w';
  if (mode & S_IXOTH)
    perms[8] = 'x';
  return perms;
}

Referenced by push_st_perm().

push_link_target()

static int push_link_target ( lua_State * L )

static

Definition at line 1066 of file lfs.c.

{
  const char *file = luaL_checkstring(L, 1);
#ifdef _WIN32
  HANDLE h = CreateFile(file, GENERIC_READ,
                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  if (h == INVALID_HANDLE_VALUE) {
    return lfs_win32_pusherror(L);
  }
#endif
  char *target = NULL;
  int tsize, size = 256;        /* size = initial buffer capacity */
  int ok = 0;
  while (!ok) {
    char *target2 = realloc(target, size);
    if (!target2) {             /* failed to allocate */
      break;
    }
    target = target2;
#ifdef _WIN32
    tsize = GetFinalPathNameByHandle(h, target, size, FILE_NAME_OPENED);
#else
    tsize = readlink(file, target, size);
#endif
    if (tsize < 0) {            /* a readlink() error occurred */
      break;
    }
    if (tsize < size) {
#ifdef _WIN32
      if (tsize > 4 && strncmp(target, "\\\\?\\", 4) == 0) {
        memmove_s(target, tsize - 3, target + 4, tsize - 3);
        tsize -= 4;
      }
#endif
      ok = 1;
      break;
    }
    /* possibly truncated readlink() result, double size and retry */
    size *= 2;
  }
  if (ok) {
    target[tsize] = '\0';
    lua_pushlstring(L, target, tsize);
  }
#ifdef _WIN32
  CloseHandle(h);
#endif
  free(target);
  return ok;
}

References free, lua_pushlstring(), luaL_checkstring, NULL, and realloc.

Referenced by link_info().

push_st_atime()

static void push_st_atime ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 880 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_atime);
}

References lua_pushinteger().

push_st_blksize()

static void push_st_blksize ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 911 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_blksize);
}

References lua_pushinteger().

push_st_blocks()

static void push_st_blocks ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 905 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_blocks);
}

References lua_pushinteger().

push_st_ctime()

static void push_st_ctime ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 892 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_ctime);
}

References lua_pushinteger().

push_st_dev()

static void push_st_dev ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 844 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_dev);
}

References lua_pushinteger().

push_st_gid()

static void push_st_gid ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 868 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_gid);
}

References lua_pushinteger().

push_st_ino()

static void push_st_ino ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 850 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_ino);
}

References lua_pushinteger().

push_st_mode()

static void push_st_mode ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 838 of file lfs.c.

{
  lua_pushstring(L, mode2string(info->st_mode));
}

References lua_pushstring(), and mode2string().

push_st_mtime()

static void push_st_mtime ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 886 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_mtime);
}

References lua_pushinteger().

push_st_nlink()

static void push_st_nlink ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 856 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_nlink);
}

References lua_pushinteger().

push_st_perm()

static void push_st_perm ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 975 of file lfs.c.

{
  lua_pushstring(L, perm2string(info->st_mode));
}

References lua_pushstring(), and perm2string().

push_st_rdev()

static void push_st_rdev ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 874 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_rdev);
}

References lua_pushinteger().

push_st_size()

static void push_st_size ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 898 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_size);
}

References lua_pushinteger().

push_st_uid()

static void push_st_uid ( lua_State * L, STAT_STRUCT * info )

static

Definition at line 862 of file lfs.c.

{
  lua_pushinteger(L, (lua_Integer) info->st_uid);
}

References lua_pushinteger().

pusherror()

static int pusherror ( lua_State * L, const char * info )

static

Definition at line 234 of file lfs.c.

{
  lua_pushnil(L);
  if (info == NULL)
    lua_pushstring(L, strerror(errno));
  else
    lua_pushfstring(L, "%s: %s", info, strerror(errno));
  lua_pushinteger(L, errno);
  return 3;
}

References lua_pushfstring(), lua_pushinteger(), lua_pushnil(), lua_pushstring(), and NULL.

Referenced by get_dir(), lfs_g_setmode(), link_info(), and pushresult().

pushresult()

static int pushresult ( lua_State * L, int res, const char * info )

static

Definition at line 245 of file lfs.c.

{
  if (res == -1) {
    return pusherror(L, info);
  } else {
    lua_pushboolean(L, 1);
    return 1;
  }
}

References lua_pushboolean(), and pusherror().

Referenced by file_utime(), make_dir(), make_link(), and remove_dir().

remove_dir()

static int remove_dir ( lua_State * L )

static

Definition at line 630 of file lfs.c.

{
  const char *path = luaL_checkstring(L, 1);
  return pushresult(L, rmdir(path), NULL);
}

References luaL_checkstring, NULL, and pushresult().

set_info()

static void set_info ( lua_State * L )

static

Definition at line 1142 of file lfs.c.

{
  lua_pushliteral(L, "Copyright (C) 2003-2017 Kepler Project");
  lua_setfield(L, -2, "_COPYRIGHT");
  lua_pushliteral(L,
                  "LuaFileSystem is a Lua library developed to complement "
                  "the set of functions related to file systems offered by "
                  "the standard Lua distribution");
  lua_setfield(L, -2, "_DESCRIPTION");
  lua_pushliteral(L, "LuaFileSystem " LFS_VERSION);
  lua_setfield(L, -2, "_VERSION");
}

References LFS_VERSION, lua_pushliteral, and lua_setfield().

Referenced by luaopen_lfs().

Variable Documentation

fslib

const struct luaL_Reg fslib[]

static

Initial value:

= {
  { "attributes", file_info },
  { "chdir", change_dir },
  { "currentdir", get_dir },
  { "dir", dir_iter_factory },
  { "link", make_link },
  { "lock", file_lock },
  { "mkdir", make_dir },
  { "rmdir", remove_dir },
  { "symlinkattributes", link_info },
  { "setmode", lfs_f_setmode },
  { "touch", file_utime },
  { "unlock", file_unlock },
  { "lock_dir", lfs_lock_dir },
  { NULL, NULL },
}

Definition at line 1156 of file lfs.c.

                                       {
  { "attributes", file_info },
  { "chdir", change_dir },
  { "currentdir", get_dir },
  { "dir", dir_iter_factory },
  { "link", make_link },
  { "lock", file_lock },
  { "mkdir", make_dir },
  { "rmdir", remove_dir },
  { "symlinkattributes", link_info },
  { "setmode", lfs_f_setmode },
  { "touch", file_utime },
  { "unlock", file_unlock },
  { "lock_dir", lfs_lock_dir },
  { NULL, NULL },
};

Referenced by luaopen_lfs().

members

struct _stat_members members[]

Initial value:

= {
  { "mode", push_st_mode },
  { "dev", push_st_dev },
  { "ino", push_st_ino },
  { "nlink", push_st_nlink },
  { "uid", push_st_uid },
  { "gid", push_st_gid },
  { "rdev", push_st_rdev },
  { "access", push_st_atime },
  { "modification", push_st_mtime },
  { "change", push_st_ctime },
  { "size", push_st_size },
  { "permissions", push_st_perm },
 
  { "blocks", push_st_blocks },
  { "blksize", push_st_blksize },
 
  { NULL, NULL }
}

Definition at line 987 of file lfs.c.

                                 {
  { "mode", push_st_mode },
  { "dev", push_st_dev },
  { "ino", push_st_ino },
  { "nlink", push_st_nlink },
  { "uid", push_st_uid },
  { "gid", push_st_gid },
  { "rdev", push_st_rdev },
  { "access", push_st_atime },
  { "modification", push_st_mtime },
  { "change", push_st_ctime },
  { "size", push_st_size },
  { "permissions", push_st_perm },
#ifndef _WIN32
  { "blocks", push_st_blocks },
  { "blksize", push_st_blksize },
#endif
  { NULL, NULL }
};

Referenced by _file_info_().