static int ctx_want_write(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
lua_pushboolean(L, mosquitto_want_write(ctx->mosq));
return 1;
}
static int ctx_loop_misc(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int rc = mosquitto_loop_misc(ctx->mosq);
return mosq__pstatus(L, rc);
}
static int ctx_will_clear(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int rc = mosquitto_will_clear(ctx->mosq);
return mosq__pstatus(L, rc);
}
static int ctx_disconnect(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int rc = mosquitto_disconnect(ctx->mosq);
return mosq__pstatus(L, rc);
}
static int ctx_loop_stop(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
bool force = lua_toboolean(L, 2);
int rc = mosquitto_loop_stop(ctx->mosq, force);
return mosq__pstatus(L, rc);
}
static int ctx_get_header_length(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
lua_pushinteger(L, modbus_get_header_length(ctx->modbus));
return 1;
}
static int ctx_get_socket(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
lua_pushinteger(L, modbus_get_socket(ctx->modbus));
return 1;
}
static int ctx_connect(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int rc = modbus_connect(ctx->modbus);
return libmodbus_rc_to_nil_error(L, rc, 0);
}
static int ctx_loop_write(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int max_packets = luaL_optinteger(L, 2, 1);
int rc = mosquitto_loop_write(ctx->mosq, max_packets);
return mosq__pstatus(L, rc);
}
static int ctx_set_socket(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int newfd = luaL_checknumber(L, 2);
modbus_set_socket(ctx->modbus, newfd);
return 0;
}
static int ctx_set_slave(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int slave = luaL_checknumber(L, 2);
int rc = modbus_set_slave(ctx->modbus, slave);
return libmodbus_rc_to_nil_error(L, rc, 0);
}
static int ctx_login_set(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
const char *username = (lua_isnil(L, 2) ? NULL : luaL_checkstring(L, 2));
const char *password = (lua_isnil(L, 3) ? NULL : luaL_checkstring(L, 3));
int rc = mosquitto_username_pw_set(ctx->mosq, username, password);
return mosq__pstatus(L, rc);
}
static int ctx_set_error_recovery(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int opt = luaL_checkinteger(L, 2);
int opt2 = luaL_optinteger(L, 3, 0);
int rc = modbus_set_error_recovery(ctx->modbus, opt | opt2);
return libmodbus_rc_to_nil_error(L, rc, 0);
}
static int ctx_connect_async(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
const char *host = luaL_optstring(L, 2, "localhost");
int port = luaL_optinteger(L, 3, 1883);
int keepalive = luaL_optinteger(L, 4, 60);
int rc = mosquitto_connect_async(ctx->mosq, host, port, keepalive);
return mosq__pstatus(L, rc);
}
static int ctx_write_register(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int addr = luaL_checknumber(L, 2);
int val = luaL_checknumber(L, 3);
int rc = modbus_write_register(ctx->modbus, addr, val);
return libmodbus_rc_to_nil_error(L, rc, 1);
}
int config_group_parse ( ctx_t *ctx_p, const char *const config_group_name )
{
int rc;
debug ( 1, "(ctx_p, \"%s\")", config_group_name );
ctx_p->config_group = config_group_name;
rc = configs_parse ( ctx_p, PS_CONTROL );
if ( !rc )
rc = ctx_check ( ctx_p );
return errno = rc;
}
static int ctx_set_debug(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
bool opt;
if (lua_isnil(L, -1)) {
opt = true;
} else {
opt = lua_toboolean(L, -1);
}
modbus_set_debug(ctx->modbus, opt);
return 0;
}
static int ctx_destroy(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
modbus_free(ctx->modbus);
/* remove all methods operating on ctx */
lua_newtable(L);
lua_setmetatable(L, -2);
/* Nothing to return on stack */
return 0;
}
static int ctx_write_bits(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int addr = luaL_checknumber(L, 2);
int rc;
int rcount;
/*
* TODO - could allow just a series of arguments too? easier for
* smaller sets?"?)
*/
luaL_checktype(L, 3, LUA_TTABLE);
/* array style table only! */
int count = lua_objlen(L, 3);
if (count > MODBUS_MAX_WRITE_BITS) {
return luaL_argerror(L, 3, "requested too many bits");
}
/* Convert table to uint8_t array */
uint8_t *buf = malloc(count * sizeof(uint8_t));
assert(buf);
for (int i = 1; i <= count; i++) {
bool ok = false;
lua_rawgeti(L, 3, i);
if (lua_type(L, -1) == LUA_TNUMBER) {
buf[i-1] = lua_tonumber(L, -1);
ok = true;
}
if (lua_type(L, -1) == LUA_TBOOLEAN) {
buf[i-1] = lua_toboolean(L, -1);
ok = true;
}
if (ok) {
lua_pop(L, 1);
} else {
free(buf);
return luaL_argerror(L, 3, "table values must be numeric or bool");
}
}
rc = modbus_write_bits(ctx->modbus, addr, count, buf);
if (rc == count) {
rcount = 1;
lua_pushboolean(L, true);
} else {
rcount = libmodbus_rc_to_nil_error(L, rc, count);
}
free(buf);
return rcount;
}
static int mosq_loop(lua_State *L, bool forever)
{
ctx_t *ctx = ctx_check(L, 1);
int timeout = luaL_optinteger(L, 2, -1);
int max_packets = luaL_optinteger(L, 3, 1);
int rc;
if (forever) {
rc = mosquitto_loop_forever(ctx->mosq, timeout, max_packets);
} else {
rc = mosquitto_loop(ctx->mosq, timeout, max_packets);
}
return mosq__pstatus(L, rc);
}
static int ctx_tcp_pi_listen(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int conns = luaL_optinteger(L, 2, 1);
int sock = modbus_tcp_pi_listen(ctx->modbus, conns);
if (sock == -1) {
return libmodbus_rc_to_nil_error(L, 0, 1);
}
lua_pushnumber(L, sock);
return 1;
}
static int ctx_tcp_pi_accept(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int sock = luaL_checknumber(L, 2);
sock = modbus_tcp_pi_accept(ctx->modbus, &sock);
if (sock == -1) {
return libmodbus_rc_to_nil_error(L, 0, 1);
}
lua_pushnumber(L, sock);
return 1;
}
static int ctx_reply_exception(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
const char *req = luaL_checklstring(L, 2, NULL);
int exception = luaL_checknumber(L, 3);
int rc = modbus_reply_exception(ctx->modbus, (uint8_t*)req, exception);
if (rc == -1) {
return libmodbus_rc_to_nil_error(L, 0, 1);
} else {
return libmodbus_rc_to_nil_error(L, rc, rc);
}
}
static int ctx_tls_set(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
const char *cafile = luaL_optstring(L, 2, NULL);
const char *capath = luaL_optstring(L, 3, NULL);
const char *certfile = luaL_optstring(L, 4, NULL);
const char *keyfile = luaL_optstring(L, 5, NULL);
// the last param is a callback to a function that asks for a passphrase for a keyfile
// our keyfiles should NOT have a passphrase
int rc = mosquitto_tls_set(ctx->mosq, cafile, capath, certfile, keyfile, 0);
return mosq__pstatus(L, rc);
}
static int ctx_destroy(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
mosquitto_destroy(ctx->mosq);
/* clean up Lua callback functions in the registry */
ctx__on_clear(ctx);
/* remove all methods operating on ctx */
lua_newtable(L);
lua_setmetatable(L, -2);
return mosq__pstatus(L, MOSQ_ERR_SUCCESS);
}
static int ctx_reply(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
size_t req_len;
const char *req = luaL_checklstring(L, 2, &req_len);
luaL_checktype(L, 3, LUA_TTABLE);
// FIXME - oh boy, probably need a whole lot of wrappers on the mappings?
//modbus_reply(ctx->modbus, (uint8_t*)req, req_len, mapping);
(void)ctx;
(void)req;
return luaL_error(L, "reply is simply unimplemented my friend!");
}
static int ctx_set_response_timeout(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int opt = luaL_checkinteger(L, 2);
int opt2 = luaL_optinteger(L, 3, 0);
#if LIBMODBUS_VERSION_CHECK(3,1,0)
modbus_set_response_timeout(ctx->modbus, opt, opt2);
#else
struct timeval t = { opt, opt2 };
modbus_set_response_timeout(ctx->modbus, &t);
#endif
return 0;
}
static int ctx_unsubscribe(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int mid;
const char *sub = luaL_checkstring(L, 2);
int rc = mosquitto_unsubscribe(ctx->mosq, &mid, sub);
if (rc != MOSQ_ERR_SUCCESS) {
return mosq__pstatus(L, rc);
} else {
lua_pushinteger(L, mid);
return 1;
}
}
static int ctx_socket(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int fd = mosquitto_socket(ctx->mosq);
switch (fd) {
case -1:
lua_pushboolean(L, false);
break;
default:
lua_pushinteger(L, fd);
break;
}
return 1;
}
static int ctx_will_set(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
const char *topic = luaL_checkstring(L, 2);
size_t payloadlen = 0;
const void *payload = NULL;
if (!lua_isnil(L, 3)) {
payload = lua_tolstring(L, 3, &payloadlen);
};
int qos = luaL_optinteger(L, 4, 0);
bool retain = lua_toboolean(L, 5);
int rc = mosquitto_will_set(ctx->mosq, topic, payloadlen, payload, qos, retain);
return mosq__pstatus(L, rc);
}
