mirrors/prosody
1
0
Fork 0
mirror of https://github.com/bjc/prosody.git synced 2025-04-05 14:17:37 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

util-src/*.c: astyle --indent=tab --brackets=attach --indent-switches --break-blocks --pad-oper --unpad-paren --add-brackets --align-pointer=type --lineend=linux

Browse source
This commit is contained in:
Kim Alvefur 2015-04-03 19:52:48 +02:00
parent 28c58565ac
commit e866ef555a
7 changed files with 827 additions and 697 deletions
Download patch file Download diff file Expand all files Collapse all files

313
util-src/encodings.c
View file

@ -27,95 +27,125 @@
/***************** BASE64 *****************/ /***************** BASE64 *****************/
static const char code[]= static const char code[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static void base64_encode(luaL_Buffer *b, unsigned int c1, unsigned int c2, unsigned int c3, int n) static void base64_encode(luaL_Buffer* b, unsigned int c1, unsigned int c2, unsigned int c3, int n) {
{ unsigned long tuple = c3 + 256UL * (c2 + 256UL * c1);
unsigned long tuple=c3+256UL*(c2+256UL*c1);
int i; int i;
char s[4]; char s[4];
for (i=0; i<4; i++) {
s[3-i] = code[tuple % 64]; for(i = 0; i < 4; i++) {
s[3 - i] = code[tuple % 64];
tuple /= 64; tuple /= 64;
} }
for (i=n+1; i<4; i++) s[i]='=';
luaL_addlstring(b,s,4); for(i = n + 1; i < 4; i++) {
s[i] = '=';
}
luaL_addlstring(b, s, 4);
} }
static int Lbase64_encode(lua_State *L) /** encode(s) */ static int Lbase64_encode(lua_State* L) { /** encode(s) */
{
size_t l; size_t l;
const unsigned char *s=(const unsigned char*)luaL_checklstring(L,1,&l); const unsigned char* s = (const unsigned char*)luaL_checklstring(L, 1, &l);
luaL_Buffer b; luaL_Buffer b;
int n; int n;
luaL_buffinit(L,&b); luaL_buffinit(L, &b);
for (n=l/3; n--; s+=3) base64_encode(&b,s[0],s[1],s[2],3);
switch (l%3) for(n = l / 3; n--; s += 3) {
{ base64_encode(&b, s[0], s[1], s[2], 3);
case 1: base64_encode(&b,s[0],0,0,1); break;
case 2: base64_encode(&b,s[0],s[1],0,2); break;
} }
switch(l % 3) {
case 1:
base64_encode(&b, s[0], 0, 0, 1);
break;
case 2:
base64_encode(&b, s[0], s[1], 0, 2);
break;
}
luaL_pushresult(&b); luaL_pushresult(&b);
return 1; return 1;
} }
static void base64_decode(luaL_Buffer *b, int c1, int c2, int c3, int c4, int n) static void base64_decode(luaL_Buffer* b, int c1, int c2, int c3, int c4, int n) {
{ unsigned long tuple = c4 + 64L * (c3 + 64L * (c2 + 64L * c1));
unsigned long tuple=c4+64L*(c3+64L*(c2+64L*c1));
char s[3]; char s[3];
switch (--n)
{ switch(--n) {
case 3: s[2]=(char) tuple; case 3:
case 2: s[1]=(char) (tuple >> 8); s[2] = (char) tuple;
case 1: s[0]=(char) (tuple >> 16); case 2:
s[1] = (char)(tuple >> 8);
case 1:
s[0] = (char)(tuple >> 16);
} }
luaL_addlstring(b,s,n);
luaL_addlstring(b, s, n);
} }
static int Lbase64_decode(lua_State *L) /** decode(s) */ static int Lbase64_decode(lua_State* L) { /** decode(s) */
{
size_t l; size_t l;
const char *s=luaL_checklstring(L,1,&l); const char* s = luaL_checklstring(L, 1, &l);
luaL_Buffer b; luaL_Buffer b;
int n=0; int n = 0;
char t[4]; char t[4];
luaL_buffinit(L,&b); luaL_buffinit(L, &b);
for (;;)
{ for(;;) {
int c=*s++; int c = *s++;
switch (c)
{ switch(c) {
const char *p; const char* p;
default: default:
p=strchr(code,c); if (p==NULL) return 0; p = strchr(code, c);
t[n++]= (char) (p-code);
if (n==4) if(p == NULL) {
{ return 0;
base64_decode(&b,t[0],t[1],t[2],t[3],4);
n=0;
} }
t[n++] = (char)(p - code);
if(n == 4) {
base64_decode(&b, t[0], t[1], t[2], t[3], 4);
n = 0;
}
break; break;
case '=': case '=':
switch (n)
{ switch(n) {
case 1: base64_decode(&b,t[0],0,0,0,1); break; case 1:
case 2: base64_decode(&b,t[0],t[1],0,0,2); break; base64_decode(&b, t[0], 0, 0, 0, 1);
case 3: base64_decode(&b,t[0],t[1],t[2],0,3); break; break;
case 2:
base64_decode(&b, t[0], t[1], 0, 0, 2);
break;
case 3:
base64_decode(&b, t[0], t[1], t[2], 0, 3);
break;
} }
n=0;
n = 0;
break; break;
case 0: case 0:
luaL_pushresult(&b); luaL_pushresult(&b);
return 1; return 1;
case '\n': case '\r': case '\t': case ' ': case '\f': case '\b': case '\n':
case '\r':
case '\t':
case ' ':
case '\f':
case '\b':
break; break;
} }
} }
} }
static const luaL_Reg Reg_base64[] = static const luaL_Reg Reg_base64[] = {
{
{ "encode", Lbase64_encode }, { "encode", Lbase64_encode },
{ "decode", Lbase64_decode }, { "decode", Lbase64_decode },
{ NULL, NULL } { NULL, NULL }
@ -133,70 +163,89 @@ static const luaL_Reg Reg_base64[] =
/* /*
* Decode one UTF-8 sequence, returning NULL if byte sequence is invalid. * Decode one UTF-8 sequence, returning NULL if byte sequence is invalid.
*/ */
static const char *utf8_decode (const char *o, int *val) { static const char* utf8_decode(const char* o, int* val) {
static unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF}; static unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
const unsigned char *s = (const unsigned char *)o; const unsigned char* s = (const unsigned char*)o;
unsigned int c = s[0]; unsigned int c = s[0];
unsigned int res = 0; /* final result */ unsigned int res = 0; /* final result */
if (c < 0x80) /* ascii? */
if(c < 0x80) { /* ascii? */
res = c; res = c;
else { } else {
int count = 0; /* to count number of continuation bytes */ int count = 0; /* to count number of continuation bytes */
while (c & 0x40) { /* still have continuation bytes? */
while(c & 0x40) { /* still have continuation bytes? */
int cc = s[++count]; /* read next byte */ int cc = s[++count]; /* read next byte */
if ((cc & 0xC0) != 0x80) /* not a continuation byte? */
if((cc & 0xC0) != 0x80) { /* not a continuation byte? */
return NULL; /* invalid byte sequence */ return NULL; /* invalid byte sequence */
}
res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */ res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */
c <<= 1; /* to test next bit */ c <<= 1; /* to test next bit */
} }
res |= ((c & 0x7F) << (count * 5)); /* add first byte */ res |= ((c & 0x7F) << (count * 5)); /* add first byte */
if (count > 3 || res > MAXUNICODE || res <= limits[count] || (0xd800 <= res && res <= 0xdfff) )
if(count > 3 || res > MAXUNICODE || res <= limits[count] || (0xd800 <= res && res <= 0xdfff)) {
return NULL; /* invalid byte sequence */ return NULL; /* invalid byte sequence */
}
s += count; /* skip continuation bytes read */ s += count; /* skip continuation bytes read */
} }
if (val) *val = res;
return (const char *)s + 1; /* +1 to include first byte */ if(val) {
*val = res;
}
return (const char*)s + 1; /* +1 to include first byte */
} }
/* /*
* Check that a string is valid UTF-8 * Check that a string is valid UTF-8
* Returns NULL if not * Returns NULL if not
*/ */
const char* check_utf8 (lua_State *L, int idx, size_t *l) { const char* check_utf8(lua_State* L, int idx, size_t* l) {
size_t pos, len; size_t pos, len;
const char *s = luaL_checklstring(L, 1, &len); const char* s = luaL_checklstring(L, 1, &len);
pos = 0; pos = 0;
while (pos <= len) {
const char *s1 = utf8_decode(s + pos, NULL); while(pos <= len) {
if (s1 == NULL) { /* conversion error? */ const char* s1 = utf8_decode(s + pos, NULL);
if(s1 == NULL) { /* conversion error? */
return NULL; return NULL;
} }
pos = s1 - s; pos = s1 - s;
} }
if(l != NULL) { if(l != NULL) {
*l = len; *l = len;
} }
return s; return s;
} }
static int Lutf8_valid(lua_State *L) { static int Lutf8_valid(lua_State* L) {
lua_pushboolean(L, check_utf8(L, 1, NULL) != NULL); lua_pushboolean(L, check_utf8(L, 1, NULL) != NULL);
return 1; return 1;
} }
static int Lutf8_length(lua_State *L) { static int Lutf8_length(lua_State* L) {
size_t len; size_t len;
if(!check_utf8(L, 1, &len)) { if(!check_utf8(L, 1, &len)) {
lua_pushnil(L); lua_pushnil(L);
lua_pushliteral(L, "invalid utf8"); lua_pushliteral(L, "invalid utf8");
return 2; return 2;
} }
lua_pushinteger(L, len); lua_pushinteger(L, len);
return 1; return 1;
} }
static const luaL_Reg Reg_utf8[] = static const luaL_Reg Reg_utf8[] = {
{
{ "valid", Lutf8_valid }, { "valid", Lutf8_valid },
{ "length", Lutf8_length }, { "length", Lutf8_length },
{ NULL, NULL } { NULL, NULL }
@ -210,11 +259,10 @@ static const luaL_Reg Reg_utf8[] =
#include <unicode/ustring.h> #include <unicode/ustring.h>
#include <unicode/utrace.h> #include <unicode/utrace.h>
static int icu_stringprep_prep(lua_State *L, const UStringPrepProfile *profile) static int icu_stringprep_prep(lua_State* L, const UStringPrepProfile* profile) {
{
size_t input_len; size_t input_len;
int32_t unprepped_len, prepped_len, output_len; int32_t unprepped_len, prepped_len, output_len;
const char *input; const char* input;
char output[1024]; char output[1024];
UChar unprepped[1024]; /* Temporary unicode buffer (1024 characters) */ UChar unprepped[1024]; /* Temporary unicode buffer (1024 characters) */
@ -226,45 +274,56 @@ static int icu_stringprep_prep(lua_State *L, const UStringPrepProfile *profile)
lua_pushnil(L); lua_pushnil(L);
return 1; return 1;
} }
input = lua_tolstring(L, 1, &input_len); input = lua_tolstring(L, 1, &input_len);
if (input_len >= 1024) {
if(input_len >= 1024) {
lua_pushnil(L); lua_pushnil(L);
return 1; return 1;
} }
u_strFromUTF8(unprepped, 1024, &unprepped_len, input, input_len, &err); u_strFromUTF8(unprepped, 1024, &unprepped_len, input, input_len, &err);
if (U_FAILURE(err)) {
if(U_FAILURE(err)) {
lua_pushnil(L); lua_pushnil(L);
return 1; return 1;
} }
prepped_len = usprep_prepare(profile, unprepped, unprepped_len, prepped, 1024, 0, NULL, &err); prepped_len = usprep_prepare(profile, unprepped, unprepped_len, prepped, 1024, 0, NULL, &err);
if (U_FAILURE(err)) {
if(U_FAILURE(err)) {
lua_pushnil(L); lua_pushnil(L);
return 1; return 1;
} else { } else {
u_strToUTF8(output, 1024, &output_len, prepped, prepped_len, &err); u_strToUTF8(output, 1024, &output_len, prepped, prepped_len, &err);
if (U_SUCCESS(err) && output_len < 1024)
if(U_SUCCESS(err) && output_len < 1024) {
lua_pushlstring(L, output, output_len); lua_pushlstring(L, output, output_len);
else } else {
lua_pushnil(L); lua_pushnil(L);
}
return 1; return 1;
} }
} }
UStringPrepProfile *icu_nameprep; UStringPrepProfile* icu_nameprep;
UStringPrepProfile *icu_nodeprep; UStringPrepProfile* icu_nodeprep;
UStringPrepProfile *icu_resourceprep; UStringPrepProfile* icu_resourceprep;
UStringPrepProfile *icu_saslprep; UStringPrepProfile* icu_saslprep;
/* initialize global ICU stringprep profiles */ /* initialize global ICU stringprep profiles */
void init_icu() void init_icu() {
{
UErrorCode err = U_ZERO_ERROR; UErrorCode err = U_ZERO_ERROR;
utrace_setLevel(UTRACE_VERBOSE); utrace_setLevel(UTRACE_VERBOSE);
icu_nameprep = usprep_openByType(USPREP_RFC3491_NAMEPREP, &err); icu_nameprep = usprep_openByType(USPREP_RFC3491_NAMEPREP, &err);
icu_nodeprep = usprep_openByType(USPREP_RFC3920_NODEPREP, &err); icu_nodeprep = usprep_openByType(USPREP_RFC3920_NODEPREP, &err);
icu_resourceprep = usprep_openByType(USPREP_RFC3920_RESOURCEPREP, &err); icu_resourceprep = usprep_openByType(USPREP_RFC3920_RESOURCEPREP, &err);
icu_saslprep = usprep_openByType(USPREP_RFC4013_SASLPREP, &err); icu_saslprep = usprep_openByType(USPREP_RFC4013_SASLPREP, &err);
if (U_FAILURE(err)) fprintf(stderr, "[c] util.encodings: error: %s\n", u_errorName((UErrorCode)err));
if(U_FAILURE(err)) {
fprintf(stderr, "[c] util.encodings: error: %s\n", u_errorName((UErrorCode)err));
}
} }
#define MAKE_PREP_FUNC(myFunc, prep) \ #define MAKE_PREP_FUNC(myFunc, prep) \
@ -275,8 +334,7 @@ MAKE_PREP_FUNC(Lstringprep_nodeprep, icu_nodeprep) /** stringprep.nodeprep(s) *
MAKE_PREP_FUNC(Lstringprep_resourceprep, icu_resourceprep) /** stringprep.resourceprep(s) */ MAKE_PREP_FUNC(Lstringprep_resourceprep, icu_resourceprep) /** stringprep.resourceprep(s) */
MAKE_PREP_FUNC(Lstringprep_saslprep, icu_saslprep) /** stringprep.saslprep(s) */ MAKE_PREP_FUNC(Lstringprep_saslprep, icu_saslprep) /** stringprep.saslprep(s) */
static const luaL_Reg Reg_stringprep[] = static const luaL_Reg Reg_stringprep[] = {
{
{ "nameprep", Lstringprep_nameprep }, { "nameprep", Lstringprep_nameprep },
{ "nodeprep", Lstringprep_nodeprep }, { "nodeprep", Lstringprep_nodeprep },
{ "resourceprep", Lstringprep_resourceprep }, { "resourceprep", Lstringprep_resourceprep },
@ -289,24 +347,28 @@ static const luaL_Reg Reg_stringprep[] =
#include <stringprep.h> #include <stringprep.h>
static int stringprep_prep(lua_State *L, const Stringprep_profile *profile) static int stringprep_prep(lua_State* L, const Stringprep_profile* profile) {
{
size_t len; size_t len;
const char *s; const char* s;
char string[1024]; char string[1024];
int ret; int ret;
if(!lua_isstring(L, 1)) { if(!lua_isstring(L, 1)) {
lua_pushnil(L); lua_pushnil(L);
return 1; return 1;
} }
s = check_utf8(L, 1, &len); s = check_utf8(L, 1, &len);
if (s == NULL || len >= 1024 || len != strlen(s)) {
if(s == NULL || len >= 1024 || len != strlen(s)) {
lua_pushnil(L); lua_pushnil(L);
return 1; /* TODO return error message */ return 1; /* TODO return error message */
} }
strcpy(string, s); strcpy(string, s);
ret = stringprep(string, 1024, (Stringprep_profile_flags)0, profile); ret = stringprep(string, 1024, (Stringprep_profile_flags)0, profile);
if (ret == STRINGPREP_OK) {
if(ret == STRINGPREP_OK) {
lua_pushstring(L, string); lua_pushstring(L, string);
return 1; return 1;
} else { } else {
@ -323,8 +385,7 @@ MAKE_PREP_FUNC(Lstringprep_nodeprep, stringprep_xmpp_nodeprep) /** stringprep.n
MAKE_PREP_FUNC(Lstringprep_resourceprep, stringprep_xmpp_resourceprep) /** stringprep.resourceprep(s) */ MAKE_PREP_FUNC(Lstringprep_resourceprep, stringprep_xmpp_resourceprep) /** stringprep.resourceprep(s) */
MAKE_PREP_FUNC(Lstringprep_saslprep, stringprep_saslprep) /** stringprep.saslprep(s) */ MAKE_PREP_FUNC(Lstringprep_saslprep, stringprep_saslprep) /** stringprep.saslprep(s) */
static const luaL_Reg Reg_stringprep[] = static const luaL_Reg Reg_stringprep[] = {
{
{ "nameprep", Lstringprep_nameprep }, { "nameprep", Lstringprep_nameprep },
{ "nodeprep", Lstringprep_nodeprep }, { "nodeprep", Lstringprep_nodeprep },
{ "resourceprep", Lstringprep_resourceprep }, { "resourceprep", Lstringprep_resourceprep },
@ -338,62 +399,70 @@ static const luaL_Reg Reg_stringprep[] =
#include <unicode/ustdio.h> #include <unicode/ustdio.h>
#include <unicode/uidna.h> #include <unicode/uidna.h>
/* IDNA2003 or IDNA2008 ? ? ? */ /* IDNA2003 or IDNA2008 ? ? ? */
static int Lidna_to_ascii(lua_State *L) /** idna.to_ascii(s) */ static int Lidna_to_ascii(lua_State* L) { /** idna.to_ascii(s) */
{
size_t len; size_t len;
int32_t ulen, dest_len, output_len; int32_t ulen, dest_len, output_len;
const char *s = luaL_checklstring(L, 1, &len); const char* s = luaL_checklstring(L, 1, &len);
UChar ustr[1024]; UChar ustr[1024];
UErrorCode err = U_ZERO_ERROR; UErrorCode err = U_ZERO_ERROR;
UChar dest[1024]; UChar dest[1024];
char output[1024]; char output[1024];
u_strFromUTF8(ustr, 1024, &ulen, s, len, &err); u_strFromUTF8(ustr, 1024, &ulen, s, len, &err);
if (U_FAILURE(err)) {
if(U_FAILURE(err)) {
lua_pushnil(L); lua_pushnil(L);
return 1; return 1;
} }
dest_len = uidna_IDNToASCII(ustr, ulen, dest, 1024, UIDNA_USE_STD3_RULES, NULL, &err); dest_len = uidna_IDNToASCII(ustr, ulen, dest, 1024, UIDNA_USE_STD3_RULES, NULL, &err);
if (U_FAILURE(err)) {
if(U_FAILURE(err)) {
lua_pushnil(L); lua_pushnil(L);
return 1; return 1;
} else { } else {
u_strToUTF8(output, 1024, &output_len, dest, dest_len, &err); u_strToUTF8(output, 1024, &output_len, dest, dest_len, &err);
if (U_SUCCESS(err) && output_len < 1024)
if(U_SUCCESS(err) && output_len < 1024) {
lua_pushlstring(L, output, output_len); lua_pushlstring(L, output, output_len);
else } else {
lua_pushnil(L); lua_pushnil(L);
}
return 1; return 1;
} }
} }
static int Lidna_to_unicode(lua_State *L) /** idna.to_unicode(s) */ static int Lidna_to_unicode(lua_State* L) { /** idna.to_unicode(s) */
{
size_t len; size_t len;
int32_t ulen, dest_len, output_len; int32_t ulen, dest_len, output_len;
const char *s = luaL_checklstring(L, 1, &len); const char* s = luaL_checklstring(L, 1, &len);
UChar ustr[1024]; UChar ustr[1024];
UErrorCode err = U_ZERO_ERROR; UErrorCode err = U_ZERO_ERROR;
UChar dest[1024]; UChar dest[1024];
char output[1024]; char output[1024];
u_strFromUTF8(ustr, 1024, &ulen, s, len, &err); u_strFromUTF8(ustr, 1024, &ulen, s, len, &err);
if (U_FAILURE(err)) {
if(U_FAILURE(err)) {
lua_pushnil(L); lua_pushnil(L);
return 1; return 1;
} }
dest_len = uidna_IDNToUnicode(ustr, ulen, dest, 1024, UIDNA_USE_STD3_RULES, NULL, &err); dest_len = uidna_IDNToUnicode(ustr, ulen, dest, 1024, UIDNA_USE_STD3_RULES, NULL, &err);
if (U_FAILURE(err)) {
if(U_FAILURE(err)) {
lua_pushnil(L); lua_pushnil(L);
return 1; return 1;
} else { } else {
u_strToUTF8(output, 1024, &output_len, dest, dest_len, &err); u_strToUTF8(output, 1024, &output_len, dest, dest_len, &err);
if (U_SUCCESS(err) && output_len < 1024)
if(U_SUCCESS(err) && output_len < 1024) {
lua_pushlstring(L, output, output_len); lua_pushlstring(L, output, output_len);
else } else {
lua_pushnil(L); lua_pushnil(L);
}
return 1; return 1;
} }
} }
@ -404,17 +473,19 @@ static int Lidna_to_unicode(lua_State *L) /** idna.to_unicode(s) */
#include <idna.h> #include <idna.h>
#include <idn-free.h> #include <idn-free.h>
static int Lidna_to_ascii(lua_State *L) /** idna.to_ascii(s) */ static int Lidna_to_ascii(lua_State* L) { /** idna.to_ascii(s) */
{
size_t len; size_t len;
const char *s = check_utf8(L, 1, &len); const char* s = check_utf8(L, 1, &len);
if (s == NULL || len != strlen(s)) {
if(s == NULL || len != strlen(s)) {
lua_pushnil(L); lua_pushnil(L);
return 1; /* TODO return error message */ return 1; /* TODO return error message */
} }
char* output = NULL; char* output = NULL;
int ret = idna_to_ascii_8z(s, &output, IDNA_USE_STD3_ASCII_RULES); int ret = idna_to_ascii_8z(s, &output, IDNA_USE_STD3_ASCII_RULES);
if (ret == IDNA_SUCCESS) {
if(ret == IDNA_SUCCESS) {
lua_pushstring(L, output); lua_pushstring(L, output);
idn_free(output); idn_free(output);
return 1; return 1;
@ -425,13 +496,13 @@ static int Lidna_to_ascii(lua_State *L) /** idna.to_ascii(s) */
} }
} }
static int Lidna_to_unicode(lua_State *L) /** idna.to_unicode(s) */ static int Lidna_to_unicode(lua_State* L) { /** idna.to_unicode(s) */
{
size_t len; size_t len;
const char *s = luaL_checklstring(L, 1, &len); const char* s = luaL_checklstring(L, 1, &len);
char* output = NULL; char* output = NULL;
int ret = idna_to_unicode_8z8z(s, &output, 0); int ret = idna_to_unicode_8z8z(s, &output, 0);
if (ret == IDNA_SUCCESS) {
if(ret == IDNA_SUCCESS) {
lua_pushstring(L, output); lua_pushstring(L, output);
idn_free(output); idn_free(output);
return 1; return 1;
@ -443,8 +514,7 @@ static int Lidna_to_unicode(lua_State *L) /** idna.to_unicode(s) */
} }
#endif #endif
static const luaL_Reg Reg_idna[] = static const luaL_Reg Reg_idna[] = {
{
{ "to_ascii", Lidna_to_ascii }, { "to_ascii", Lidna_to_ascii },
{ "to_unicode", Lidna_to_unicode }, { "to_unicode", Lidna_to_unicode },
{ NULL, NULL } { NULL, NULL }
@ -452,8 +522,7 @@ static const luaL_Reg Reg_idna[] =
/***************** end *****************/ /***************** end *****************/
LUALIB_API int luaopen_util_encodings(lua_State *L) LUALIB_API int luaopen_util_encodings(lua_State* L) {
{
#ifdef USE_STRINGPREP_ICU #ifdef USE_STRINGPREP_ICU
init_icu(); init_icu();
#endif #endif

55
util-src/hashes.c
View file

@ -34,12 +34,13 @@ typedef unsigned __int32 uint32_t;
#define HMAC_IPAD 0x36363636 #define HMAC_IPAD 0x36363636
#define HMAC_OPAD 0x5c5c5c5c #define HMAC_OPAD 0x5c5c5c5c
const char *hex_tab = "0123456789abcdef"; const char* hex_tab = "0123456789abcdef";
void toHex(const unsigned char *in, int length, unsigned char *out) { void toHex(const unsigned char* in, int length, unsigned char* out) {
int i; int i;
for (i = 0; i < length; i++) {
out[i*2] = hex_tab[(in[i] >> 4) & 0xF]; for(i = 0; i < length; i++) {
out[i*2+1] = hex_tab[(in[i]) & 0xF]; out[i * 2] = hex_tab[(in[i] >> 4) & 0xF];
out[i * 2 + 1] = hex_tab[(in[i]) & 0xF];
} }
} }
@ -68,15 +69,14 @@ MAKE_HASH_FUNCTION(Lmd5, MD5, MD5_DIGEST_LENGTH)
struct hash_desc { struct hash_desc {
int (*Init)(void*); int (*Init)(void*);
int (*Update)(void*, const void *, size_t); int (*Update)(void*, const void*, size_t);
int (*Final)(unsigned char*, void*); int (*Final)(unsigned char*, void*);
size_t digestLength; size_t digestLength;
void *ctx, *ctxo; void* ctx, *ctxo;
}; };
static void hmac(struct hash_desc *desc, const char *key, size_t key_len, static void hmac(struct hash_desc* desc, const char* key, size_t key_len,
const char *msg, size_t msg_len, unsigned char *result) const char* msg, size_t msg_len, unsigned char* result) {
{
union xory { union xory {
unsigned char bytes[64]; unsigned char bytes[64];
uint32_t quadbytes[16]; uint32_t quadbytes[16];
@ -86,7 +86,7 @@ static void hmac(struct hash_desc *desc, const char *key, size_t key_len,
unsigned char hashedKey[64]; /* Maximum used digest length */ unsigned char hashedKey[64]; /* Maximum used digest length */
union xory k_ipad, k_opad; union xory k_ipad, k_opad;
if (key_len > 64) { if(key_len > 64) {
desc->Init(desc->ctx); desc->Init(desc->ctx);
desc->Update(desc->ctx, key, key_len); desc->Update(desc->ctx, key, key_len);
desc->Final(hashedKey, desc->ctx); desc->Final(hashedKey, desc->ctx);
@ -98,7 +98,7 @@ static void hmac(struct hash_desc *desc, const char *key, size_t key_len,
memset(k_ipad.bytes + key_len, 0, 64 - key_len); memset(k_ipad.bytes + key_len, 0, 64 - key_len);
memcpy(k_opad.bytes, k_ipad.bytes, 64); memcpy(k_opad.bytes, k_ipad.bytes, 64);
for (i = 0; i < 16; i++) { for(i = 0; i < 16; i++) {
k_ipad.quadbytes[i] ^= HMAC_IPAD; k_ipad.quadbytes[i] ^= HMAC_IPAD;
k_opad.quadbytes[i] ^= HMAC_OPAD; k_opad.quadbytes[i] ^= HMAC_OPAD;
} }
@ -143,10 +143,10 @@ MAKE_HMAC_FUNCTION(Lhmac_sha256, SHA256, SHA256_DIGEST_LENGTH, SHA256_CTX)
MAKE_HMAC_FUNCTION(Lhmac_sha512, SHA512, SHA512_DIGEST_LENGTH, SHA512_CTX) MAKE_HMAC_FUNCTION(Lhmac_sha512, SHA512, SHA512_DIGEST_LENGTH, SHA512_CTX)
MAKE_HMAC_FUNCTION(Lhmac_md5, MD5, MD5_DIGEST_LENGTH, MD5_CTX) MAKE_HMAC_FUNCTION(Lhmac_md5, MD5, MD5_DIGEST_LENGTH, MD5_CTX)
static int LscramHi(lua_State *L) { static int LscramHi(lua_State* L) {
union xory { union xory {
unsigned char bytes[SHA_DIGEST_LENGTH]; unsigned char bytes[SHA_DIGEST_LENGTH];
uint32_t quadbytes[SHA_DIGEST_LENGTH/4]; uint32_t quadbytes[SHA_DIGEST_LENGTH / 4];
}; };
int i; int i;
SHA_CTX ctx, ctxo; SHA_CTX ctx, ctxo;
@ -155,32 +155,39 @@ static int LscramHi(lua_State *L) {
union xory res; union xory res;
size_t str_len, salt_len; size_t str_len, salt_len;
struct hash_desc desc; struct hash_desc desc;
const char *str = luaL_checklstring(L, 1, &str_len); const char* str = luaL_checklstring(L, 1, &str_len);
const char *salt = luaL_checklstring(L, 2, &salt_len); const char* salt = luaL_checklstring(L, 2, &salt_len);
char *salt2; char* salt2;
const int iter = luaL_checkinteger(L, 3); const int iter = luaL_checkinteger(L, 3);
desc.Init = (int (*)(void*))SHA1_Init; desc.Init = (int (*)(void*))SHA1_Init;
desc.Update = (int (*)(void*, const void *, size_t))SHA1_Update; desc.Update = (int (*)(void*, const void*, size_t))SHA1_Update;
desc.Final = (int (*)(unsigned char*, void*))SHA1_Final; desc.Final = (int (*)(unsigned char*, void*))SHA1_Final;
desc.digestLength = SHA_DIGEST_LENGTH; desc.digestLength = SHA_DIGEST_LENGTH;
desc.ctx = &ctx; desc.ctx = &ctx;
desc.ctxo = &ctxo; desc.ctxo = &ctxo;
salt2 = malloc(salt_len + 4); salt2 = malloc(salt_len + 4);
if (salt2 == NULL)
if(salt2 == NULL) {
luaL_error(L, "Out of memory in scramHi"); luaL_error(L, "Out of memory in scramHi");
}
memcpy(salt2, salt, salt_len); memcpy(salt2, salt, salt_len);
memcpy(salt2 + salt_len, "\0\0\0\1", 4); memcpy(salt2 + salt_len, "\0\0\0\1", 4);
hmac(&desc, str, str_len, salt2, salt_len + 4, Ust); hmac(&desc, str, str_len, salt2, salt_len + 4, Ust);
free(salt2); free(salt2);
memcpy(res.bytes, Ust, sizeof(res)); memcpy(res.bytes, Ust, sizeof(res));
for (i = 1; i < iter; i++) {
for(i = 1; i < iter; i++) {
int j; int j;
hmac(&desc, str, str_len, (char*)Ust, sizeof(Ust), Und.bytes); hmac(&desc, str, str_len, (char*)Ust, sizeof(Ust), Und.bytes);
for (j = 0; j < SHA_DIGEST_LENGTH/4; j++)
for(j = 0; j < SHA_DIGEST_LENGTH / 4; j++) {
res.quadbytes[j] ^= Und.quadbytes[j]; res.quadbytes[j] ^= Und.quadbytes[j];
}
memcpy(Ust, Und.bytes, sizeof(Ust)); memcpy(Ust, Und.bytes, sizeof(Ust));
} }
@ -189,8 +196,7 @@ static int LscramHi(lua_State *L) {
return 1; return 1;
} }
static const luaL_Reg Reg[] = static const luaL_Reg Reg[] = {
{
{ "sha1", Lsha1 }, { "sha1", Lsha1 },
{ "sha224", Lsha224 }, { "sha224", Lsha224 },
{ "sha256", Lsha256 }, { "sha256", Lsha256 },
@ -205,8 +211,7 @@ static const luaL_Reg Reg[] =
{ NULL, NULL } { NULL, NULL }
}; };
LUALIB_API int luaopen_util_hashes(lua_State *L) LUALIB_API int luaopen_util_hashes(lua_State* L) {
{
lua_newtable(L); lua_newtable(L);
luaL_register(L, NULL, Reg); luaL_register(L, NULL, Reg);
lua_pushliteral(L, "-3.14"); lua_pushliteral(L, "-3.14");

68
util-src/net.c
View file

@ -14,13 +14,13 @@
#include <errno.h> #include <errno.h>
#ifndef _WIN32 #ifndef _WIN32
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <net/if.h> #include <net/if.h>
#include <ifaddrs.h> #include <ifaddrs.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <netinet/in.h> #include <netinet/in.h>
#endif #endif
#include <lua.h> #include <lua.h>
@ -32,20 +32,19 @@
/* Enumerate all locally configured IP addresses */ /* Enumerate all locally configured IP addresses */
const char * const type_strings[] = { const char* const type_strings[] = {
"both", "both",
"ipv4", "ipv4",
"ipv6", "ipv6",
NULL NULL
}; };
static int lc_local_addresses(lua_State *L) static int lc_local_addresses(lua_State* L) {
{
#ifndef _WIN32 #ifndef _WIN32
/* Link-local IPv4 addresses; see RFC 3927 and RFC 5735 */ /* Link-local IPv4 addresses; see RFC 3927 and RFC 5735 */
const long ip4_linklocal = htonl(0xa9fe0000); /* 169.254.0.0 */ const long ip4_linklocal = htonl(0xa9fe0000); /* 169.254.0.0 */
const long ip4_mask = htonl(0xffff0000); const long ip4_mask = htonl(0xffff0000);
struct ifaddrs *addr = NULL, *a; struct ifaddrs* addr = NULL, *a;
#endif #endif
int n = 1; int n = 1;
int type = luaL_checkoption(L, 1, "both", type_strings); int type = luaL_checkoption(L, 1, "both", type_strings);
@ -54,63 +53,78 @@ static int lc_local_addresses(lua_State *L)
const char ipv6 = (type == 0 || type == 2); const char ipv6 = (type == 0 || type == 2);
#ifndef _WIN32 #ifndef _WIN32
if (getifaddrs(&addr) < 0) {
if(getifaddrs(&addr) < 0) {
lua_pushnil(L); lua_pushnil(L);
lua_pushfstring(L, "getifaddrs failed (%d): %s", errno, lua_pushfstring(L, "getifaddrs failed (%d): %s", errno,
strerror(errno)); strerror(errno));
return 2; return 2;
} }
#endif #endif
lua_newtable(L); lua_newtable(L);
#ifndef _WIN32 #ifndef _WIN32
for (a = addr; a; a = a->ifa_next) {
for(a = addr; a; a = a->ifa_next) {
int family; int family;
char ipaddr[INET6_ADDRSTRLEN]; char ipaddr[INET6_ADDRSTRLEN];
const char *tmp = NULL; const char* tmp = NULL;
if (a->ifa_addr == NULL || a->ifa_flags & IFF_LOOPBACK) if(a->ifa_addr == NULL || a->ifa_flags & IFF_LOOPBACK) {
continue; continue;
}
family = a->ifa_addr->sa_family; family = a->ifa_addr->sa_family;
if (ipv4 && family == AF_INET) { if(ipv4 && family == AF_INET) {
struct sockaddr_in *sa = (struct sockaddr_in *)a->ifa_addr; struct sockaddr_in* sa = (struct sockaddr_in*)a->ifa_addr;
if (!link_local &&((sa->sin_addr.s_addr & ip4_mask) == ip4_linklocal))
if(!link_local && ((sa->sin_addr.s_addr & ip4_mask) == ip4_linklocal)) {
continue; continue;
}
tmp = inet_ntop(family, &sa->sin_addr, ipaddr, sizeof(ipaddr)); tmp = inet_ntop(family, &sa->sin_addr, ipaddr, sizeof(ipaddr));
} else if (ipv6 && family == AF_INET6) { } else if(ipv6 && family == AF_INET6) {
struct sockaddr_in6 *sa = (struct sockaddr_in6 *)a->ifa_addr; struct sockaddr_in6* sa = (struct sockaddr_in6*)a->ifa_addr;
if (!link_local && IN6_IS_ADDR_LINKLOCAL(&sa->sin6_addr))
if(!link_local && IN6_IS_ADDR_LINKLOCAL(&sa->sin6_addr)) {
continue; continue;
if (IN6_IS_ADDR_V4MAPPED(&sa->sin6_addr) || IN6_IS_ADDR_V4COMPAT(&sa->sin6_addr)) }
if(IN6_IS_ADDR_V4MAPPED(&sa->sin6_addr) || IN6_IS_ADDR_V4COMPAT(&sa->sin6_addr)) {
continue; continue;
}
tmp = inet_ntop(family, &sa->sin6_addr, ipaddr, sizeof(ipaddr)); tmp = inet_ntop(family, &sa->sin6_addr, ipaddr, sizeof(ipaddr));
} }
if (tmp != NULL) { if(tmp != NULL) {
lua_pushstring(L, tmp); lua_pushstring(L, tmp);
lua_rawseti(L, -2, n++); lua_rawseti(L, -2, n++);
} }
/* TODO: Error reporting? */ /* TODO: Error reporting? */
} }
freeifaddrs(addr); freeifaddrs(addr);
#else #else
if (ipv4) {
if(ipv4) {
lua_pushstring(L, "0.0.0.0"); lua_pushstring(L, "0.0.0.0");
lua_rawseti(L, -2, n++); lua_rawseti(L, -2, n++);
} }
if (ipv6) {
if(ipv6) {
lua_pushstring(L, "::"); lua_pushstring(L, "::");
lua_rawseti(L, -2, n++); lua_rawseti(L, -2, n++);
} }
#endif #endif
return 1; return 1;
} }
int luaopen_util_net(lua_State* L) int luaopen_util_net(lua_State* L) {
{
luaL_Reg exports[] = { luaL_Reg exports[] = {
{ "local_addresses", lc_local_addresses }, { "local_addresses", lc_local_addresses },
{ NULL, NULL } { NULL, NULL }

361
util-src/pposix.c
View file

@ -45,34 +45,29 @@
#endif #endif
#if (defined(_SVID_SOURCE) && !defined(WITHOUT_MALLINFO)) #if (defined(_SVID_SOURCE) && !defined(WITHOUT_MALLINFO))
#include <malloc.h> #include <malloc.h>
#define WITH_MALLINFO #define WITH_MALLINFO
#endif #endif
/* Daemonization support */ /* Daemonization support */
static int lc_daemonize(lua_State *L) static int lc_daemonize(lua_State* L) {
{
pid_t pid; pid_t pid;
if ( getppid() == 1 ) if(getppid() == 1) {
{
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "already-daemonized"); lua_pushstring(L, "already-daemonized");
return 2; return 2;
} }
/* Attempt initial fork */ /* Attempt initial fork */
if((pid = fork()) < 0) if((pid = fork()) < 0) {
{
/* Forking failed */ /* Forking failed */
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "fork-failed"); lua_pushstring(L, "fork-failed");
return 2; return 2;
} } else if(pid != 0) {
else if(pid != 0)
{
/* We are the parent process */ /* We are the parent process */
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
lua_pushnumber(L, pid); lua_pushnumber(L, pid);
@ -80,8 +75,7 @@ static int lc_daemonize(lua_State *L)
} }
/* and we are the child process */ /* and we are the child process */
if(setsid() == -1) if(setsid() == -1) {
{
/* We failed to become session leader */ /* We failed to become session leader */
/* (we probably already were) */ /* (we probably already were) */
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
@ -99,8 +93,9 @@ static int lc_daemonize(lua_State *L)
open("/dev/null", O_WRONLY); open("/dev/null", O_WRONLY);
/* Final fork, use it wisely */ /* Final fork, use it wisely */
if(fork()) if(fork()) {
exit(0); exit(0);
}
/* Show's over, let's continue */ /* Show's over, let's continue */
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
@ -110,7 +105,7 @@ static int lc_daemonize(lua_State *L)
/* Syslog support */ /* Syslog support */
const char * const facility_strings[] = { const char* const facility_strings[] = {
"auth", "auth",
#if !(defined(sun) || defined(__sun)) #if !(defined(sun) || defined(__sun))
"authpriv", "authpriv",
@ -135,7 +130,7 @@ const char * const facility_strings[] = {
"user", "user",
"uucp", "uucp",
NULL NULL
}; };
int facility_constants[] = { int facility_constants[] = {
LOG_AUTH, LOG_AUTH,
#if !(defined(sun) || defined(__sun)) #if !(defined(sun) || defined(__sun))
@ -162,7 +157,7 @@ int facility_constants[] = {
LOG_USER, LOG_USER,
LOG_UUCP, LOG_UUCP,
-1 -1
}; };
/* " /* "
The parameter ident in the call of openlog() is probably stored as-is. The parameter ident in the call of openlog() is probably stored as-is.
@ -174,15 +169,15 @@ int facility_constants[] = {
*/ */
char* syslog_ident = NULL; char* syslog_ident = NULL;
int lc_syslog_open(lua_State* L) int lc_syslog_open(lua_State* L) {
{
int facility = luaL_checkoption(L, 2, "daemon", facility_strings); int facility = luaL_checkoption(L, 2, "daemon", facility_strings);
facility = facility_constants[facility]; facility = facility_constants[facility];
luaL_checkstring(L, 1); luaL_checkstring(L, 1);
if(syslog_ident) if(syslog_ident) {
free(syslog_ident); free(syslog_ident);
}
syslog_ident = strdup(lua_tostring(L, 1)); syslog_ident = strdup(lua_tostring(L, 1));
@ -190,14 +185,14 @@ int lc_syslog_open(lua_State* L)
return 0; return 0;
} }
const char * const level_strings[] = { const char* const level_strings[] = {
"debug", "debug",
"info", "info",
"notice", "notice",
"warn", "warn",
"error", "error",
NULL NULL
}; };
int level_constants[] = { int level_constants[] = {
LOG_DEBUG, LOG_DEBUG,
LOG_INFO, LOG_INFO,
@ -205,38 +200,37 @@ int level_constants[] = {
LOG_WARNING, LOG_WARNING,
LOG_CRIT, LOG_CRIT,
-1 -1
}; };
int lc_syslog_log(lua_State* L) int lc_syslog_log(lua_State* L) {
{
int level = level_constants[luaL_checkoption(L, 1, "notice", level_strings)]; int level = level_constants[luaL_checkoption(L, 1, "notice", level_strings)];
if(lua_gettop(L) == 3) if(lua_gettop(L) == 3) {
syslog(level, "%s: %s", luaL_checkstring(L, 2), luaL_checkstring(L, 3)); syslog(level, "%s: %s", luaL_checkstring(L, 2), luaL_checkstring(L, 3));
else } else {
syslog(level, "%s", lua_tostring(L, 2)); syslog(level, "%s", lua_tostring(L, 2));
}
return 0; return 0;
} }
int lc_syslog_close(lua_State* L) int lc_syslog_close(lua_State* L) {
{
closelog(); closelog();
if(syslog_ident)
{ if(syslog_ident) {
free(syslog_ident); free(syslog_ident);
syslog_ident = NULL; syslog_ident = NULL;
} }
return 0; return 0;
} }
int lc_syslog_setmask(lua_State* L) int lc_syslog_setmask(lua_State* L) {
{
int level_idx = luaL_checkoption(L, 1, "notice", level_strings); int level_idx = luaL_checkoption(L, 1, "notice", level_strings);
int mask = 0; int mask = 0;
do
{ do {
mask |= LOG_MASK(level_constants[level_idx]); mask |= LOG_MASK(level_constants[level_idx]);
} while (++level_idx<=4); } while(++level_idx <= 4);
setlogmask(mask); setlogmask(mask);
return 0; return 0;
@ -244,59 +238,55 @@ int lc_syslog_setmask(lua_State* L)
/* getpid */ /* getpid */
int lc_getpid(lua_State* L) int lc_getpid(lua_State* L) {
{
lua_pushinteger(L, getpid()); lua_pushinteger(L, getpid());
return 1; return 1;
} }
/* UID/GID functions */ /* UID/GID functions */
int lc_getuid(lua_State* L) int lc_getuid(lua_State* L) {
{
lua_pushinteger(L, getuid()); lua_pushinteger(L, getuid());
return 1; return 1;
} }
int lc_getgid(lua_State* L) int lc_getgid(lua_State* L) {
{
lua_pushinteger(L, getgid()); lua_pushinteger(L, getgid());
return 1; return 1;
} }
int lc_setuid(lua_State* L) int lc_setuid(lua_State* L) {
{
int uid = -1; int uid = -1;
if(lua_gettop(L) < 1)
if(lua_gettop(L) < 1) {
return 0; return 0;
if(!lua_isnumber(L, 1) && lua_tostring(L, 1)) }
{
if(!lua_isnumber(L, 1) && lua_tostring(L, 1)) {
/* Passed UID is actually a string, so look up the UID */ /* Passed UID is actually a string, so look up the UID */
struct passwd *p; struct passwd* p;
p = getpwnam(lua_tostring(L, 1)); p = getpwnam(lua_tostring(L, 1));
if(!p)
{ if(!p) {
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "no-such-user"); lua_pushstring(L, "no-such-user");
return 2; return 2;
} }
uid = p->pw_uid; uid = p->pw_uid;
} } else {
else
{
uid = lua_tonumber(L, 1); uid = lua_tonumber(L, 1);
} }
if(uid>-1) if(uid > -1) {
{
/* Ok, attempt setuid */ /* Ok, attempt setuid */
errno = 0; errno = 0;
if(setuid(uid))
{ if(setuid(uid)) {
/* Fail */ /* Fail */
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
switch(errno)
{ switch(errno) {
case EINVAL: case EINVAL:
lua_pushstring(L, "invalid-uid"); lua_pushstring(L, "invalid-uid");
break; break;
@ -306,10 +296,9 @@ int lc_setuid(lua_State* L)
default: default:
lua_pushstring(L, "unknown-error"); lua_pushstring(L, "unknown-error");
} }
return 2; return 2;
} } else {
else
{
/* Success! */ /* Success! */
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
return 1; return 1;
@ -322,39 +311,38 @@ int lc_setuid(lua_State* L)
return 2; return 2;
} }
int lc_setgid(lua_State* L) int lc_setgid(lua_State* L) {
{
int gid = -1; int gid = -1;
if(lua_gettop(L) < 1)
if(lua_gettop(L) < 1) {
return 0; return 0;
if(!lua_isnumber(L, 1) && lua_tostring(L, 1)) }
{
if(!lua_isnumber(L, 1) && lua_tostring(L, 1)) {
/* Passed GID is actually a string, so look up the GID */ /* Passed GID is actually a string, so look up the GID */
struct group *g; struct group* g;
g = getgrnam(lua_tostring(L, 1)); g = getgrnam(lua_tostring(L, 1));
if(!g)
{ if(!g) {
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "no-such-group"); lua_pushstring(L, "no-such-group");
return 2; return 2;
} }
gid = g->gr_gid; gid = g->gr_gid;
} } else {
else
{
gid = lua_tonumber(L, 1); gid = lua_tonumber(L, 1);
} }
if(gid>-1) if(gid > -1) {
{
/* Ok, attempt setgid */ /* Ok, attempt setgid */
errno = 0; errno = 0;
if(setgid(gid))
{ if(setgid(gid)) {
/* Fail */ /* Fail */
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
switch(errno)
{ switch(errno) {
case EINVAL: case EINVAL:
lua_pushstring(L, "invalid-gid"); lua_pushstring(L, "invalid-gid");
break; break;
@ -364,10 +352,9 @@ int lc_setgid(lua_State* L)
default: default:
lua_pushstring(L, "unknown-error"); lua_pushstring(L, "unknown-error");
} }
return 2; return 2;
} } else {
else
{
/* Success! */ /* Success! */
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
return 1; return 1;
@ -380,29 +367,30 @@ int lc_setgid(lua_State* L)
return 2; return 2;
} }
int lc_initgroups(lua_State* L) int lc_initgroups(lua_State* L) {
{
int ret; int ret;
gid_t gid; gid_t gid;
struct passwd *p; struct passwd* p;
if(!lua_isstring(L, 1)) if(!lua_isstring(L, 1)) {
{
lua_pushnil(L); lua_pushnil(L);
lua_pushstring(L, "invalid-username"); lua_pushstring(L, "invalid-username");
return 2; return 2;
} }
p = getpwnam(lua_tostring(L, 1)); p = getpwnam(lua_tostring(L, 1));
if(!p)
{ if(!p) {
lua_pushnil(L); lua_pushnil(L);
lua_pushstring(L, "no-such-user"); lua_pushstring(L, "no-such-user");
return 2; return 2;
} }
if(lua_gettop(L) < 2)
if(lua_gettop(L) < 2) {
lua_pushnil(L); lua_pushnil(L);
switch(lua_type(L, 2)) }
{
switch(lua_type(L, 2)) {
case LUA_TNIL: case LUA_TNIL:
gid = p->pw_gid; gid = p->pw_gid;
break; break;
@ -414,11 +402,11 @@ int lc_initgroups(lua_State* L)
lua_pushstring(L, "invalid-gid"); lua_pushstring(L, "invalid-gid");
return 2; return 2;
} }
ret = initgroups(lua_tostring(L, 1), gid); ret = initgroups(lua_tostring(L, 1), gid);
if(ret)
{ if(ret) {
switch(errno) switch(errno) {
{
case ENOMEM: case ENOMEM:
lua_pushnil(L); lua_pushnil(L);
lua_pushstring(L, "no-memory"); lua_pushstring(L, "no-memory");
@ -431,39 +419,37 @@ int lc_initgroups(lua_State* L)
lua_pushnil(L); lua_pushnil(L);
lua_pushstring(L, "unknown-error"); lua_pushstring(L, "unknown-error");
} }
} } else {
else
{
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
lua_pushnil(L); lua_pushnil(L);
} }
return 2; return 2;
} }
int lc_umask(lua_State* L) int lc_umask(lua_State* L) {
{
char old_mode_string[7]; char old_mode_string[7];
mode_t old_mode = umask(strtoul(luaL_checkstring(L, 1), NULL, 8)); mode_t old_mode = umask(strtoul(luaL_checkstring(L, 1), NULL, 8));
snprintf(old_mode_string, sizeof(old_mode_string), "%03o", old_mode); snprintf(old_mode_string, sizeof(old_mode_string), "%03o", old_mode);
old_mode_string[sizeof(old_mode_string)-1] = 0; old_mode_string[sizeof(old_mode_string) - 1] = 0;
lua_pushstring(L, old_mode_string); lua_pushstring(L, old_mode_string);
return 1; return 1;
} }
int lc_mkdir(lua_State* L) int lc_mkdir(lua_State* L) {
{
int ret = mkdir(luaL_checkstring(L, 1), S_IRUSR | S_IWUSR | S_IXUSR int ret = mkdir(luaL_checkstring(L, 1), S_IRUSR | S_IWUSR | S_IXUSR
| S_IRGRP | S_IWGRP | S_IXGRP | S_IRGRP | S_IWGRP | S_IXGRP
| S_IROTH | S_IXOTH); /* mode 775 */ | S_IROTH | S_IXOTH); /* mode 775 */
lua_pushboolean(L, ret==0); lua_pushboolean(L, ret == 0);
if(ret)
{ if(ret) {
lua_pushstring(L, strerror(errno)); lua_pushstring(L, strerror(errno));
return 2; return 2;
} }
return 1; return 1;
} }
@ -477,20 +463,52 @@ int lc_mkdir(lua_State* L)
* Example usage: * Example usage:
* pposix.setrlimit("NOFILE", 1000, 2000) * pposix.setrlimit("NOFILE", 1000, 2000)
*/ */
int string2resource(const char *s) { int string2resource(const char* s) {
if (!strcmp(s, "CORE")) return RLIMIT_CORE; if(!strcmp(s, "CORE")) {
if (!strcmp(s, "CPU")) return RLIMIT_CPU; return RLIMIT_CORE;
if (!strcmp(s, "DATA")) return RLIMIT_DATA; }
if (!strcmp(s, "FSIZE")) return RLIMIT_FSIZE;
if (!strcmp(s, "NOFILE")) return RLIMIT_NOFILE; if(!strcmp(s, "CPU")) {
if (!strcmp(s, "STACK")) return RLIMIT_STACK; 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 !(defined(sun) || defined(__sun))
if (!strcmp(s, "MEMLOCK")) return RLIMIT_MEMLOCK;
if (!strcmp(s, "NPROC")) return RLIMIT_NPROC; if(!strcmp(s, "MEMLOCK")) {
if (!strcmp(s, "RSS")) return RLIMIT_RSS; return RLIMIT_MEMLOCK;
}
if(!strcmp(s, "NPROC")) {
return RLIMIT_NPROC;
}
if(!strcmp(s, "RSS")) {
return RLIMIT_RSS;
}
#endif #endif
#ifdef RLIMIT_NICE #ifdef RLIMIT_NICE
if (!strcmp(s, "NICE")) return RLIMIT_NICE;
if(!strcmp(s, "NICE")) {
return RLIMIT_NICE;
}
#endif #endif
return -1; return -1;
} }
@ -498,8 +516,11 @@ int string2resource(const char *s) {
unsigned long int arg_to_rlimit(lua_State* L, int idx, rlim_t current) { unsigned long int arg_to_rlimit(lua_State* L, int idx, rlim_t current) {
switch(lua_type(L, idx)) { switch(lua_type(L, idx)) {
case LUA_TSTRING: case LUA_TSTRING:
if(strcmp(lua_tostring(L, idx), "unlimited") == 0)
if(strcmp(lua_tostring(L, idx), "unlimited") == 0) {
return RLIM_INFINITY; return RLIM_INFINITY;
}
case LUA_TNUMBER: case LUA_TNUMBER:
return lua_tointeger(L, idx); return lua_tointeger(L, idx);
case LUA_TNONE: case LUA_TNONE:
@ -510,10 +531,11 @@ unsigned long int arg_to_rlimit(lua_State* L, int idx, rlim_t current) {
} }
} }
int lc_setrlimit(lua_State *L) { int lc_setrlimit(lua_State* L) {
struct rlimit lim; struct rlimit lim;
int arguments = lua_gettop(L); int arguments = lua_gettop(L);
int rid = -1; int rid = -1;
if(arguments < 1 || arguments > 3) { if(arguments < 1 || arguments > 3) {
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "incorrect-arguments"); lua_pushstring(L, "incorrect-arguments");
@ -521,14 +543,15 @@ int lc_setrlimit(lua_State *L) {
} }
rid = string2resource(luaL_checkstring(L, 1)); rid = string2resource(luaL_checkstring(L, 1));
if (rid == -1) {
if(rid == -1) {
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "invalid-resource"); lua_pushstring(L, "invalid-resource");
return 2; return 2;
} }
/* Fetch current values to use as defaults */ /* Fetch current values to use as defaults */
if (getrlimit(rid, &lim)) { if(getrlimit(rid, &lim)) {
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "getrlimit-failed"); lua_pushstring(L, "getrlimit-failed");
return 2; return 2;
@ -537,22 +560,23 @@ int lc_setrlimit(lua_State *L) {
lim.rlim_cur = arg_to_rlimit(L, 2, lim.rlim_cur); lim.rlim_cur = arg_to_rlimit(L, 2, lim.rlim_cur);
lim.rlim_max = arg_to_rlimit(L, 3, lim.rlim_max); lim.rlim_max = arg_to_rlimit(L, 3, lim.rlim_max);
if (setrlimit(rid, &lim)) { if(setrlimit(rid, &lim)) {
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "setrlimit-failed"); lua_pushstring(L, "setrlimit-failed");
return 2; return 2;
} }
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
return 1; return 1;
} }
int lc_getrlimit(lua_State *L) { int lc_getrlimit(lua_State* L) {
int arguments = lua_gettop(L); int arguments = lua_gettop(L);
const char *resource = NULL; const char* resource = NULL;
int rid = -1; int rid = -1;
struct rlimit lim; struct rlimit lim;
if (arguments != 1) { if(arguments != 1) {
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "invalid-arguments"); lua_pushstring(L, "invalid-arguments");
return 2; return 2;
@ -562,8 +586,9 @@ int lc_getrlimit(lua_State *L) {
resource = luaL_checkstring(L, 1); resource = luaL_checkstring(L, 1);
rid = string2resource(resource); rid = string2resource(resource);
if (rid != -1) {
if (getrlimit(rid, &lim)) { if(rid != -1) {
if(getrlimit(rid, &lim)) {
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
lua_pushstring(L, "getrlimit-failed."); lua_pushstring(L, "getrlimit-failed.");
return 2; return 2;
@ -574,33 +599,38 @@ int lc_getrlimit(lua_State *L) {
lua_pushstring(L, "invalid-resource"); lua_pushstring(L, "invalid-resource");
return 2; return 2;
} }
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
if(lim.rlim_cur == RLIM_INFINITY)
if(lim.rlim_cur == RLIM_INFINITY) {
lua_pushstring(L, "unlimited"); lua_pushstring(L, "unlimited");
else } else {
lua_pushnumber(L, lim.rlim_cur); lua_pushnumber(L, lim.rlim_cur);
if(lim.rlim_max == RLIM_INFINITY) }
if(lim.rlim_max == RLIM_INFINITY) {
lua_pushstring(L, "unlimited"); lua_pushstring(L, "unlimited");
else } else {
lua_pushnumber(L, lim.rlim_max); lua_pushnumber(L, lim.rlim_max);
}
return 3; return 3;
} }
int lc_abort(lua_State* L) int lc_abort(lua_State* L) {
{
abort(); abort();
return 0; return 0;
} }
int lc_uname(lua_State* L) int lc_uname(lua_State* L) {
{
struct utsname uname_info; struct utsname uname_info;
if(uname(&uname_info) != 0)
{ if(uname(&uname_info) != 0) {
lua_pushnil(L); lua_pushnil(L);
lua_pushstring(L, strerror(errno)); lua_pushstring(L, strerror(errno));
return 2; return 2;
} }
lua_newtable(L); lua_newtable(L);
lua_pushstring(L, uname_info.sysname); lua_pushstring(L, uname_info.sysname);
lua_setfield(L, -2, "sysname"); lua_setfield(L, -2, "sysname");
@ -615,28 +645,25 @@ int lc_uname(lua_State* L)
return 1; return 1;
} }
int lc_setenv(lua_State* L) int lc_setenv(lua_State* L) {
{ const char* var = luaL_checkstring(L, 1);
const char *var = luaL_checkstring(L, 1); const char* value;
const char *value;
/* If the second argument is nil or nothing, unset the var */ /* If the second argument is nil or nothing, unset the var */
if(lua_isnoneornil(L, 2)) if(lua_isnoneornil(L, 2)) {
{ if(unsetenv(var) != 0) {
if(unsetenv(var) != 0)
{
lua_pushnil(L); lua_pushnil(L);
lua_pushstring(L, strerror(errno)); lua_pushstring(L, strerror(errno));
return 2; return 2;
} }
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
return 1; return 1;
} }
value = luaL_checkstring(L, 2); value = luaL_checkstring(L, 2);
if(setenv(var, value, 1) != 0) if(setenv(var, value, 1) != 0) {
{
lua_pushnil(L); lua_pushnil(L);
lua_pushstring(L, strerror(errno)); lua_pushstring(L, strerror(errno));
return 2; return 2;
@ -647,8 +674,7 @@ int lc_setenv(lua_State* L)
} }
#ifdef WITH_MALLINFO #ifdef WITH_MALLINFO
int lc_meminfo(lua_State* L) int lc_meminfo(lua_State* L) {
{
struct mallinfo info = mallinfo(); struct mallinfo info = mallinfo();
lua_newtable(L); lua_newtable(L);
/* This is the total size of memory allocated with sbrk by malloc, in bytes. */ /* This is the total size of memory allocated with sbrk by malloc, in bytes. */
@ -676,13 +702,14 @@ int lc_meminfo(lua_State* L)
* */ * */
#if _XOPEN_SOURCE >= 600 || _POSIX_C_SOURCE >= 200112L || defined(_GNU_SOURCE) #if _XOPEN_SOURCE >= 600 || _POSIX_C_SOURCE >= 200112L || defined(_GNU_SOURCE)
int lc_fallocate(lua_State* L) int lc_fallocate(lua_State* L) {
{
int ret; int ret;
off_t offset, len; off_t offset, len;
FILE *f = *(FILE**) luaL_checkudata(L, 1, LUA_FILEHANDLE); FILE* f = *(FILE**) luaL_checkudata(L, 1, LUA_FILEHANDLE);
if (f == NULL)
if(f == NULL) {
luaL_error(L, "attempt to use a closed file"); luaL_error(L, "attempt to use a closed file");
}
offset = luaL_checkinteger(L, 2); offset = luaL_checkinteger(L, 2);
len = luaL_checkinteger(L, 3); len = luaL_checkinteger(L, 3);
@ -690,20 +717,23 @@ int lc_fallocate(lua_State* L)
#if defined(__linux__) && defined(_GNU_SOURCE) #if defined(__linux__) && defined(_GNU_SOURCE)
errno = 0; errno = 0;
ret = fallocate(fileno(f), FALLOC_FL_KEEP_SIZE, offset, len); ret = fallocate(fileno(f), FALLOC_FL_KEEP_SIZE, offset, len);
if(ret == 0)
{ if(ret == 0) {
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
return 1; return 1;
} }
/* Some old versions of Linux apparently use the return value instead of errno */
if(errno == 0) errno = ret;
if(errno != ENOSYS && errno != EOPNOTSUPP) /* Some old versions of Linux apparently use the return value instead of errno */
{ if(errno == 0) {
errno = ret;
}
if(errno != ENOSYS && errno != EOPNOTSUPP) {
lua_pushnil(L); lua_pushnil(L);
lua_pushstring(L, strerror(errno)); lua_pushstring(L, strerror(errno));
return 2; return 2;
} }
#else #else
#warning Only using posix_fallocate() fallback. #warning Only using posix_fallocate() fallback.
#warning Linux fallocate() is strongly recommended if available: recompile with -D_GNU_SOURCE #warning Linux fallocate() is strongly recommended if available: recompile with -D_GNU_SOURCE
@ -711,13 +741,11 @@ int lc_fallocate(lua_State* L)
#endif #endif
ret = posix_fallocate(fileno(f), offset, len); ret = posix_fallocate(fileno(f), offset, len);
if(ret == 0)
{ if(ret == 0) {
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
return 1; return 1;
} } else {
else
{
lua_pushnil(L); lua_pushnil(L);
lua_pushstring(L, strerror(ret)); lua_pushstring(L, strerror(ret));
/* posix_fallocate() can leave a bunch of NULs at the end, so we cut that /* posix_fallocate() can leave a bunch of NULs at the end, so we cut that
@ -730,8 +758,7 @@ int lc_fallocate(lua_State* L)
/* Register functions */ /* Register functions */
int luaopen_util_pposix(lua_State *L) int luaopen_util_pposix(lua_State* L) {
{
luaL_Reg exports[] = { luaL_Reg exports[] = {
{ "abort", lc_abort }, { "abort", lc_abort },

117
util-src/signal.c
View file

@ -40,9 +40,8 @@
#define lsig #define lsig
struct lua_signal struct lua_signal {
{ char* name; /* name of the signal */
char *name; /* name of the signal */
int sig; /* the signal */ int sig; /* the signal */
}; };
@ -154,30 +153,27 @@ static const struct lua_signal lua_signals[] = {
{NULL, 0} {NULL, 0}
}; };
static lua_State *Lsig = NULL; static lua_State* Lsig = NULL;
static lua_Hook Hsig = NULL; static lua_Hook Hsig = NULL;
static int Hmask = 0; static int Hmask = 0;
static int Hcount = 0; static int Hcount = 0;
static struct signal_event static struct signal_event {
{
int Nsig; int Nsig;
struct signal_event *next_event; struct signal_event* next_event;
} *signal_queue = NULL; }* signal_queue = NULL;
static struct signal_event *last_event = NULL; static struct signal_event* last_event = NULL;
static void sighook(lua_State *L, lua_Debug *ar) static void sighook(lua_State* L, lua_Debug* ar) {
{ struct signal_event* event;
struct signal_event *event;
/* restore the old hook */ /* restore the old hook */
lua_sethook(L, Hsig, Hmask, Hcount); lua_sethook(L, Hsig, Hmask, Hcount);
lua_pushstring(L, LUA_SIGNAL); lua_pushstring(L, LUA_SIGNAL);
lua_gettable(L, LUA_REGISTRYINDEX); lua_gettable(L, LUA_REGISTRYINDEX);
while((event = signal_queue)) while((event = signal_queue)) {
{
lua_pushnumber(L, event->Nsig); lua_pushnumber(L, event->Nsig);
lua_gettable(L, -2); lua_gettable(L, -2);
lua_call(L, 0, 0); lua_call(L, 0, 0);
@ -189,10 +185,8 @@ static void sighook(lua_State *L, lua_Debug *ar)
} }
static void handle(int sig) static void handle(int sig) {
{ if(!signal_queue) {
if(!signal_queue)
{
/* Store the existing debug hook (if any) and its parameters */ /* Store the existing debug hook (if any) and its parameters */
Hsig = lua_gethook(Lsig); Hsig = lua_gethook(Lsig);
Hmask = lua_gethookmask(Lsig); Hmask = lua_gethookmask(Lsig);
@ -206,9 +200,7 @@ static void handle(int sig)
/* Set our new debug hook */ /* Set our new debug hook */
lua_sethook(Lsig, sighook, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1); lua_sethook(Lsig, sighook, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
} } else {
else
{
last_event->next_event = malloc(sizeof(struct signal_event)); last_event->next_event = malloc(sizeof(struct signal_event));
last_event->next_event->Nsig = sig; last_event->next_event->Nsig = sig;
last_event->next_event->next_event = NULL; last_event->next_event->next_event = NULL;
@ -228,32 +220,34 @@ static void handle(int sig)
* in an unstable state. * in an unstable state.
*/ */
static int l_signal(lua_State *L) static int l_signal(lua_State* L) {
{
int args = lua_gettop(L); int args = lua_gettop(L);
int t, sig; /* type, signal */ int t, sig; /* type, signal */
/* get type of signal */ /* get type of signal */
luaL_checkany(L, 1); luaL_checkany(L, 1);
t = lua_type(L, 1); t = lua_type(L, 1);
if (t == LUA_TNUMBER)
if(t == LUA_TNUMBER) {
sig = (int) lua_tonumber(L, 1); sig = (int) lua_tonumber(L, 1);
else if (t == LUA_TSTRING) } else if(t == LUA_TSTRING) {
{
lua_pushstring(L, LUA_SIGNAL); lua_pushstring(L, LUA_SIGNAL);
lua_gettable(L, LUA_REGISTRYINDEX); lua_gettable(L, LUA_REGISTRYINDEX);
lua_pushvalue(L, 1); lua_pushvalue(L, 1);
lua_gettable(L, -2); lua_gettable(L, -2);
if (!lua_isnumber(L, -1))
if(!lua_isnumber(L, -1)) {
luaL_error(L, "invalid signal string"); luaL_error(L, "invalid signal string");
}
sig = (int) lua_tonumber(L, -1); sig = (int) lua_tonumber(L, -1);
lua_pop(L, 1); /* get rid of number we pushed */ lua_pop(L, 1); /* get rid of number we pushed */
} else } else {
luaL_checknumber(L, 1); /* will always error, with good error msg */ luaL_checknumber(L, 1); /* will always error, with good error msg */
}
/* set handler */ /* set handler */
if (args == 1 || lua_isnil(L, 2)) /* clear handler */ if(args == 1 || lua_isnil(L, 2)) { /* clear handler */
{
lua_pushstring(L, LUA_SIGNAL); lua_pushstring(L, LUA_SIGNAL);
lua_gettable(L, LUA_REGISTRYINDEX); lua_gettable(L, LUA_REGISTRYINDEX);
lua_pushnumber(L, sig); lua_pushnumber(L, sig);
@ -263,8 +257,7 @@ static int l_signal(lua_State *L)
lua_settable(L, -4); lua_settable(L, -4);
lua_remove(L, -2); /* remove LUA_SIGNAL table */ lua_remove(L, -2); /* remove LUA_SIGNAL table */
signal(sig, SIG_DFL); signal(sig, SIG_DFL);
} else } else {
{
luaL_checktype(L, 2, LUA_TFUNCTION); luaL_checktype(L, 2, LUA_TFUNCTION);
lua_pushstring(L, LUA_SIGNAL); lua_pushstring(L, LUA_SIGNAL);
@ -277,20 +270,21 @@ static int l_signal(lua_State *L)
/* Set the state for the handler */ /* Set the state for the handler */
Lsig = L; Lsig = L;
if (lua_toboolean(L, 3)) /* c hook? */ if(lua_toboolean(L, 3)) { /* c hook? */
{ if(signal(sig, handle) == SIG_ERR) {
if (signal(sig, handle) == SIG_ERR)
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
else } else {
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
} else /* lua_hook */ }
{ } else { /* lua_hook */
if (signal(sig, handle) == SIG_ERR) if(signal(sig, handle) == SIG_ERR) {
lua_pushboolean(L, 0); lua_pushboolean(L, 0);
else } else {
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
} }
} }
}
return 1; return 1;
} }
@ -300,8 +294,7 @@ static int l_signal(lua_State *L)
* signal = signal number or string * signal = signal number or string
*/ */
static int l_raise(lua_State *L) static int l_raise(lua_State* L) {
{
/* int args = lua_gettop(L); */ /* int args = lua_gettop(L); */
int t = 0; /* type */ int t = 0; /* type */
lua_Number ret; lua_Number ret;
@ -309,23 +302,26 @@ static int l_raise(lua_State *L)
luaL_checkany(L, 1); luaL_checkany(L, 1);
t = lua_type(L, 1); t = lua_type(L, 1);
if (t == LUA_TNUMBER)
{ if(t == LUA_TNUMBER) {
ret = (lua_Number) raise((int) lua_tonumber(L, 1)); ret = (lua_Number) raise((int) lua_tonumber(L, 1));
lua_pushnumber(L, ret); lua_pushnumber(L, ret);
} else if (t == LUA_TSTRING) } else if(t == LUA_TSTRING) {
{
lua_pushstring(L, LUA_SIGNAL); lua_pushstring(L, LUA_SIGNAL);
lua_gettable(L, LUA_REGISTRYINDEX); lua_gettable(L, LUA_REGISTRYINDEX);
lua_pushvalue(L, 1); lua_pushvalue(L, 1);
lua_gettable(L, -2); lua_gettable(L, -2);
if (!lua_isnumber(L, -1))
if(!lua_isnumber(L, -1)) {
luaL_error(L, "invalid signal string"); luaL_error(L, "invalid signal string");
}
ret = (lua_Number) raise((int) lua_tonumber(L, -1)); ret = (lua_Number) raise((int) lua_tonumber(L, -1));
lua_pop(L, 1); /* get rid of number we pushed */ lua_pop(L, 1); /* get rid of number we pushed */
lua_pushnumber(L, ret); lua_pushnumber(L, ret);
} else } else {
luaL_checknumber(L, 1); /* will always error, with good error msg */ luaL_checknumber(L, 1); /* will always error, with good error msg */
}
return 1; return 1;
} }
@ -341,8 +337,7 @@ static int l_raise(lua_State *L)
* signal = signal number or string * signal = signal number or string
*/ */
static int l_kill(lua_State *L) static int l_kill(lua_State* L) {
{
int t; /* type */ int t; /* type */
lua_Number ret; /* return value */ lua_Number ret; /* return value */
@ -350,25 +345,29 @@ static int l_kill(lua_State *L)
luaL_checkany(L, 2); /* check for a second arg */ luaL_checkany(L, 2); /* check for a second arg */
t = lua_type(L, 2); t = lua_type(L, 2);
if (t == LUA_TNUMBER)
{ if(t == LUA_TNUMBER) {
ret = (lua_Number) kill((int) lua_tonumber(L, 1), ret = (lua_Number) kill((int) lua_tonumber(L, 1),
(int) lua_tonumber(L, 2)); (int) lua_tonumber(L, 2));
lua_pushnumber(L, ret); lua_pushnumber(L, ret);
} else if (t == LUA_TSTRING) } else if(t == LUA_TSTRING) {
{
lua_pushstring(L, LUA_SIGNAL); lua_pushstring(L, LUA_SIGNAL);
lua_gettable(L, LUA_REGISTRYINDEX); lua_gettable(L, LUA_REGISTRYINDEX);
lua_pushvalue(L, 2); lua_pushvalue(L, 2);
lua_gettable(L, -2); lua_gettable(L, -2);
if (!lua_isnumber(L, -1))
if(!lua_isnumber(L, -1)) {
luaL_error(L, "invalid signal string"); luaL_error(L, "invalid signal string");
}
ret = (lua_Number) kill((int) lua_tonumber(L, 1), ret = (lua_Number) kill((int) lua_tonumber(L, 1),
(int) lua_tonumber(L, -1)); (int) lua_tonumber(L, -1));
lua_pop(L, 1); /* get rid of number we pushed */ lua_pop(L, 1); /* get rid of number we pushed */
lua_pushnumber(L, ret); lua_pushnumber(L, ret);
} else } else {
luaL_checknumber(L, 2); /* will always error, with good error msg */ luaL_checknumber(L, 2); /* will always error, with good error msg */
}
return 1; return 1;
} }
@ -383,8 +382,7 @@ static const struct luaL_Reg lsignal_lib[] = {
{NULL, NULL} {NULL, NULL}
}; };
int luaopen_util_signal(lua_State *L) int luaopen_util_signal(lua_State* L) {
{
int i = 0; int i = 0;
/* add the library */ /* add the library */
@ -397,8 +395,7 @@ int luaopen_util_signal(lua_State *L)
lua_pushstring(L, LUA_SIGNAL); lua_pushstring(L, LUA_SIGNAL);
lua_newtable(L); lua_newtable(L);
while (lua_signals[i].name != NULL) while(lua_signals[i].name != NULL) {
{
/* registry table */ /* registry table */
lua_pushstring(L, lua_signals[i].name); lua_pushstring(L, lua_signals[i].name);
lua_pushnumber(L, lua_signals[i].sig); lua_pushnumber(L, lua_signals[i].sig);

2
util-src/table.c
View file

@ -6,7 +6,7 @@ static int Lcreate_table(lua_State* L) {
return 1; return 1;
} }
int luaopen_util_table(lua_State *L) { int luaopen_util_table(lua_State* L) {
lua_newtable(L); lua_newtable(L);
lua_pushcfunction(L, Lcreate_table); lua_pushcfunction(L, Lcreate_table);
lua_setfield(L, -2, "create"); lua_setfield(L, -2, "create");

50
util-src/windows.c
View file

@ -23,23 +23,26 @@
#define luaL_register(L, N, R) luaL_setfuncs(L, R, 0) #define luaL_register(L, N, R) luaL_setfuncs(L, R, 0)
#endif #endif
static int Lget_nameservers(lua_State *L) { static int Lget_nameservers(lua_State* L) {
char stack_buffer[1024]; // stack allocated buffer char stack_buffer[1024]; // stack allocated buffer
IP4_ARRAY* ips = (IP4_ARRAY*) stack_buffer; IP4_ARRAY* ips = (IP4_ARRAY*) stack_buffer;
DWORD len = sizeof(stack_buffer); DWORD len = sizeof(stack_buffer);
DNS_STATUS status; DNS_STATUS status;
status = DnsQueryConfig(DnsConfigDnsServerList, FALSE, NULL, NULL, ips, &len); status = DnsQueryConfig(DnsConfigDnsServerList, FALSE, NULL, NULL, ips, &len);
if (status == 0) {
if(status == 0) {
DWORD i; DWORD i;
lua_createtable(L, ips->AddrCount, 0); lua_createtable(L, ips->AddrCount, 0);
for (i = 0; i < ips->AddrCount; i++) {
for(i = 0; i < ips->AddrCount; i++) {
DWORD ip = ips->AddrArray[i]; DWORD ip = ips->AddrArray[i];
char ip_str[16] = ""; char ip_str[16] = "";
sprintf_s(ip_str, sizeof(ip_str), "%d.%d.%d.%d", (ip >> 0) & 255, (ip >> 8) & 255, (ip >> 16) & 255, (ip >> 24) & 255); sprintf_s(ip_str, sizeof(ip_str), "%d.%d.%d.%d", (ip >> 0) & 255, (ip >> 8) & 255, (ip >> 16) & 255, (ip >> 24) & 255);
lua_pushstring(L, ip_str); lua_pushstring(L, ip_str);
lua_rawseti(L, -2, i+1); lua_rawseti(L, -2, i + 1);
} }
return 1; return 1;
} else { } else {
lua_pushnil(L); lua_pushnil(L);
@ -48,43 +51,58 @@ static int Lget_nameservers(lua_State *L) {
} }
} }
static int lerror(lua_State *L, char* string) { static int lerror(lua_State* L, char* string) {
lua_pushnil(L); lua_pushnil(L);
lua_pushfstring(L, "%s: %d", string, GetLastError()); lua_pushfstring(L, "%s: %d", string, GetLastError());
return 2; return 2;
} }
static int Lget_consolecolor(lua_State *L) { static int Lget_consolecolor(lua_State* L) {
HWND console = GetStdHandle(STD_OUTPUT_HANDLE); HWND console = GetStdHandle(STD_OUTPUT_HANDLE);
WORD color; DWORD read_len; WORD color;
DWORD read_len;
CONSOLE_SCREEN_BUFFER_INFO info; CONSOLE_SCREEN_BUFFER_INFO info;
if (console == INVALID_HANDLE_VALUE) return lerror(L, "GetStdHandle"); if(console == INVALID_HANDLE_VALUE) {
if (!GetConsoleScreenBufferInfo(console, &info)) return lerror(L, "GetConsoleScreenBufferInfo"); return lerror(L, "GetStdHandle");
if (!ReadConsoleOutputAttribute(console, &color, 1, info.dwCursorPosition, &read_len)) return lerror(L, "ReadConsoleOutputAttribute"); }
if(!GetConsoleScreenBufferInfo(console, &info)) {
return lerror(L, "GetConsoleScreenBufferInfo");
}
if(!ReadConsoleOutputAttribute(console, &color, 1, info.dwCursorPosition, &read_len)) {
return lerror(L, "ReadConsoleOutputAttribute");
}
lua_pushnumber(L, color); lua_pushnumber(L, color);
return 1; return 1;
} }
static int Lset_consolecolor(lua_State *L) { static int Lset_consolecolor(lua_State* L) {
int color = luaL_checkint(L, 1); int color = luaL_checkint(L, 1);
HWND console = GetStdHandle(STD_OUTPUT_HANDLE); HWND console = GetStdHandle(STD_OUTPUT_HANDLE);
if (console == INVALID_HANDLE_VALUE) return lerror(L, "GetStdHandle");
if (!SetConsoleTextAttribute(console, color)) return lerror(L, "SetConsoleTextAttribute"); if(console == INVALID_HANDLE_VALUE) {
return lerror(L, "GetStdHandle");
}
if(!SetConsoleTextAttribute(console, color)) {
return lerror(L, "SetConsoleTextAttribute");
}
lua_pushboolean(L, 1); lua_pushboolean(L, 1);
return 1; return 1;
} }
static const luaL_Reg Reg[] = static const luaL_Reg Reg[] = {
{
{ "get_nameservers", Lget_nameservers }, { "get_nameservers", Lget_nameservers },
{ "get_consolecolor", Lget_consolecolor }, { "get_consolecolor", Lget_consolecolor },
{ "set_consolecolor", Lset_consolecolor }, { "set_consolecolor", Lset_consolecolor },
{ NULL, NULL } { NULL, NULL }
}; };
LUALIB_API int luaopen_util_windows(lua_State *L) { LUALIB_API int luaopen_util_windows(lua_State* L) {
lua_newtable(L); lua_newtable(L);
luaL_register(L, NULL, Reg); luaL_register(L, NULL, Reg);
lua_pushliteral(L, "-3.14"); lua_pushliteral(L, "-3.14");