380 lines
7.4 KiB
C
380 lines
7.4 KiB
C
|
/*
|
||
|
|
* fastindex - fast lua module indexing plugin
|
||
|
|
* Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org>
|
||
|
|
*
|
||
|
|
* This program is free software; you can redistribute it and/or modify
|
||
|
|
* it under the terms of the GNU General Public License version 2
|
||
|
|
* as published by the Free Software Foundation
|
||
|
|
*
|
||
|
|
* This program is distributed in the hope that it will be useful,
|
||
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
* GNU General Public License for more details.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <sys/types.h>
|
||
|
|
#include <sys/time.h>
|
||
|
|
#include <sys/cdefs.h>
|
||
|
|
|
||
|
|
#ifndef _POSIX_C_SOURCE
|
||
|
|
#define _POSIX_C_SOURCE /* XXX: portability hack for timestamp */
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <sys/stat.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <errno.h>
|
||
|
|
#include <glob.h>
|
||
|
|
|
||
|
|
#include <lualib.h>
|
||
|
|
#include <lauxlib.h>
|
||
|
|
#include "list.h"
|
||
|
|
|
||
|
|
#define MODNAME "luci.fastindex"
|
||
|
|
#define DEFAULT_BUFLEN 1024
|
||
|
|
|
||
|
|
//#define DEBUG 1
|
||
|
|
|
||
|
|
#ifdef DEBUG
|
||
|
|
#define DPRINTF(...) fprintf(stderr, __VA_ARGS__)
|
||
|
|
#else
|
||
|
|
#define DPRINTF(...) do {} while (0)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/**
|
||
|
|
* list_for_each_offset - iterate over a list, start with the provided pointer
|
||
|
|
* @pos: the &struct list_head to use as a loop cursor.
|
||
|
|
* @head: the head for your list.
|
||
|
|
*/
|
||
|
|
#define list_for_each_offset(pos, head, offset) \
|
||
|
|
for (pos = (offset)->next; pos != (offset); \
|
||
|
|
pos = ((pos->next == (head)) && ((offset) != (head)) ? (head)->next : pos->next))
|
||
|
|
|
||
|
|
static char *namespace = NULL;
|
||
|
|
|
||
|
|
struct fastindex_entry {
|
||
|
|
struct list_head list;
|
||
|
|
time_t timestamp;
|
||
|
|
int checked;
|
||
|
|
char *name;
|
||
|
|
};
|
||
|
|
|
||
|
|
struct fastindex_pattern {
|
||
|
|
struct list_head list;
|
||
|
|
char pattern[];
|
||
|
|
};
|
||
|
|
|
||
|
|
struct fastindex {
|
||
|
|
lua_State *L;
|
||
|
|
int checked;
|
||
|
|
char *func;
|
||
|
|
struct list_head patterns;
|
||
|
|
struct list_head *last;
|
||
|
|
struct list_head entries;
|
||
|
|
int ofs;
|
||
|
|
char *buf;
|
||
|
|
int buflen;
|
||
|
|
};
|
||
|
|
|
||
|
|
static inline struct fastindex *
|
||
|
|
to_fastindex(struct lua_State *L)
|
||
|
|
{
|
||
|
|
struct fastindex *f;
|
||
|
|
lua_getfield(L, lua_upvalueindex(1), "__data");
|
||
|
|
f = lua_touserdata(L, -1);
|
||
|
|
lua_pop(L, 1);
|
||
|
|
return f;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int
|
||
|
|
fastindex_module(lua_State *L)
|
||
|
|
{
|
||
|
|
const char *s;
|
||
|
|
s = luaL_checkstring(L, 1);
|
||
|
|
|
||
|
|
if (s) {
|
||
|
|
if (namespace)
|
||
|
|
free(namespace);
|
||
|
|
namespace = strdup(s);
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static struct fastindex_entry *
|
||
|
|
find_entry(struct fastindex *f, char *name)
|
||
|
|
{
|
||
|
|
struct list_head *p;
|
||
|
|
|
||
|
|
if (!f->last)
|
||
|
|
f->last = &f->entries;
|
||
|
|
|
||
|
|
list_for_each_offset(p, &f->entries, f->last) {
|
||
|
|
struct fastindex_entry *e;
|
||
|
|
e = container_of(p, struct fastindex_entry, list);
|
||
|
|
if (!strcmp(e->name, name))
|
||
|
|
return e;
|
||
|
|
}
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
static struct fastindex_entry *
|
||
|
|
new_entry(struct fastindex *f, char *name)
|
||
|
|
{
|
||
|
|
struct fastindex_entry *e;
|
||
|
|
|
||
|
|
e = malloc(sizeof(struct fastindex_entry));
|
||
|
|
if (!e)
|
||
|
|
goto error;
|
||
|
|
|
||
|
|
memset(e, 0, sizeof(struct fastindex_entry));
|
||
|
|
e->name = strdup(name);
|
||
|
|
if (!e->name) {
|
||
|
|
free(e);
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
INIT_LIST_HEAD(&e->list);
|
||
|
|
|
||
|
|
return e;
|
||
|
|
|
||
|
|
error:
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void free_entry(struct fastindex_entry *e)
|
||
|
|
{
|
||
|
|
list_del(&e->list);
|
||
|
|
free(e->name);
|
||
|
|
free(e);
|
||
|
|
}
|
||
|
|
|
||
|
|
int bufferwriter(lua_State *L, const void *p, size_t sz, void *ud)
|
||
|
|
{
|
||
|
|
struct fastindex *f = ud;
|
||
|
|
|
||
|
|
while (f->ofs + sz > f->buflen) {
|
||
|
|
char *b = f->buf;
|
||
|
|
f->buflen *= 2;
|
||
|
|
f->buf = realloc(f->buf, f->buflen);
|
||
|
|
if (!f->buf) {
|
||
|
|
free(b);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
memcpy(f->buf + f->ofs, p, sz);
|
||
|
|
f->ofs += sz;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
load_index(struct fastindex *f, struct fastindex_entry *e)
|
||
|
|
{
|
||
|
|
lua_State *L;
|
||
|
|
|
||
|
|
DPRINTF("Loading module: %s\n", e->name);
|
||
|
|
|
||
|
|
if (!f->buf)
|
||
|
|
f->buf = malloc(f->buflen);
|
||
|
|
|
||
|
|
if (!f->buf)
|
||
|
|
luaL_error(f->L, "Out of memory!\n");
|
||
|
|
|
||
|
|
f->ofs = 0;
|
||
|
|
L = luaL_newstate();
|
||
|
|
if (!L)
|
||
|
|
return;
|
||
|
|
|
||
|
|
namespace = NULL;
|
||
|
|
luaL_openlibs(L);
|
||
|
|
lua_pushcfunction(L, fastindex_module);
|
||
|
|
lua_setfield(L, LUA_GLOBALSINDEX, "module");
|
||
|
|
|
||
|
|
do {
|
||
|
|
if (luaL_dofile(L, e->name)) {
|
||
|
|
DPRINTF("Warning: unable to open module '%s'\n", e->name);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
lua_getglobal(L, f->func);
|
||
|
|
lua_dump(L, bufferwriter, f);
|
||
|
|
DPRINTF("Got %d bytes\n", f->ofs);
|
||
|
|
if (f->ofs == 0)
|
||
|
|
break;
|
||
|
|
lua_createtable(f->L, (namespace ? 2 : 1), 0);
|
||
|
|
luaL_loadbuffer(f->L, f->buf, f->ofs, "tmp");
|
||
|
|
lua_rawseti(f->L, -2, 1);
|
||
|
|
if (namespace) {
|
||
|
|
DPRINTF("Module has namespace '%s'\n", namespace);
|
||
|
|
lua_pushstring(f->L, namespace);
|
||
|
|
lua_rawseti(f->L, -2, 2);
|
||
|
|
free(namespace);
|
||
|
|
namespace = NULL;
|
||
|
|
}
|
||
|
|
lua_setfield(f->L, -2, e->name);
|
||
|
|
} while (0);
|
||
|
|
|
||
|
|
lua_close(L);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static int
|
||
|
|
fastindex_scan(lua_State *L)
|
||
|
|
{
|
||
|
|
struct list_head *tmp, *p;
|
||
|
|
struct fastindex *f;
|
||
|
|
glob_t gl;
|
||
|
|
int i;
|
||
|
|
int gl_flags = GLOB_NOESCAPE | GLOB_NOSORT | GLOB_MARK;
|
||
|
|
|
||
|
|
f = to_fastindex(L);
|
||
|
|
f->checked++;
|
||
|
|
|
||
|
|
|
||
|
|
if (list_empty(&f->patterns))
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
lua_getfield(L, lua_upvalueindex(1), "indexes");
|
||
|
|
list_for_each(p, &f->patterns) {
|
||
|
|
struct fastindex_pattern *pt = container_of(p, struct fastindex_pattern, list);
|
||
|
|
glob(pt->pattern, gl_flags, NULL, &gl);
|
||
|
|
gl_flags |= GLOB_APPEND;
|
||
|
|
}
|
||
|
|
for (i = 0; i < gl.gl_pathc; i++) {
|
||
|
|
struct fastindex_entry *e;
|
||
|
|
struct stat st;
|
||
|
|
|
||
|
|
if (stat(gl.gl_pathv[i], &st))
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if ((st.st_mode & S_IFMT) != S_IFREG)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
e = find_entry(f, gl.gl_pathv[i]);
|
||
|
|
if (!e) {
|
||
|
|
e = new_entry(f, gl.gl_pathv[i]);
|
||
|
|
list_add_tail(&e->list, &f->entries);
|
||
|
|
}
|
||
|
|
|
||
|
|
e->checked = f->checked;
|
||
|
|
if ((e->timestamp < st.st_mtime)) {
|
||
|
|
load_index(f, e);
|
||
|
|
e->timestamp = st.st_mtime;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
globfree(&gl);
|
||
|
|
list_for_each_safe(p, tmp, &f->entries) {
|
||
|
|
struct fastindex_entry *e = container_of(p, struct fastindex_entry, list);
|
||
|
|
if (e->checked < f->checked) {
|
||
|
|
lua_pushnil(f->L);
|
||
|
|
lua_setfield(f->L, -2, e->name);
|
||
|
|
free_entry(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
lua_pop(L, 1);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int
|
||
|
|
fastindex_free(lua_State *L)
|
||
|
|
{
|
||
|
|
struct fastindex *f;
|
||
|
|
struct list_head *p, *tmp;
|
||
|
|
|
||
|
|
f = lua_touserdata(L, -1);
|
||
|
|
list_for_each_safe(p, tmp, &f->patterns) {
|
||
|
|
struct fastindex_pattern *pt;
|
||
|
|
pt = container_of(p, struct fastindex_pattern, list);
|
||
|
|
list_del(p);
|
||
|
|
free(pt);
|
||
|
|
}
|
||
|
|
list_for_each_safe(p, tmp, &f->entries) {
|
||
|
|
struct fastindex_entry *e;
|
||
|
|
e = container_of(p, struct fastindex_entry, list);
|
||
|
|
free_entry(e);
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int
|
||
|
|
fastindex_add(lua_State *L)
|
||
|
|
{
|
||
|
|
struct fastindex_pattern *pt;
|
||
|
|
struct fastindex *f;
|
||
|
|
const char *str;
|
||
|
|
|
||
|
|
f = to_fastindex(L);
|
||
|
|
str = luaL_checkstring(L, 1);
|
||
|
|
if (!str)
|
||
|
|
luaL_error(L, "Invalid argument");
|
||
|
|
|
||
|
|
pt = malloc(sizeof(struct fastindex_pattern) + strlen(str) + 1);
|
||
|
|
if (!pt)
|
||
|
|
luaL_error(L, "Out of memory");
|
||
|
|
|
||
|
|
INIT_LIST_HEAD(&pt->list);
|
||
|
|
strcpy(pt->pattern, str);
|
||
|
|
list_add(&pt->list, &f->patterns);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const luaL_Reg fastindex_m[] = {
|
||
|
|
{ "add", fastindex_add },
|
||
|
|
{ "scan", fastindex_scan },
|
||
|
|
{ NULL, NULL }
|
||
|
|
};
|
||
|
|
|
||
|
|
static int
|
||
|
|
fastindex_new(lua_State *L)
|
||
|
|
{
|
||
|
|
struct fastindex *f;
|
||
|
|
const char *func;
|
||
|
|
|
||
|
|
func = luaL_checkstring(L, 1);
|
||
|
|
|
||
|
|
f = lua_newuserdata(L, sizeof(struct fastindex));
|
||
|
|
lua_createtable(L, 0, 2);
|
||
|
|
lua_pushvalue(L, -1);
|
||
|
|
lua_setfield(L, -2, "__index");
|
||
|
|
lua_pushcfunction(L, fastindex_free);
|
||
|
|
lua_setfield(L, -2, "__gc");
|
||
|
|
lua_pushvalue(L, -1);
|
||
|
|
lua_setmetatable(L, -3);
|
||
|
|
lua_pushvalue(L, -2);
|
||
|
|
lua_setfield(L, -2, "__data");
|
||
|
|
lua_createtable(L, 0, 1);
|
||
|
|
lua_setfield(L, -2, "indexes");
|
||
|
|
lua_pushvalue(L, -2);
|
||
|
|
luaI_openlib(L, NULL, fastindex_m, 1);
|
||
|
|
|
||
|
|
memset(f, 0, sizeof(struct fastindex));
|
||
|
|
f->L = L;
|
||
|
|
f->buflen = DEFAULT_BUFLEN;
|
||
|
|
INIT_LIST_HEAD(&f->entries);
|
||
|
|
INIT_LIST_HEAD(&f->patterns);
|
||
|
|
|
||
|
|
f->func = strdup(func);
|
||
|
|
if (!f->func) {
|
||
|
|
if (f->func)
|
||
|
|
free(f->func);
|
||
|
|
luaL_error(L, "Out of memory\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const luaL_Reg fastindex[] = {
|
||
|
|
{ "new", fastindex_new },
|
||
|
|
{ NULL, NULL },
|
||
|
|
};
|
||
|
|
|
||
|
|
int
|
||
|
|
luaopen_luci_fastindex(lua_State *L)
|
||
|
|
{
|
||
|
|
luaL_register(L, MODNAME, fastindex);
|
||
|
|
return 0;
|
||
|
|
}
|