diff options
Diffstat (limited to '')
| -rw-r--r-- | src/environ_vtab.cc | 338 |
1 files changed, 338 insertions, 0 deletions
diff --git a/src/environ_vtab.cc b/src/environ_vtab.cc new file mode 100644 index 0000000..1265f4c --- /dev/null +++ b/src/environ_vtab.cc @@ -0,0 +1,338 @@ +/** + * Copyright (c) 2014, Timothy Stack + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of Timothy Stack nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "environ_vtab.hh" + +#include <stdlib.h> +#include <string.h> + +#include "base/auto_mem.hh" +#include "base/lnav_log.hh" +#include "config.h" + +extern char** environ; + +const char* const ENVIRON_CREATE_STMT = R"( +-- Access lnav's environment variables through this table. +CREATE TABLE environ ( + name TEXT PRIMARY KEY, + value TEXT +); +)"; + +struct env_vtab { + sqlite3_vtab base; + sqlite3* db; +}; + +struct env_vtab_cursor { + sqlite3_vtab_cursor base; + char** env_cursor; +}; + +static int vt_destructor(sqlite3_vtab* p_svt); + +static int +vt_create(sqlite3* db, + void* pAux, + int argc, + const char* const* argv, + sqlite3_vtab** pp_vt, + char** pzErr) +{ + env_vtab* p_vt; + + /* Allocate the sqlite3_vtab/vtab structure itself */ + p_vt = (env_vtab*) sqlite3_malloc(sizeof(*p_vt)); + + if (p_vt == NULL) { + return SQLITE_NOMEM; + } + + memset(&p_vt->base, 0, sizeof(sqlite3_vtab)); + p_vt->db = db; + + *pp_vt = &p_vt->base; + + int rc = sqlite3_declare_vtab(db, ENVIRON_CREATE_STMT); + + return rc; +} + +static int +vt_destructor(sqlite3_vtab* p_svt) +{ + env_vtab* p_vt = (env_vtab*) p_svt; + + /* Free the SQLite structure */ + sqlite3_free(p_vt); + + return SQLITE_OK; +} + +static int +vt_connect(sqlite3* db, + void* p_aux, + int argc, + const char* const* argv, + sqlite3_vtab** pp_vt, + char** pzErr) +{ + return vt_create(db, p_aux, argc, argv, pp_vt, pzErr); +} + +static int +vt_disconnect(sqlite3_vtab* pVtab) +{ + return vt_destructor(pVtab); +} + +static int +vt_destroy(sqlite3_vtab* p_vt) +{ + return vt_destructor(p_vt); +} + +static int vt_next(sqlite3_vtab_cursor* cur); + +static int +vt_open(sqlite3_vtab* p_svt, sqlite3_vtab_cursor** pp_cursor) +{ + env_vtab* p_vt = (env_vtab*) p_svt; + + p_vt->base.zErrMsg = NULL; + + env_vtab_cursor* p_cur = (env_vtab_cursor*) new env_vtab_cursor(); + + if (p_cur == NULL) { + return SQLITE_NOMEM; + } else { + *pp_cursor = (sqlite3_vtab_cursor*) p_cur; + + p_cur->base.pVtab = p_svt; + p_cur->env_cursor = environ; + } + + return SQLITE_OK; +} + +static int +vt_close(sqlite3_vtab_cursor* cur) +{ + env_vtab_cursor* p_cur = (env_vtab_cursor*) cur; + + /* Free cursor struct. */ + delete p_cur; + + return SQLITE_OK; +} + +static int +vt_eof(sqlite3_vtab_cursor* cur) +{ + env_vtab_cursor* vc = (env_vtab_cursor*) cur; + + return vc->env_cursor[0] == NULL; +} + +static int +vt_next(sqlite3_vtab_cursor* cur) +{ + env_vtab_cursor* vc = (env_vtab_cursor*) cur; + + if (vc->env_cursor[0] != NULL) { + vc->env_cursor += 1; + } + + return SQLITE_OK; +} + +static int +vt_column(sqlite3_vtab_cursor* cur, sqlite3_context* ctx, int col) +{ + env_vtab_cursor* vc = (env_vtab_cursor*) cur; + const char* eq = strchr(vc->env_cursor[0], '='); + + switch (col) { + case 0: + sqlite3_result_text(ctx, + vc->env_cursor[0], + eq - vc->env_cursor[0], + SQLITE_TRANSIENT); + break; + case 1: + sqlite3_result_text(ctx, eq + 1, -1, SQLITE_TRANSIENT); + break; + } + + return SQLITE_OK; +} + +static int +vt_rowid(sqlite3_vtab_cursor* cur, sqlite_int64* p_rowid) +{ + env_vtab_cursor* p_cur = (env_vtab_cursor*) cur; + + *p_rowid = (int64_t) p_cur->env_cursor[0]; + + return SQLITE_OK; +} + +static int +vt_best_index(sqlite3_vtab* tab, sqlite3_index_info* p_info) +{ + return SQLITE_OK; +} + +static int +vt_filter(sqlite3_vtab_cursor* p_vtc, + int idxNum, + const char* idxStr, + int argc, + sqlite3_value** argv) +{ + return SQLITE_OK; +} + +static int +vt_update(sqlite3_vtab* tab, + int argc, + sqlite3_value** argv, + sqlite_int64* rowid) +{ + const char* name + = (argc > 2 ? (const char*) sqlite3_value_text(argv[2]) : nullptr); + env_vtab* p_vt = (env_vtab*) tab; + int retval = SQLITE_ERROR; + + if (argc != 1 + && (argc < 3 || sqlite3_value_type(argv[2]) == SQLITE_NULL + || sqlite3_value_type(argv[3]) == SQLITE_NULL + || sqlite3_value_text(argv[2])[0] == '\0')) + { + tab->zErrMsg = sqlite3_mprintf( + "A non-empty name and value must be provided when inserting an " + "environment variable"); + + return SQLITE_ERROR; + } + if (name != nullptr && strchr(name, '=') != nullptr) { + tab->zErrMsg = sqlite3_mprintf( + "Environment variable names cannot contain an equals sign (=)"); + + return SQLITE_ERROR; + } + + if (sqlite3_value_type(argv[0]) != SQLITE_NULL) { + int64_t index = sqlite3_value_int64(argv[0]); + const char* var = (const char*) index; + const char* eq = strchr(var, '='); + size_t namelen = eq - var; + char name[namelen + 1]; + + memcpy(name, var, namelen); + name[namelen] = '\0'; + unsetenv(name); + + retval = SQLITE_OK; + } else if (name != nullptr && getenv(name) != nullptr) { +#ifdef SQLITE_FAIL + int rc; + + rc = sqlite3_vtab_on_conflict(p_vt->db); + switch (rc) { + case SQLITE_FAIL: + case SQLITE_ABORT: + tab->zErrMsg = sqlite3_mprintf( + "An environment variable with the name '%s' already exists", + name); + return rc; + case SQLITE_IGNORE: + return SQLITE_OK; + case SQLITE_REPLACE: + break; + default: + return rc; + } +#endif + } + + if (name != nullptr && argc == 4) { + const unsigned char* value = sqlite3_value_text(argv[3]); + + setenv((const char*) name, (const char*) value, 1); + + return SQLITE_OK; + } + + return retval; +} + +static sqlite3_module vtab_module = { + 0, /* iVersion */ + vt_create, /* xCreate - create a vtable */ + vt_connect, /* xConnect - associate a vtable with a connection */ + vt_best_index, /* xBestIndex - best index */ + vt_disconnect, /* xDisconnect - disassociate a vtable with a connection */ + vt_destroy, /* xDestroy - destroy a vtable */ + vt_open, /* xOpen - open a cursor */ + vt_close, /* xClose - close a cursor */ + vt_filter, /* xFilter - configure scan constraints */ + vt_next, /* xNext - advance a cursor */ + vt_eof, /* xEof - inidicate end of result set*/ + vt_column, /* xColumn - read data */ + vt_rowid, /* xRowid - read data */ + vt_update, /* xUpdate - write data */ + NULL, /* xBegin - begin transaction */ + NULL, /* xSync - sync transaction */ + NULL, /* xCommit - commit transaction */ + NULL, /* xRollback - rollback transaction */ + NULL, /* xFindFunction - function overloading */ +}; + +int +register_environ_vtab(sqlite3* db) +{ + auto_mem<char, sqlite3_free> errmsg; + int rc; + + rc = sqlite3_create_module(db, "environ_vtab_impl", &vtab_module, NULL); + ensure(rc == SQLITE_OK); + if ((rc = sqlite3_exec( + db, + "CREATE VIRTUAL TABLE environ USING environ_vtab_impl()", + NULL, + NULL, + errmsg.out())) + != SQLITE_OK) + { + fprintf(stderr, "unable to create environ table %s\n", errmsg.in()); + } + return rc; +} |