/*
** Delete an entry.
** @param #1 LDAP connection.
** @param #2 String with entry's DN.
** @return Boolean.
*/
static int lualdap_delete (lua_State *L) {
conn_data *conn = getconnection (L);
ldap_pchar_t dn = (ldap_pchar_t) luaL_checkstring (L, 2);
ldap_int_t rc, msgid;
rc = ldap_delete_ext (conn->ld, dn, NULL, NULL, &msgid);
return create_future (L, rc, 1, msgid, LDAP_RES_DELETE);
}
/* destroy the session on the server side */
void destroysession()
{
int sd;
char *xml, query[256];
sprintf(query, "/destroysession.php?sessionid=%s", xmlxml.sessionid);
do
{
*xmlxml.error = 0;
sd = getconnection(host_entry, gijohnport);
getxml(sd, &xml, query, gijohnserver, gijohnport, 0);
close(sd);
parsexml(xml);
free(xml);
if (*xmlxml.error)
{
printf("[-] Error: destroying session: %s\n[+] Sleeping for %dsec... and resending\n", xmlxml.error, SLEEP_TIME);
sleep(SLEEP_TIME);
}
}
while (*xmlxml.error);
if (options.flags & FLG_VERBOSE) printf("[+] Session destroyed\n[+] Thanks for using GI John!\n");
return;
}
/*
** Sets the timeout for a lock in the connection.
*/
static int opts_settimeout (lua_State *L)
{
conn_data *conn = getconnection(L);
int milisseconds = luaL_checknumber(L, 2);
lua_pushnumber(L, sqlite3_busy_timeout(conn, milisseconds));
return 1;
}
/*
** Escapes a string for use within an SQL statement.
** Returns a string with the escaped string.
*/
static int conn_escape (lua_State *L) {
conn_data *conn = getconnection (L);
size_t len;
const char *from = luaL_checklstring (L, 2, &len);
int error;
int ret = 1;
luaL_Buffer b;
#if defined(luaL_buffinitsize)
char *to = luaL_buffinitsize (L, &b, 2*len+1);
#else
char *to;
luaL_buffinit (L, &b);
to = luaL_prepbuffer (&b);
#endif
len = PQescapeStringConn (conn->pg_conn, to, from, len, &error);
if (error == 0) { /* success ! */
#if defined(luaL_pushresultsize)
luaL_pushresultsize (&b, len);
#else
luaL_addsize (&b, len);
luaL_pushresult (&b);
#endif
} else {
ret = luasql_failmsg (L, "cannot escape string. PostgreSQL: ", PQerrorMessage (conn->pg_conn));
}
return ret;
}
/*
** Set "auto commit" property of the connection.
** If 'true', then rollback current transaction.
** If 'false', then start a new transaction.
*/
static int conn_setautocommit(lua_State *L)
{
conn_data *conn = getconnection(L);
if (lua_toboolean(L, 2))
{
conn->auto_commit = 1;
/* undo active transaction - ignore errors */
sqlite3_exec(conn->sql_conn, "ROLLBACK", NULL, NULL, NULL);
}
else
{
char *errmsg;
int res;
conn->auto_commit = 0;
res = sqlite3_exec(conn->sql_conn, "BEGIN", NULL, NULL, &errmsg);
if (res != SQLITE_OK)
{
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
sqlite3_free(errmsg);
lua_concat(L, 2);
lua_error(L);
}
}
lua_pushboolean(L, 1);
return 1;
}
/*
** Perform a search operation.
** @return #1 Function to iterate over the result entries.
** @return #2 nil.
** @return #3 nil as first entry.
** The search result is defined as an upvalue of the iterator.
*/
static int lualdap_search (lua_State *L) {
conn_data *conn = getconnection (L);
ldap_pchar_t base;
ldap_pchar_t filter;
char *attrs[LUALDAP_MAX_ATTRS];
int scope, attrsonly, msgid, rc, sizelimit;
struct timeval st, *timeout;
if (!lua_istable (L, 2))
return luaL_error (L, LUALDAP_PREFIX"no search specification");
if (!get_attrs_param (L, attrs))
return 2;
/* get other parameters */
attrsonly = booltabparam (L, "attrsonly", 0);
base = (ldap_pchar_t) strtabparam (L, "base", NULL);
filter = (ldap_pchar_t) strtabparam (L, "filter", NULL);
scope = string2scope (L, strtabparam (L, "scope", NULL));
sizelimit = longtabparam (L, "sizelimit", LDAP_NO_LIMIT);
timeout = get_timeout_param (L, &st);
rc = ldap_search_ext (conn->ld, base, scope, filter, attrs, attrsonly,
NULL, NULL, timeout, sizelimit, &msgid);
if (rc != LDAP_SUCCESS)
return luaL_error (L, LUALDAP_PREFIX"%s", ldap_err2string (rc));
create_search (L, 1, msgid);
lua_pushcclosure (L, next_message, 1);
return 1;
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute (lua_State *L) {
conn_data *conn = getconnection (L);
const char *statement = luaL_checkstring (L, 2);
unsigned long st_len = strlen(statement);
if (mysql_real_query(conn->my_conn, statement, st_len))
/* error executing query */
return luasql_failmessage(L, "Error executing query. MySQL: ", mysql_error(conn->my_conn));
else
{
MYSQL_RES *res = mysql_store_result(conn->my_conn);
unsigned int num_cols = mysql_field_count(conn->my_conn);
if (res) { /* tuples returned */
return create_cursor (L, 1, res, num_cols);
}
else { /* mysql_use_result() returned nothing; should it have? */
if(num_cols == 0) { /* no tuples returned */
/* query does not return data (it was not a SELECT) */
lua_pushnumber(L, mysql_affected_rows(conn->my_conn));
return 1;
}
else /* mysql_use_result() should have returned data */
return luasql_failmessage(L, "Error retrieving result. MySQL: ", mysql_error(conn->my_conn));
}
}
}
void account::addconnection (const account& a) throw(error){
account* temp=const_cast<account*>(&a);
if(!getconnection(temp->user()->user())){
_connection.push_back(temp);
}
else throw error(Connection, QString("You are already connected with this user"));
}
/*
** Rollback the current transaction.
*/
static int conn_rollback (lua_State *L) {
conn_data *conn = (conn_data *) getconnection (L);
SQLRETURN ret = SQLEndTran(hDBC, conn->hdbc, SQL_ROLLBACK);
if (error(ret))
return fail(L, hSTMT, conn->hdbc);
else
return pass(L);
}
/*
** Rolls back a transaction.
*/
static int conn_commit (lua_State *L) {
conn_data *conn = (conn_data *) getconnection (L);
SQLRETURN ret = SQLEndTran(hDBC, conn->hdbc, SQL_COMMIT);
if (error(ret))
return fail(L, hSTMT, conn->hdbc);
else
return pass(L);
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute (lua_State *L) {
env_data *env;
conn_data *conn = getconnection (L);
const char *statement = luaL_checkstring (L, 2);
sword status;
ub4 prefetch = 0;
ub4 iters;
ub4 mode;
ub2 type;
OCIStmt *stmthp;
/* get environment */
lua_rawgeti (L, LUA_REGISTRYINDEX, conn->env);
if (!lua_isuserdata (L, -1))
luaL_error(L,LUASQL_PREFIX"invalid environment in connection!");
env = (env_data *)lua_touserdata (L, -1);
/* statement handle */
ASSERT (L, OCIHandleAlloc ((dvoid *)env->envhp, (dvoid **)&stmthp,
OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), conn->errhp);
ASSERT (L, OCIAttrSet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT,
(dvoid *)&prefetch, (ub4)0, (ub4)OCI_ATTR_PREFETCH_ROWS,
conn->errhp), conn->errhp);
ASSERT (L, OCIStmtPrepare (stmthp, conn->errhp, (text *)statement,
(ub4) strlen(statement), (ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT),
conn->errhp);
/* statement type */
ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4) OCI_HTYPE_STMT,
(dvoid *)&type, (ub4 *)0, (ub4)OCI_ATTR_STMT_TYPE, conn->errhp),
conn->errhp);
if (type == OCI_STMT_SELECT)
iters = 0;
else
iters = 1;
if (conn->auto_commit)
mode = OCI_COMMIT_ON_SUCCESS;
else
mode = OCI_DEFAULT;
/* execute statement */
status = OCIStmtExecute (conn->svchp, stmthp, conn->errhp, iters,
(ub4)0, (CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, mode);
if (status && (status != OCI_NO_DATA)) {
OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT);
return checkerr (L, status, conn->errhp);
}
if (type == OCI_STMT_SELECT) {
/* create cursor */
return create_cursor (L, 1, conn, stmthp, statement);
} else {
/* return number of rows */
int rows_affected;
ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT,
(dvoid *)&rows_affected, (ub4 *)0,
(ub4)OCI_ATTR_ROW_COUNT, conn->errhp), conn->errhp);
OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT);
lua_pushnumber (L, rows_affected);
return 1;
}
}
/*
** Rollback the current transaction.
*/
static int conn_rollback (lua_State *L) {
conn_data *conn = getconnection (L);
sql_rollback(conn);
if (conn->auto_commit == 0) {
sql_begin(conn);
lua_pushboolean (L, 1);
} else
lua_pushboolean (L, 0);
return 1;
}
/*
** Change the distinguished name of an entry.
*/
static int lualdap_rename (lua_State *L) {
conn_data *conn = getconnection (L);
ldap_pchar_t dn = (ldap_pchar_t) luaL_checkstring (L, 2);
ldap_pchar_t rdn = (ldap_pchar_t) luaL_checkstring (L, 3);
ldap_pchar_t par = (ldap_pchar_t) luaL_optlstring (L, 4, NULL, NULL);
const int del = luaL_optnumber (L, 5, 0);
ldap_int_t msgid;
ldap_int_t rc = ldap_rename (conn->ld, dn, rdn, par, del, NULL, NULL, &msgid);
return create_future (L, rc, 1, msgid, LDAP_RES_MODDN);
}
/*
** Rolls back the current transaction
** Lua Returns:
** 1 if rollback is sucsessful
** nil and error message otherwise.
*/
static int conn_rollback(lua_State *L) {
conn_data *conn = getconnection(L,1);
isc_rollback_retaining(conn->env->status_vector, &conn->transaction);
if ( CHECK_DB_ERROR(conn->env->status_vector) )
return return_db_error(L, conn->env->status_vector);
lua_pushboolean(L, 1);
return 1;
}
/*
** Rollback the current transaction.
*/
static int conn_rollback (lua_State *L) {
conn_data *conn = getconnection (L);
ASSERT (L, OCITransRollback (conn->svchp, conn->errhp, OCI_DEFAULT),
conn->errhp);
/*
if (conn->auto_commit == 0)
sql_begin(conn);
*/
return 0;
}
/*
** Commit the current transaction.
*/
static int conn_commit (lua_State *L) {
conn_data *conn = getconnection (L);
ASSERT (L, OCITransCommit (conn->svchp, conn->errhp, OCI_DEFAULT),
conn->errhp);
/*
if (conn->auto_commit == 0)
ASSERT (L, OCITransStart (conn->svchp, conn->errhp...
*/
return 0;
}
/*
** Set "auto commit" property of the connection. Modes ON/OFF
*/
static int conn_setautocommit (lua_State *L) {
conn_data *conn = getconnection (L);
if (lua_toboolean (L, 2)) {
mysql_autocommit(conn->my_conn, 1); /* Set it ON */
}
else {
mysql_autocommit(conn->my_conn, 0);
}
lua_pushboolean(L, 1);
return 1;
}
/*
** Compare a value against an entry.
** @param #1 LDAP connection.
** @param #2 String with entry's DN.
** @param #3 String with attribute's name.
** @param #4 String with attribute's value.
** @return Function to process the LDAP result.
*/
static int lualdap_compare (lua_State *L) {
conn_data *conn = getconnection (L);
ldap_pchar_t dn = (ldap_pchar_t) luaL_checkstring (L, 2);
ldap_pchar_t attr = (ldap_pchar_t) luaL_checkstring (L, 3);
BerValue bvalue;
ldap_int_t rc, msgid;
bvalue.bv_val = (char *)luaL_checkstring (L, 4);
bvalue.bv_len = lua_strlen (L, 4);
rc = ldap_compare_ext (conn->ld, dn, attr, &bvalue, NULL, NULL, &msgid);
return create_future (L, rc, 1, msgid, LDAP_RES_COMPARE);
}
/*
** Sets the autocommit state of the connection
** Lua Returns:
** autocommit state (0:off, 1:on)
** nil and error message on error.
*/
static int conn_setautocommit(lua_State *L) {
conn_data *conn = getconnection(L,1);
if(lua_toboolean(L, 2))
conn->autocommit = 1;
else
conn->autocommit = 0;
lua_pushboolean(L, 1);
return 1;
}
/*
** Add a new entry to the directory.
** @param #1 LDAP connection.
** @param #2 String with new entry's DN.
** @param #3 Table with new entry's attributes and values.
** @return Function to process the LDAP result.
*/
static int lualdap_add (lua_State *L) {
conn_data *conn = getconnection (L);
ldap_pchar_t dn = (ldap_pchar_t) luaL_checkstring (L, 2);
attrs_data attrs;
ldap_int_t rc, msgid;
A_init (&attrs);
if (lua_istable (L, 3))
A_tab2mod (L, &attrs, 3, LUALDAP_MOD_ADD);
A_lastattr (L, &attrs);
rc = ldap_add_ext (conn->ld, dn, attrs.attrs, NULL, NULL, &msgid);
return create_future (L, rc, 1, msgid, LDAP_RES_ADD);
}
/*
** Set "auto commit" property of the connection.
** If 'true', then rollback current transaction.
** If 'false', then start a new transaction.
*/
static int conn_setautocommit (lua_State *L) {
conn_data *conn = getconnection (L);
if (lua_toboolean (L, 2)) {
conn->auto_commit = 1;
sql_rollback(conn); /* Undo active transaction. */
}
else {
conn->auto_commit = 0;
sql_begin(conn);
}
lua_pushboolean(L, 1);
return 1;
}
/*
** Escapes a string for use within an SQL statement.
** Returns a string with the escaped string.
*/
static int conn_escape (lua_State *L) {
conn_data *conn = getconnection (L);
size_t len;
const char *from = luaL_checklstring (L, 2, &len);
char to[len*sizeof(char)*2+1];
int error;
len = PQescapeStringConn (conn->pg_conn, to, from, len, &error);
if (error == 0) { /* success ! */
lua_pushlstring (L, to, len);
return 1;
} else
return luasql_failmsg (L, "cannot escape string. PostgreSQL: ", PQerrorMessage (conn->pg_conn));
}
/*
** Executes a SQL statement.
** Returns
** cursor object: if there are results or
** row count: number of rows affected by statement if no results
*/
static int conn_execute (lua_State *L) {
conn_data *conn = (conn_data *) getconnection (L);
const char *statement = luaL_checkstring(L, 2);
SQLHDBC hdbc = conn->hdbc;
SQLHSTMT hstmt;
SQLSMALLINT numcols;
SQLRETURN ret;
ret = SQLAllocHandle(hSTMT, hdbc, &hstmt);
if (error(ret))
return fail(L, hDBC, hdbc);
ret = SQLPrepare(hstmt, (char *) statement, SQL_NTS);
if (error(ret)) {
ret = fail(L, hSTMT, hstmt);
SQLFreeHandle(hSTMT, hstmt);
return ret;
}
/* execute the statement */
ret = SQLExecute (hstmt);
if (error(ret)) {
ret = fail(L, hSTMT, hstmt);
SQLFreeHandle(hSTMT, hstmt);
return ret;
}
/* determine the number of results */
ret = SQLNumResultCols (hstmt, &numcols);
if (error(ret)) {
ret = fail(L, hSTMT, hstmt);
SQLFreeHandle(hSTMT, hstmt);
return ret;
}
if (numcols > 0)
/* if there is a results table (e.g., SELECT) */
return create_cursor (L, 1, conn, hstmt, numcols);
else {
/* if action has no results (e.g., UPDATE) */
SQLINTEGER numrows;
ret = SQLRowCount(hstmt, &numrows);
if (error(ret)) {
ret = fail(L, hSTMT, hstmt);
SQLFreeHandle(hSTMT, hstmt);
return ret;
}
lua_pushnumber(L, numrows);
SQLFreeHandle(hSTMT, hstmt);
return 1;
}
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute(lua_State *L)
{
conn_data *conn = getconnection(L);
const char *statement = luaL_checkstring(L, 2);
int res;
sqlite3_stmt *vm;
const char *errmsg;
int numcols;
const char *tail;
res = sqlite3_prepare(conn->sql_conn, statement, -1, &vm, &tail);
if (res != SQLITE_OK)
{
errmsg = sqlite3_errmsg(conn->sql_conn);
lua_pushnil(L);
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
lua_concat(L, 2);
return 2;
}
/* process first result to retrive query information and type */
res = sqlite3_step(vm);
numcols = sqlite3_column_count(vm);
/* real query? if empty, must have numcols!=0 */
if ((res == SQLITE_ROW) || ((res == SQLITE_DONE) && numcols))
{
sqlite3_reset(vm);
return create_cursor(L, 1, conn, vm, numcols);
}
if (res == SQLITE_DONE) /* and numcols==0, INSERT,UPDATE,DELETE statement */
{
sqlite3_finalize(vm);
/* return number of columns changed */
lua_pushnumber(L, sqlite3_changes(conn->sql_conn));
return 1;
}
/* error */
errmsg = sqlite3_errmsg(sqlite3_db_handle(vm));
sqlite3_finalize(vm);
lua_pushnil(L);
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
lua_concat(L, 2);
return 2;
}
/*
** Set "auto commit" property of the connection.
** If 'true', then rollback current transaction.
** If 'false', then start a new transaction.
*/
static int conn_setautocommit (lua_State *L) {
conn_data *conn = getconnection (L);
if (lua_toboolean (L, 2)) {
conn->auto_commit = 1;
/* Undo active transaction. */
ASSERT (L, OCITransRollback (conn->svchp, conn->errhp,
OCI_DEFAULT), conn->errhp);
}
else {
conn->auto_commit = 0;
/* sql_begin(conn);*/
}
lua_pushboolean(L, 1);
return 1;
}
/*
** Sets the auto commit mode
*/
static int conn_setautocommit (lua_State *L) {
conn_data *conn = (conn_data *) getconnection (L);
SQLRETURN ret;
if (lua_toboolean (L, 2)) {
ret = SQLSetConnectAttr(conn->hdbc, SQL_ATTR_AUTOCOMMIT,
(SQLPOINTER) SQL_AUTOCOMMIT_ON, 0);
} else {
ret = SQLSetConnectAttr(conn->hdbc, SQL_ATTR_AUTOCOMMIT,
(SQLPOINTER) SQL_AUTOCOMMIT_OFF, 0);
}
if (error(ret))
return fail(L, hSTMT, conn->hdbc);
else
return pass(L);
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute(lua_State *L)
{
conn_data *conn = getconnection(L);
const char *statement = luaL_checkstring(L, 2);
int res;
sqlite_vm *vm;
char *errmsg;
int numcols;
const char **col_info;
res = sqlite_compile(conn->sql_conn, statement, NULL, &vm, &errmsg);
if (res != SQLITE_OK)
{
lua_pushnil(L);
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
sqlite_freemem(errmsg);
lua_concat(L, 2);
return 2;
}
/* process first result to retrive query information and type */
res = sqlite_step(vm, &numcols, NULL, &col_info);
/* real query? if empty, must have numcols!=0 */
if ((res == SQLITE_ROW) || ((res == SQLITE_DONE) && numcols))
{
sqlite_reset(vm, NULL);
return create_cursor(L, 1, conn, vm, numcols, col_info);
}
if (res == SQLITE_DONE) /* and numcols==0, INSERT,UPDATE,DELETE statement */
{
sqlite_finalize(vm, NULL);
/* return number of columns changed */
lua_pushnumber(L, sqlite_changes(conn->sql_conn));
return 1;
}
/* error */
sqlite_finalize(vm, &errmsg);
lua_pushnil(L);
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
sqlite_freemem(errmsg);
lua_concat(L, 2);
return 2;
}
LUA_API int conn_autocommit_start(lua_State *L) {
conn_data *conn = getconnection(L);
my_bool auto_mode = lua_toboolean(L, 2);
my_bool ret = 0;
int status = mysql_autocommit_start(&ret, &conn->my_conn, auto_mode);
if (status) {
REF_CO(conn);
wait_for_status(L, conn, &conn->my_conn, status, conn_autocommit_event, 0);
return lua_yield(L, 0);
} else if (ret == 0) {
lua_pushboolean(L, true);
return 1;
} else {
return luamariadb_push_errno(L, conn);
}
}
LUA_API int set_character_set_start(lua_State *L) {
conn_data *conn = getconnection(L);
const char *charset = luaL_checkstring(L, 2);
int ret = 0;
int status = mysql_set_character_set_start(&ret, &conn->my_conn, charset);
if (status) {
REF_CO(conn);
wait_for_status(L, conn, &conn->my_conn, status, set_character_set_cont, 0);
return lua_yield(L, 0);
} else if (ret == 0) {
lua_pushboolean(L, 1);
return 1;
} else {
return luamariadb_push_errno(L, conn);
}
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute (lua_State *L) {
conn_data *conn = getconnection (L);
const char *statement = luaL_checkstring (L, 2);
PGresult *res = PQexec(conn->pg_conn, statement);
if (res && PQresultStatus(res)==PGRES_COMMAND_OK) {
/* no tuples returned */
lua_pushnumber(L, atof(PQcmdTuples(res)));
PQclear (res);
return 1;
}
else if (res && PQresultStatus(res)==PGRES_TUPLES_OK)
/* tuples returned */
return create_cursor (L, 1, res);
else {
/* error */
PQclear (res);
return luasql_failmsg(L, "error executing statement. PostgreSQL: ", PQerrorMessage(conn->pg_conn));
}
}