int plugin_register(struct plugin_handle* plugin, const char* config)
{
struct chat_history_data* data;
PLUGIN_INITIALIZE(plugin, "SQLite chat history plugin", "1.0", "Provide a global chat history log.");
plugin->funcs.on_user_chat_message = history_add;
plugin->funcs.on_user_login = user_login;
data = parse_config(config, plugin);
if (!data)
return -1;
plugin->ptr = data;
create_tables(plugin);
data->command_history_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(data->command_history_handle, plugin, "history", "?N", auth_cred_guest, &command_history, "Show chat message history.");
plugin->hub.command_add(plugin, data->command_history_handle);
data->command_historycleanup_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(data->command_historycleanup_handle, plugin, "historycleanup", "", auth_cred_admin, &command_historycleanup, "Clean chat message history.");
plugin->hub.command_add(plugin, data->command_historycleanup_handle);
return 0;
}
/*
* Builds arguments.
*/
PRIVATE addr_t buildargs
(void *stack, size_t size, const char **argv, const char **envp)
{
int p; /* Stack pointer. */
int argc; /* argv length. */
int envc; /* envc length. */
/* Get argv count. */
if ((argc = count(argv)) < 0)
return (0);
/* Get envp count. */
if ((envc = count(envp)) < 0)
return (0);
/* Copy argv and envp to stack. */
if ((p = copy_strings(envc, envp, stack, size - 1, 0)) < 0)
return (0);
if ((p = copy_strings(argc, argv, stack, p, 0)) < 0)
return (0);
if ((p = create_tables(stack, size, p, argc, envc)) == 0)
return (0);
return (p);
}
int plugin_register(struct plugin_handle* plugin, const char* config)
{
PLUGIN_INITIALIZE(plugin, "SQLite logging plugin", "0.5", "Logs users entering and leaving the hub to SQLite database.");
struct log_data* ldata;
plugin->funcs.on_user_login = log_user_login;
plugin->funcs.on_user_login_error = log_user_login_error;
plugin->funcs.on_user_logout = log_user_logout;
plugin->funcs.on_user_nick_change = log_change_nick;
ldata = parse_config(config, plugin);
if (!ldata)
return -1;
ldata->command_userlog_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(ldata->command_userlog_handle, plugin, "userlog", "?N?mm", auth_cred_operator, &command_userlog, "[<lines> [<column> <search pattern>]]", "Search in userlog for a value.");
plugin->hub.command_add(plugin, ldata->command_userlog_handle);
ldata->command_userlogcleanup_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(ldata->command_userlogcleanup_handle, plugin, "userlogcleanup", "N", auth_cred_admin, &command_userlogcleanup, "<days>", "Delete log entries.");
plugin->hub.command_add(plugin, ldata->command_userlogcleanup_handle);
plugin->ptr = ldata;
create_tables(plugin);
return 0;
}
sqlite3* db_open()
{
sqlite3 *db;
g_debug("Open db connection to "CONFIGDIR"gtkqq.db (%s, %d)"
, __FILE__, __LINE__);
gint retcode = sqlite3_open(CONFIGDIR"gtkqq.db", &db);
if(retcode != SQLITE_OK){
if(retcode == SQLITE_NOMEM){
g_error("Open database error. no memory. (%s, %d)", __FILE__, __LINE__);
return NULL;
}
g_error("Open database error. %s (%s, %d)", sqlite3_errmsg(db)
, __FILE__, __LINE__);
sqlite3_close(db);
return NULL;
}
if(!test_table_exist(db)){
if(create_tables(db) != SQLITE_OK){
g_error("Create tables error! (%s, %d)", __FILE__, __LINE__);
sqlite3_close(db);
return NULL;
}
}
return db;
}
int plugin_register(struct plugin_handle* plugin, const char* config)
{
struct extras_data* extrasdata;
PLUGIN_INITIALIZE(plugin, "Extras plugin", "0.1", "Plugin for extra features like hub news, releases, hublist.");
extrasdata = parse_config(config, plugin);
if (!extrasdata)
return -1;
extrasdata->command_hubadd_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(extrasdata->command_hubadd_handle, plugin, "hubadd", "m+m", auth_cred_admin, &command_hubadd, "<address> <hub name>", "Add hub to hublist.");
plugin->hub.command_add(plugin, extrasdata->command_hubadd_handle);
extrasdata->command_hubdel_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(extrasdata->command_hubdel_handle, plugin, "hubdel", "N", auth_cred_admin, &command_hubdel, "<hub id>", "Delete hub from hublist.");
plugin->hub.command_add(plugin, extrasdata->command_hubdel_handle);
extrasdata->command_hublist_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(extrasdata->command_hublist_handle, plugin, "hublist", "", auth_cred_user, &command_hublist, "", "List hubs in hublist.");
plugin->hub.command_add(plugin, extrasdata->command_hublist_handle);
extrasdata->command_newsadd_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(extrasdata->command_newsadd_handle, plugin, "newsadd", "+m", auth_cred_admin, &command_newsadd, "", "Add news item.");
plugin->hub.command_add(plugin, extrasdata->command_newsadd_handle);
extrasdata->command_newsdel_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(extrasdata->command_newsdel_handle, plugin, "newsdel", "N", auth_cred_admin, &command_newsdel, "<news id>", "Delete news item.");
plugin->hub.command_add(plugin, extrasdata->command_newsdel_handle);
extrasdata->command_news_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(extrasdata->command_news_handle, plugin, "news", "", auth_cred_user, &command_news, "", "Show hubnews.");
plugin->hub.command_add(plugin, extrasdata->command_news_handle);
extrasdata->command_releaseadd_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(extrasdata->command_releaseadd_handle, plugin, "releaseadd", "m+m", auth_cred_admin, &command_releaseadd, "<tth> <title>", "Add release.");
plugin->hub.command_add(plugin, extrasdata->command_releaseadd_handle);
extrasdata->command_releasedel_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(extrasdata->command_releasedel_handle, plugin, "releasedel", "N", auth_cred_admin, &command_releasedel, "<release id>", "Delete release.");
plugin->hub.command_add(plugin, extrasdata->command_releasedel_handle);
extrasdata->command_releases_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
PLUGIN_COMMAND_INITIALIZE(extrasdata->command_releases_handle, plugin, "releases", "", auth_cred_user, &command_releases, "", "Show releases.");
plugin->hub.command_add(plugin, extrasdata->command_releases_handle);
plugin->ptr = extrasdata;
create_tables(plugin);
return 0;
}
connection::connection(std::string const& file_name)
: db_connection_m(0)
{
int error = SQLITE_OK;
error = sqlite3_open_v2(file_name.c_str(), &db_connection_m, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
if (error != SQLITE_OK)
{
throw std::runtime_error(std::string("Could not estabilish database connection: ") + sqlite3_errmsg(db_connection_m));
}
create_tables();
}
void SQLiteStorage::connect()
{
if (SQLITE_OK != sqlite3_open(db_name_.c_str(), &connection_))
{
throw sqlite3_errcode(connection_);
}
if (create_)
{
create_tables();
return;
}
load();
}
QcOfflineCacheDatabase::QcOfflineCacheDatabase(QString sqlite_path)
{
bool create = !QFile(sqlite_path).exists();
m_database = QSqlDatabase::addDatabase(QStringLiteral("QSQLITE"), sqlite_path);
m_database.setDatabaseName(sqlite_path);
if (!m_database.open())
qWarning() << m_database.lastError().text();
if (create)
create_tables();
else
init_cache();
}
int BC_FileBox::refresh()
{
create_tables();
listbox->set_master_column(column_of_type(FILEBOX_NAME), 0);
listbox->update(list_column,
column_titles,
column_width,
columns,
0,
0,
-1,
1);
return 0;
}
struct plugin_t * init(void)
{
plugin = malloc(sizeof (struct plugin_t));
memset(plugin, 0, sizeof *plugin);
plugin->run = run;
plugin->name = "seen";
plugin->type = PLUGIN_TYPE_COMMAND | PLUGIN_TYPE_GREP;
plugin->keywords = keywords;
create_tables();
return plugin;
}
/* GNUCASH_RESAVE_VERSION indicates the earliest database version
* compatible with this version of Gnucash; the stored value is the
* earliest version of Gnucash conpatible with the database. If the
* GNUCASH_RESAVE_VERSION for this Gnucash is newer than the Gnucash
* version which created the database, a resave is offered. If the
* version of this Gnucash is older than the saved resave version,
* then the database will be loaded read-only. A resave will update
* both values to match this version of Gnucash.
*/
void
gnc_dbi_load (QofBackend* qbe, QofBook* book, QofBackendLoadType loadType)
{
GncDbiBackend* be = (GncDbiBackend*)qbe;
g_return_if_fail (qbe != nullptr);
g_return_if_fail (book != nullptr);
ENTER ("be=%p, book=%p", be, book);
if (loadType == LOAD_TYPE_INITIAL_LOAD)
{
// Set up table version information
be->init_version_info ();
assert (be->m_book == nullptr);
// Call all object backends to create any required tables
auto registry = gnc_sql_get_backend_registry();
for (auto entry : registry)
create_tables(entry, be);
}
gnc_sql_load (be, book, loadType);
if (GNUCASH_RESAVE_VERSION > be->get_table_version("Gnucash"))
{
/* The database was loaded with an older database schema or
* data semantics. In order to ensure consistency, the whole
* thing needs to be saved anew. */
qof_backend_set_error (qbe, ERR_SQL_DB_TOO_OLD);
}
else if (GNUCASH_RESAVE_VERSION < be->get_table_version("Gnucash-Resave"))
{
/* Worse, the database was created with a newer version. We
* can't safely write to this database, so the user will have
* to do a "save as" to make one that we can write to.
*/
qof_backend_set_error (qbe, ERR_SQL_DB_TOO_NEW);
}
LEAVE ("");
}
gboolean
almanah_storage_manager_connect (AlmanahStorageManager *self, GError **error)
{
/* Our beautiful SQLite VFS */
almanah_vfs_init(self->priv->settings);
/* Open the plain database */
if (sqlite3_open_v2 (self->priv->filename, &(self->priv->connection), SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, "almanah") != SQLITE_OK) {
g_set_error (error, ALMANAH_STORAGE_MANAGER_ERROR, ALMANAH_STORAGE_MANAGER_ERROR_OPENING_FILE,
_("Could not open database \"%s\". SQLite provided the following error message: %s"),
self->priv->filename, sqlite3_errmsg (self->priv->connection));
return FALSE;
}
/* Can't hurt to create the tables now */
create_tables (self);
return TRUE;
}
MetadataStorage::MetadataStorage(const char* db, aku_logger_cb_t logger)
: pool_(nullptr, &delete_apr_pool)
, driver_(nullptr)
, handle_(nullptr, AprHandleDeleter(nullptr))
, logger_(logger)
{
apr_pool_t *pool = nullptr;
auto status = apr_pool_create(&pool, NULL);
if (status != APR_SUCCESS) {
// report error (can't return error from c-tor)
throw std::runtime_error("Can't create memory pool");
}
pool_.reset(pool);
status = apr_dbd_get_driver(pool, "sqlite3", &driver_);
if (status != APR_SUCCESS) {
(*logger_)(AKU_LOG_ERROR, "Can't load driver, maybe libaprutil1-dbd-sqlite3 isn't installed");
throw std::runtime_error("Can't load sqlite3 dirver");
}
apr_dbd_t *handle = nullptr;
status = apr_dbd_open(driver_, pool, db, &handle);
if (status != APR_SUCCESS) {
(*logger_)(AKU_LOG_ERROR, "Can't open database, check file path");
throw std::runtime_error("Can't open database");
}
handle_ = HandleT(handle, AprHandleDeleter(driver_));
auto sqlite_handle = apr_dbd_native_handle(driver_, handle);
sqlite3_trace((sqlite3*)sqlite_handle, callback_adapter, (void*)logger_);
create_tables();
// Create prepared statement
const char* query = "INSERT INTO akumuli_series (series_id, keyslist, storage_id) VALUES (%s, %s, %d)";
status = apr_dbd_prepare(driver_, pool_.get(), handle_.get(), query, "INSERT_SERIES_NAME", &insert_);
if (status != 0) {
(*logger_)(AKU_LOG_ERROR, "Error creating prepared statement");
throw std::runtime_error(apr_dbd_error(driver_, handle_.get(), status));
}
}
static gboolean create_database_connection() {
gchar *path;
int rc;
if(_db)
return TRUE;
/* build the path */
path = g_build_filename(purple_user_dir(), "cap.db", (gchar *)NULL);
/* make database connection here */
rc = sqlite3_open(path, &_db);
g_free(path);
if(rc != SQLITE_OK)
return FALSE;
/* Add tables here */
create_tables();
purple_debug_info("cap", "Database connection successfully made.\n");
return TRUE;
}
int dbfile_create(char *filename)
{
int ret;
sqlite3 *db = NULL;
ret = unlink(filename);
if (ret && errno != ENOENT) {
ret = errno;
fprintf(stderr,
"Error %d while unlinking old db file \"%s\": %s",
ret, filename, strerror(ret));
return ret;
}
#define OPEN_FLAGS (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_NOMUTEX)
ret = sqlite3_open_v2(filename, &db, OPEN_FLAGS, NULL);
if (ret) {
perror_sqlite_open(db, filename);
return ret;
}
ret = create_tables(db);
if (ret) {
perror_sqlite(ret, "creating tables");
sqlite3_close(db);
return ret;
}
ret = dbfile_set_modes(db);
if (ret) {
perror_sqlite(ret, "setting journal modes");
sqlite3_close(db);
return ret;
}
gdb = db;
return 0;
}
/* GNUCASH_RESAVE_VERSION indicates the earliest database version
* compatible with this version of Gnucash; the stored value is the
* earliest version of Gnucash conpatible with the database. If the
* GNUCASH_RESAVE_VERSION for this Gnucash is newer than the Gnucash
* version which created the database, a resave is offered. If the
* version of this Gnucash is older than the saved resave version,
* then the database will be loaded read-only. A resave will update
* both values to match this version of Gnucash.
*/
template <DbType Type> void
GncDbiBackend<Type>::load (QofBook* book, QofBackendLoadType loadType)
{
g_return_if_fail (book != nullptr);
ENTER ("dbi_be=%p, book=%p", this, book);
if (loadType == LOAD_TYPE_INITIAL_LOAD)
{
// Set up table version information
init_version_info ();
assert (m_book == nullptr);
create_tables();
}
GncSqlBackend::load(book, loadType);
if (GNUCASH_RESAVE_VERSION > get_table_version("Gnucash"))
{
/* The database was loaded with an older database schema or
* data semantics. In order to ensure consistency, the whole
* thing needs to be saved anew. */
set_error(ERR_SQL_DB_TOO_OLD);
}
else if (GNUCASH_RESAVE_VERSION < get_table_version("Gnucash-Resave"))
{
/* Worse, the database was created with a newer version. We
* can't safely write to this database, so the user will have
* to do a "save as" to make one that we can write to.
*/
set_error(ERR_SQL_DB_TOO_NEW);
}
LEAVE ("");
}
static void
main_window_prepare (GstUsersTool *tool)
{
GtkWidget *uid_entry;
GtkWidget *passwd_label;
int width;
uid_entry = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog, "user_settings_uid");
gtk_spin_button_set_range (GTK_SPIN_BUTTON (uid_entry), 0, OOBS_MAX_UID);
create_tables (tool);
gtk_window_set_default_size (GTK_WINDOW (GST_TOOL (tool)->main_dialog),
650, 400);
/* Ensure dialog won't change size when selecting another user */
passwd_label = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog,
"user_settings_passwd");
width = MAX (strlen (_("Not asked on login")), strlen (_("Asked on login")));
gtk_label_set_width_chars (GTK_LABEL (passwd_label), width);
/* For random password generation. */
srand (time (NULL));
}
int
main(int argc, const char *argv[])
{
const char* host = "127.0.0.1:2181";
zhandle_t* zkhandle;
int timeout = 5000;
char node[512] = {0};
char tables[][64] = {
{"employee_info_tab"},
{"boss_info_tab"}
};
zoo_set_debug_level(ZOO_LOG_LEVEL_WARN);
zkhandle = zookeeper_init(host, NULL, timeout,
0, "Zookeeper examples: config center services", 0);
if (zkhandle == NULL) {
fprintf(stderr, "Connecting to zookeeper servers error...\n");
exit(EXIT_FAILURE);
}
/* join the election group */
struct watch_func_para_t para;
int ret = join_the_election(zkhandle, node, ¶);
if (zkhandle == NULL) {
fprintf(stderr, "join the election error...\n");
exit(EXIT_FAILURE);
}
/* leader election */
if (is_leader(zkhandle, node)) {
i_am_leader = true;
printf("This is [%s], i am a leader\n", node);
(void)create_tables(zkhandle, tables, sizeof(tables)/sizeof(tables[0]));
} else {
i_am_leader = false;
printf("This is [%s], i am a follower\n", node);
}
/* start the trigger listen thread */
pthread_attr_t attr1;
ret = pthread_attr_init(&attr1);
if (ret != 0) {
fprintf(stderr, "pthread_attr_init error...\n");
exit(EXIT_FAILURE);
}
pthread_t trigger_listen_thr;
ret = pthread_create(&trigger_listen_thr, &attr1, trigger_listen_thread, zkhandle);
if (ret != 0) {
fprintf(stderr, "pthread_create error...\n");
exit(EXIT_FAILURE);
}
ret = pthread_attr_destroy(&attr1);
if (ret != 0) {
fprintf(stderr, "pthread_attr_destroy error...\n");
exit(EXIT_FAILURE);
}
/* start the item expire thread */
pthread_attr_t attr2;
ret = pthread_attr_init(&attr2);
if (ret != 0) {
fprintf(stderr, "pthread_attr_init error...\n");
exit(EXIT_FAILURE);
}
pthread_t expire_thr;
ret = pthread_create(&expire_thr, &attr2, item_expire_thread, zkhandle);
if (ret != 0) {
fprintf(stderr, "pthread_create error...\n");
exit(EXIT_FAILURE);
}
ret = pthread_attr_destroy(&attr2);
if (ret != 0) {
fprintf(stderr, "pthread_attr_destroy error...\n");
exit(EXIT_FAILURE);
}
void *res;
ret = pthread_join(trigger_listen_thr, (void**)&res);
if (ret != 0) {
fprintf(stderr, "pthread_join error...\n");
exit(EXIT_FAILURE);
}
ret = pthread_join(expire_thr, (void**)&res);
if (ret != 0) {
fprintf(stderr, "pthread_join error...\n");
exit(EXIT_FAILURE);
}
zookeeper_close(zkhandle);
}
void
GncSqlBackend::sync_all(QofBook* book)
{
g_return_if_fail (book != NULL);
reset_version_info();
ENTER ("book=%p, sql_be->book=%p", book, m_book);
update_progress();
/* Create new tables */
m_is_pristine_db = true;
create_tables();
/* Save all contents */
m_book = book;
auto is_ok = m_conn->begin_transaction();
// FIXME: should write the set of commodities that are used
// write_commodities(sql_be, book);
if (is_ok)
{
auto obe = m_backend_registry.get_object_backend(GNC_ID_BOOK);
is_ok = obe->commit (this, QOF_INSTANCE (book));
}
if (is_ok)
{
is_ok = write_accounts();
}
if (is_ok)
{
is_ok = write_transactions();
}
if (is_ok)
{
is_ok = write_template_transactions();
}
if (is_ok)
{
is_ok = write_schedXactions();
}
if (is_ok)
{
for (auto entry : m_backend_registry)
std::get<1>(entry)->write (this);
}
if (is_ok)
{
is_ok = m_conn->commit_transaction();
}
if (is_ok)
{
m_is_pristine_db = false;
/* Mark the session as clean -- though it shouldn't ever get
* marked dirty with this backend
*/
qof_book_mark_session_saved(book);
}
else
{
if (!qof_backend_check_error (&qof_be))
qof_backend_set_error (&qof_be, ERR_BACKEND_SERVER_ERR);
is_ok = m_conn->rollback_transaction ();
}
finish_progress();
LEAVE ("book=%p", book);
}
void init_db(){
sqlite3 *db = connect_db();
create_tables(&db);
sqlite3_close(db);
}
int register_files_from_stdin(char* build, char* project, char* path) {
int res = 0;
int loaded = 0;
char *line;
size_t size;
create_tables();
if (SQL("BEGIN")) { return -1; }
prune_old_entries(build, project);
//
// Enumerate the files in the path (DSTROOT) and associate them
// with the project name and version in the sqlite database.
//
// Skip the first result, since that is . of the DSTROOT itself.
while ((line = fgetln(stdin, &size)) != NULL) {
char filename[MAXPATHLEN+1];
char fullpath[MAXPATHLEN+1];
char symlink[MAXPATHLEN+1];
ssize_t len;
struct stat sb;
char *lastpathcomp = NULL;
if (size > 0 && line[size-1] == '\n') line[--size] = 0; // chomp newline
if (size > 0 && line[size-1] == '/') line[--size] = 0; // chomp trailing slash
if(0 == strcmp(line, "."))
continue;
// Filename
filename[0] = 0;
strcpy(filename, line+1); /* skip over leading "." */
lastpathcomp = strrchr(filename, '/');
if(lastpathcomp && 0 == strncmp(lastpathcomp+1, "._", 2))
continue;
sprintf(fullpath, "%s/%s", path, filename);
res = lstat(fullpath, &sb);
if(res != 0) {
perror(fullpath);
return -1;
}
// Symlinks
symlink[0] = 0;
if (S_ISLNK(sb.st_mode)) {
len = readlink(fullpath, symlink, MAXPATHLEN);
if (len >= 0) symlink[len] = 0;
}
// Default to empty SHA-1 checksum
char* checksum = strdup(" ");
// Checksum regular files
if (S_ISREG(sb.st_mode)) {
int fd = open(fullpath, O_RDONLY);
if (fd == -1) {
perror(filename);
return -1;
}
res = register_libraries(fd, build, project, filename, NULL);
/* For -stdin mode, we don't calculate checksums
lseek(fd, (off_t)0, SEEK_SET);
checksum = calculate_digest(fd);
*/
close(fd);
}
// register regular files and symlinks in the DB
if (S_ISREG(sb.st_mode) || S_ISLNK(sb.st_mode)) {
res = SQL("INSERT INTO files (build,project, path) VALUES (%Q,%Q,%Q)",
build, project, filename);
++loaded;
}
// add all regular files, directories, and symlinks to the manifest
if (S_ISREG(sb.st_mode) || S_ISLNK(sb.st_mode) || S_ISDIR(sb.st_mode)) {
fprintf(stdout, "%s %o %d %d %lld .%s%s%s\n",
checksum,
sb.st_mode,
sb.st_uid,
sb.st_gid,
!S_ISDIR(sb.st_mode) ? sb.st_size : (off_t)0,
filename,
symlink[0] ? " -> " : "",
symlink[0] ? symlink : "");
}
free(checksum);
}
if (SQL("COMMIT")) { return -1; }
fprintf(stderr, "%s - %d files registered.\n", project, loaded);
return res;
}
/**
* @brief Start the storage server.
*
* This is the main entry point for the storage server. It reads the
* configuration file, starts listening on a port, and proccesses
* commands from clients.
*/
int main(int argc, char *argv[])
{
char file_name[MAX_LOG_NAME] = "Server";
server_time_log = fopen("server_times.log", "a");
switch (LOGGING)
{
case 0:
server_log = NULL;
break;
case 1:
server_log = stdout;
break;
case 2:
server_log = fopen(generate_logfile(file_name), "w");
break;
}
// Process command line arguments.
// This program expects exactly one argument: the config file name.
assert(argc > 0);
if (argc != 2)
{
printf("Usage %s <config_file>\n", argv[0]);
exit(EXIT_FAILURE);
}
char *config_file = argv[1];
// Read the config file.
int status = read_config(config_file, ¶ms);
if (status != 0)
{
printf("Error processing config file.\n");
exit(EXIT_FAILURE);
}
sprintf(log_buffer, "server main: Server on %s:%d\n", params.server_host, params.server_port);
logger(server_log, log_buffer);
// Create a socket.
int listensock = socket(PF_INET, SOCK_STREAM, 0);
if (listensock < 0)
{
printf("Error creating socket.\n");
exit(EXIT_FAILURE);
}
// Allow listening port to be reused if defunct.
int yes = 1;
status = setsockopt(listensock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
if (status != 0)
{
printf("Error configuring socket.\n");
exit(EXIT_FAILURE);
}
// Bind it to the listening port.
struct sockaddr_in listenaddr;
memset(&listenaddr, 0, sizeof listenaddr);
listenaddr.sin_family = AF_INET;
listenaddr.sin_port = htons(params.server_port);
inet_pton(AF_INET, params.server_host, &(listenaddr.sin_addr)); // bind to local IP address
status = bind(listensock, (struct sockaddr*) &listenaddr, sizeof listenaddr);
if (status != 0)
{
printf("Error binding socket.\n");
exit(EXIT_FAILURE);
}
// Listen for connections.
status = listen(listensock, MAX_LISTENQUEUELEN);
if (status != 0)
{
printf("Error listening on socket.\n");
exit(EXIT_FAILURE);
}
status = create_tables();
if (status != 0)
{
printf("Error creating tables.\n");
delete_tables();
exit(EXIT_FAILURE);
}
int i;
if(strcmp(params.table_names[0], "census") == 0)
for(i = 0; i < params.num_tables; i++)
{
status = populate_database(params.table_names[i]);
if(status != 0)
{
printf("Error populating tables.\n");
delete_tables();
exit(EXIT_FAILURE);
}
}
// Listen loop.
int wait_for_connections = 1;
while (wait_for_connections)
{
// Wait for a connection.
struct sockaddr_in clientaddr;
socklen_t clientaddrlen = sizeof clientaddr;
int clientsock = accept(listensock, (struct sockaddr*)&clientaddr, &clientaddrlen);
if (clientsock < 0)
{
printf("Error accepting a connection.\n");
delete_tables();
exit(EXIT_FAILURE);
}
sprintf(log_buffer, "server main: Got a connection from %s:%d.\n", inet_ntoa(clientaddr.sin_addr), clientaddr.sin_port);
logger(server_log, log_buffer);
// Get commands from client.
int wait_for_commands = 1;
do
{
// Read a line from the client.
char cmd[MAX_CMD_LEN] = {0};
int status = recvline(clientsock, cmd, MAX_CMD_LEN);
if (status != 0)
{
// Either an error occurred or the client closed the connection.
wait_for_commands = 0;
}
else
{
// Handle the command from the client.
int status = handle_command(clientsock, cmd);
if (status != 0)
wait_for_commands = 0; // Oops. An error occured.
}
}
while (wait_for_commands);
// Close the connection with the client.
close(clientsock);
sprintf(log_buffer, "server main: Closed connection from %s:%d.\n", inet_ntoa(clientaddr.sin_addr), clientaddr.sin_port);
logger(server_log, log_buffer);
}
// Stop listening for connections.
close(listensock);
fprintf(server_time_log, "Total %d gets performed in %ld microseconds\n", n_gets, get_processing_time.tv_usec);
fprintf(server_time_log, "Total %d sets performed in %ld microseconds\n", n_sets, set_processing_time.tv_usec);
fclose(server_time_log);
delete_tables();
fclose(server_log);
return EXIT_SUCCESS;
}
int BC_FileBox::create_objects()
{
int x = 10, y = 10;
BC_Resources *resources = BC_WindowBase::get_resources();
int directory_title_margin = MAX(20,
resources->filebox_text_images[0]->get_h());
// Create recent dir list
create_history();
// Directories aren't filtered in FileSystem so skip this
if(!want_directory)
{
filter_list.append(new BC_ListBoxItem("*"));
filter_list.append(new BC_ListBoxItem("[*.ifo][*.vob]"));
filter_list.append(new BC_ListBoxItem("[*.mp2][*.mp3][*.wav]"));
filter_list.append(new BC_ListBoxItem("[*.avi][*.mpg][*.m2v][*.m1v][*.mov]"));
filter_list.append(new BC_ListBoxItem("heroine*"));
filter_list.append(new BC_ListBoxItem("*.xml"));
fs->set_filter(get_resources()->filebox_filter);
}
fs->update(directory);
create_icons();
create_tables();
add_subwindow(ok_button = new BC_FileBoxOK(this));
if(want_directory)
add_subwindow(usethis_button = new BC_FileBoxUseThis(this));
add_subwindow(cancel_button = new BC_FileBoxCancel(this));
add_subwindow(new BC_Title(x, y, caption));
x = get_w() - resources->filebox_icons_images[0]->get_w() - 10;
add_subwindow(icon_button = new BC_FileBoxIcons(x, y, this));
x -= resources->filebox_text_images[0]->get_w() + 5;
add_subwindow(text_button = new BC_FileBoxText(x, y, this));
x -= resources->filebox_newfolder_images[0]->get_w() + 5;
add_subwindow(folder_button = new BC_FileBoxNewfolder(x, y, this));
x -= resources->filebox_delete_images[0]->get_w() + 5;
add_subwindow(delete_button = new BC_FileBoxDelete(x, y, this));
x -= resources->filebox_reload_images[0]->get_w() + 5;
add_subwindow(reload_button = new BC_FileBoxReload(x, y, this));
x -= resources->filebox_updir_images[0]->get_w() + 5;
add_subwindow(updir_button = new BC_FileBoxUpdir(x, y, this));
x = 10;
y += directory_title_margin + 3;
add_subwindow(recent_popup = new BC_FileBoxRecent(this,
x,
y));
add_subwindow(directory_title = new BC_FileBoxDirectoryText(x, y, this));
directory_title->reposition_window(
x,
y,
get_w() - recent_popup->get_w() - 20,
1);
recent_popup->reposition_window(
x + directory_title->get_w(),
y,
directory_title->get_w(),
200);
x = 10;
y += directory_title->get_h() + 5;
listbox = 0;
create_listbox(x, y, get_display_mode());
y += listbox->get_h() + 10;
add_subwindow(textbox = new BC_FileBoxTextBox(x, y, this));
y += textbox->get_h() + 10;
if(!want_directory)
{
add_subwindow(filter_text = new BC_FileBoxFilterText(x, y, this));
add_subwindow(filter_popup =
new BC_FileBoxFilterMenu(x + filter_text->get_w(), y, this));;
}
// listbox has to be active because refresh might be called from newfolder_thread
listbox->activate();
newfolder_thread = new BC_NewFolderThread(this);
show_window();
return 0;
}
/**
* Attaches a registry database to the registry object. Prior to calling this,
* the registry object is not actually connected to the registry. This function
* attaches it so it can be queried and manipulated.
*
* @param [in] reg the registry to attach to
* @param [in] path path to the registry db on disk
* @param [out] errPtr on error, a description of the error that occurred
* @return true if success; false if failure
*/
int reg_attach(reg_registry* reg, const char* path, reg_error* errPtr) {
struct stat sb;
int initialized = 1; /* registry already exists */
int can_write = 1; /* can write to this location */
int result = 0;
if (reg->status & reg_attached) {
reg_throw(errPtr, REG_MISUSE, "a database is already attached to this "
"registry");
return 0;
}
if (stat(path, &sb) != 0) {
initialized = 0;
if (errno == ENOENT) {
char *dirc, *dname;
dirc = strdup(path);
dname = dirname(dirc);
if (stat(dname, &sb) != 0) {
can_write = 0;
}
free(dirc);
} else {
can_write = 0;
}
}
/* can_write is still true if one of the stat calls succeeded */
if (initialized || can_write) {
sqlite3_stmt* stmt = NULL;
char* query = sqlite3_mprintf("ATTACH DATABASE '%q' AS registry", path);
int r;
do {
r = sqlite3_prepare_v2(reg->db, query, -1, &stmt, NULL);
} while (r == SQLITE_BUSY);
if (r == SQLITE_OK) {
/* XXX: Busy waiting, consider using sqlite3_busy_handler/timeout */
do {
sqlite3_step(stmt);
r = sqlite3_reset(stmt);
switch (r) {
case SQLITE_OK:
if (initialized || (create_tables(reg->db, errPtr))) {
Tcl_InitHashTable(®->open_entries,
sizeof(sqlite_int64)/sizeof(int));
Tcl_InitHashTable(®->open_files,
TCL_STRING_KEYS);
Tcl_InitHashTable(®->open_portgroups,
sizeof(sqlite_int64)/sizeof(int));
reg->status |= reg_attached;
result = 1;
}
break;
case SQLITE_BUSY:
break;
default:
reg_sqlite_error(reg->db, errPtr, query);
}
} while (r == SQLITE_BUSY);
sqlite3_finalize(stmt);
stmt = NULL;
if (result) {
result &= update_db(reg->db, errPtr);
}
} else {
reg_sqlite_error(reg->db, errPtr, query);
}
if (stmt) {
sqlite3_finalize(stmt);
}
sqlite3_free(query);
} else {
reg_throw(errPtr, REG_CANNOT_INIT, "port registry doesn't exist at "
"\"%q\" and couldn't write to this location", path);
}
return result;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
DBVARYBIN testvbin;
DBVARYCHAR testvstr;
int failed = 0;
int expected_error;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0007");
fprintf(stdout, "About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
create_tables(dbproc, 10);
if (!start_query(dbproc)) {
fprintf(stderr, "%s:%d: start_query failed\n", __FILE__, __LINE__);
failed = 1;
}
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
for (i = 1; i <= 2; i++) {
char expected[1024];
sprintf(expected, "row %07d", i);
if (i % 5 == 0) {
dbclrbuf(dbproc, 5);
}
testint = -1;
strcpy(teststr, "bogus");
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "Failed. Expected a row\n");
abort();
}
if (testint != i) {
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
if (0 != strncmp(teststr, expected, strlen(expected))) {
fprintf(stdout, "Failed. Expected s to be |%s|, was |%s|\n", expected, teststr);
abort();
}
printf("Read a row of data -> %d %s\n", (int) testint, teststr);
}
fprintf(stdout, "second select. Should fail.\n");
expected_error = 20019;
dbsetuserdata(dbproc, (BYTE*) &expected_error);
if (start_query(dbproc)) {
fprintf(stderr, "%s:%d: start_query should have failed but didn't\n", __FILE__, __LINE__);
failed = 1;
}
dbcancel(dbproc);
/*
* Test Binary binding
*/
if (!start_query(dbproc)) {
fprintf(stderr, "%s:%d: start_query failed\n", __FILE__, __LINE__);
failed = 1;
}
dbbind(dbproc, 1, VARYBINBIND, sizeof(testvbin), (BYTE *) &testvbin);
dbbind(dbproc, 2, VARYCHARBIND, sizeof(testvstr), (BYTE *) &testvstr);
dbbind(dbproc, 3, BINARYBIND, sizeof(testint), (BYTE *) &testint);
for (i = 1; i <= 2; i++) {
char expected[1024];
sprintf(expected, "row %07d ", i);
testint = -1;
memset(&testvbin, '*', sizeof(testvbin));
memset(&testvstr, '*', sizeof(testvstr));
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "Failed. Expected a row\n");
abort();
}
if (testint != i) {
fprintf(stderr, "Failed, line %d. Expected i to be %d, was %d (0x%x)\n", __LINE__, i, (int) testint, (int) testint);
abort();
}
if (testvbin.len != sizeof(testint)) {
fprintf(stderr, "Failed, line %d. Expected bin lenght to be %d, was %d\n", __LINE__, (int) sizeof(testint), (int) testvbin.len);
abort();
}
memcpy(&testint, testvbin.array, sizeof(testint));
if (testint != i) {
fprintf(stderr, "Failed, line %d. Expected i to be %d, was %d (0x%x)\n", __LINE__, i, (int) testint, (int) testint);
abort();
}
if (testvstr.len != strlen(expected) || 0 != strncmp(testvstr.str, expected, strlen(expected))) {
fprintf(stdout, "Failed, line %d. Expected s to be |%s|, was |%s|\n", __LINE__, expected, testvstr.str);
abort();
}
testvstr.str[testvstr.len] = 0;
printf("Read a row of data -> %d %s\n", (int) testint, testvstr.str);
}
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
void
jess_init (void)
{
/* quit_keyb = 0; */
quit_renderer = 0;
xres2 = resx/2;
yres2 = resy/2;
conteur.fullscreen = 0;
conteur.blur_mode = 1;
/******* ALLOCATION OF TABLES AND BUFFERS *****************/
table1 = (unsigned int *) malloc (resx * resy * sizeof (int));
if (!table1)
{
printf ("Not enought memory for allocating tables\n");
exit (1);
}
table2 = (unsigned int *) malloc (resx * resy * sizeof (int));
if (!table2)
{
printf ("Not enought memory for allocating tables\n");
exit (1);
}
table3 = (unsigned int *) malloc (resx * resy * sizeof (int));
if (!table3)
{
printf ("Not enought memory for allocating tables\n");
exit (1);
}
table4 = (unsigned int *) malloc (resx * resy * sizeof (int));
if (!table4)
{
printf ("Not enought memory for allocating tables\n");
exit (1);
}
printf ("Tables created\n");
printf("Video mode = %d*%d*%d bits\n", resx, resy, video);
if (video == 8)
buffer = (unsigned char *) malloc (resx * resy);
else
{
buffer = (unsigned char *) malloc (resx * resy * 4);
printf("Allocating memory done.\n");
}
if (!buffer)
{
printf ("Not enought memory for allocating buffer\n");
exit (1);
}
printf ("Buffer created\n");
/**********************************************************/
/******* TABLES COMPUTATION *******************************/
create_tables();
printf("Table computation Ok\n");
/***********************************************************/
srand (343425);
if (video == 8)
init_video_8();
else
init_video_32();
}
static int
load_object (struct linux_binprm * bprm, struct pt_regs *regs, int lib_ok)
{
COFF_FILHDR *coff_hdr = (COFF_FILHDR *) bprm->buf; /* COFF Header */
COFF_SCNHDR *sect_bufr; /* Pointer to section table */
COFF_SCNHDR *text_sect; /* Pointer to the text section */
COFF_SCNHDR *data_sect; /* Pointer to the data section */
COFF_SCNHDR *bss_sect; /* Pointer to the bss section */
int text_count; /* Number of text sections */
int data_count; /* Number of data sections */
int bss_count; /* Number of bss sections */
int lib_count; /* Number of lib sections */
unsigned int start_addr = 0;/* Starting location for program */
int status = 0; /* Result status register */
int fd = -1; /* Open file descriptor */
struct file *fp = NULL; /* Pointer to the file at "fd" */
short int sections = 0; /* Number of sections in the file */
short int aout_size = 0; /* Size of the a.out header area */
short int flags; /* Flag bits from the COFF header */
#ifdef COFF_DEBUG
printk ("binfmt_coff entry: %s\n", bprm->filename);
#endif
/*
* Validate the magic value for the object file.
*/
do {
if (COFF_I386BADMAG (*coff_hdr)) {
#ifdef COFF_DEBUG
printk ("bad filehdr magic\n");
#endif
status = -ENOEXEC;
break;
}
/*
* The object file should have 32 BIT little endian format. Do not allow
* it to have the 16 bit object file flag set as Linux is not able to run
* on the 80286/80186/8086.
*/
flags = COFF_SHORT (coff_hdr->f_flags);
if ((flags & (COFF_F_AR32WR | COFF_F_AR16WR)) != COFF_F_AR32WR) {
#ifdef COFF_DEBUG
printk ("invalid f_flags bits\n");
#endif
status = -ENOEXEC;
break;
}
/*
* Extract the header information which we need.
*/
sections = COFF_SHORT (coff_hdr->f_nscns); /* Number of sections */
aout_size = COFF_SHORT (coff_hdr->f_opthdr); /* Size of opt. headr */
/*
* If the file is not executable then reject the execution. This means
* that there must not be external references.
*/
if ((flags & COFF_F_EXEC) == 0) {
#ifdef COFF_DEBUG
printk ("not executable bit\n");
#endif
status = -ENOEXEC;
break;
}
/*
* There must be at least one section.
*/
if (sections == 0) {
#ifdef COFF_DEBUG
printk ("no sections\n");
#endif
status = -ENOEXEC;
break;
}
/*
* Do some additional consistency checks.
* The system requires mapping for this loader. If you try
* to use a file system with no mapping, the format is not valid.
*/
if (!bprm->inode->i_op ||
!bprm->inode->i_op->default_file_ops->mmap) {
#ifdef COFF_DEBUG
printk ("no mmap in fs\n");
#endif
status = -ENOEXEC;
}
}
while (0);
/*
* Allocate a buffer to hold the entire coff section list.
*/
if (status >= 0) {
int nbytes = sections * COFF_SCNHSZ;
sect_bufr = (COFF_SCNHDR *) kmalloc (nbytes, GFP_KERNEL);
if (0 == sect_bufr) {
#ifdef COFF_DEBUG
printk ("kmalloc failed\n");
#endif
status = -ENOEXEC;
}
/*
* Read the section list from the disk file.
*/
else {
int old_fs = get_fs ();
set_fs (get_ds ()); /* Make it point to the proper location */
status = read_exec (bprm->inode, /* INODE for file */
aout_size + COFF_FILHSZ, /* Offset in the file */
(char *) sect_bufr, /* Buffer for read */
nbytes); /* Byte count reqd. */
set_fs (old_fs); /* Restore the selector */
#ifdef COFF_DEBUG
if (status < 0)
printk ("read aout hdr, status = %d\n", status);
#endif
}
}
else
sect_bufr = NULL; /* Errors do not have a section buffer */
/*
* Count the number of sections for the required types and store the location
* of the last section for the three primary types.
*/
text_count = 0;
data_count = 0;
bss_count = 0;
lib_count = 0;
text_sect = NULL;
data_sect = NULL;
bss_sect = NULL;
/*
* Loop through the sections and find the various types
*/
if (status >= 0) {
int nIndex;
COFF_SCNHDR *sect_ptr = sect_bufr;
for (nIndex = 0; nIndex < sections; ++nIndex) {
long int sect_flags = COFF_LONG (sect_ptr->s_flags);
switch (sect_flags) {
case COFF_STYP_TEXT:
text_sect = sect_ptr;
++text_count;
status = is_properly_aligned (sect_ptr);
break;
case COFF_STYP_DATA:
data_sect = sect_ptr;
++data_count;
status = is_properly_aligned (sect_ptr);
break;
case COFF_STYP_BSS:
bss_sect = sect_ptr;
++bss_count;
break;
case COFF_STYP_LIB:
#ifdef COFF_DEBUG
printk (".lib section found\n");
#endif
++lib_count;
break;
default:
break;
}
sect_ptr = (COFF_SCNHDR *) & ((char *) sect_ptr)[COFF_SCNHSZ];
}
/*
* Ensure that there are the required sections. There must be one text
* sections and one each of the data and bss sections for an executable.
* A library may or may not have a data / bss section.
*/
if (text_count != 1) {
status = -ENOEXEC;
#ifdef COFF_DEBUG
printk ("no text sections\n");
#endif
}
else {
if (lib_ok) {
if (data_count != 1 || bss_count != 1) {
status = -ENOEXEC;
#ifdef COFF_DEBUG
printk ("no .data nor .bss sections\n");
#endif
}
}
}
}
/*
* If there is no additional header then assume the file starts at
* the first byte of the text section. This may not be the proper place,
* so the best solution is to include the optional header. A shared library
* __MUST__ have an optional header to indicate that it is a shared library.
*/
if (status >= 0) {
if (aout_size == 0) {
if (!lib_ok) {
status = -ENOEXEC;
#ifdef COFF_DEBUG
printk ("no header in library\n");
#endif
}
start_addr = COFF_LONG (text_sect->s_vaddr);
}
/*
* There is some header. Ensure that it is sufficient.
*/
else {
if (aout_size < COFF_AOUTSZ) {
status = -ENOEXEC;
#ifdef COFF_DEBUG
printk ("header too small\n");
#endif
}
else {
COFF_AOUTHDR *aout_hdr = /* Pointer to a.out header */
(COFF_AOUTHDR *) & ((char *) coff_hdr)[COFF_FILHSZ];
short int aout_magic = COFF_SHORT (aout_hdr->magic); /* id */
/*
* Validate the magic number in the a.out header. If it is valid then
* update the starting symbol location. Do not accept these file formats
* when loading a shared library.
*/
switch (aout_magic) {
case COFF_OMAGIC:
case COFF_ZMAGIC:
case COFF_STMAGIC:
if (!lib_ok) {
status = -ENOEXEC;
#ifdef COFF_DEBUG
printk ("wrong a.out header magic\n");
#endif
}
start_addr = (unsigned int) COFF_LONG (aout_hdr->entry);
break;
/*
* Magic value for a shared library. This is valid only when loading a
* shared library. (There is no need for a start_addr. It won't be used.)
*/
case COFF_SHMAGIC:
if (lib_ok) {
#ifdef COFF_DEBUG
printk ("wrong a.out header magic\n");
#endif
status = -ENOEXEC;
}
break;
default:
#ifdef COFF_DEBUG
printk ("wrong a.out header magic\n");
#endif
status = -ENOEXEC;
break;
}
}
}
}
/*
* Fetch a file pointer to the executable.
*/
if (status >= 0) {
fd = open_inode (bprm->inode, O_RDONLY);
if (fd < 0) {
#ifdef COFF_DEBUG
printk ("can not open inode, result = %d\n", fd);
#endif
status = fd;
}
else
fp = current->files->fd[fd];
}
else
fd = -1; /* Invalidate the open file descriptor */
/*
* Generate the proper values for the text fields
*
* THIS IS THE POINT OF NO RETURN. THE NEW PROCESS WILL TRAP OUT SHOULD
* SOMETHING FAIL IN THE LOAD SEQUENCE FROM THIS POINT ONWARD.
*/
if (status >= 0) {
long text_scnptr = COFF_LONG (text_sect->s_scnptr);
long text_size = COFF_LONG (text_sect->s_size);
long text_vaddr = COFF_LONG (text_sect->s_vaddr);
long data_scnptr;
long data_size;
long data_vaddr;
long bss_size;
long bss_vaddr;
/*
* Generate the proper values for the data fields
*/
if (data_sect != NULL) {
data_scnptr = COFF_LONG (data_sect->s_scnptr);
data_size = COFF_LONG (data_sect->s_size);
data_vaddr = COFF_LONG (data_sect->s_vaddr);
}
else {
data_scnptr = 0;
data_size = 0;
data_vaddr = 0;
}
/*
* Generate the proper values for the bss fields
*/
if (bss_sect != NULL) {
bss_size = COFF_LONG (bss_sect->s_size);
bss_vaddr = COFF_LONG (bss_sect->s_vaddr);
}
else {
bss_size = 0;
bss_vaddr = 0;
}
/*
* Flush the executable from memory. At this point the executable is
* committed to being defined or a segmentation violation will occur.
*/
if (lib_ok) {
#ifdef COFF_DEBUG
printk ("flushing executable\n");
#endif
flush_old_exec (bprm);
/*
* Define the initial locations for the various items in the new process
*/
current->mm->mmap = NULL;
current->mm->rss = 0;
/*
* Construct the parameter and environment string table entries.
*/
bprm->p += change_ldt (0, bprm->page);
bprm->p -= MAX_ARG_PAGES*PAGE_SIZE;
bprm->p = (unsigned long) create_tables ((char *) bprm->p,
bprm->argc,
bprm->envc,
1);
/*
* Do the end processing once the stack has been constructed
*/
current->mm->start_code = text_vaddr & PAGE_MASK;
current->mm->end_code = text_vaddr + text_size;
current->mm->end_data = data_vaddr + data_size;
current->mm->start_brk =
current->mm->brk = bss_vaddr + bss_size;
current->suid =
current->euid = bprm->e_uid;
current->sgid =
current->egid = bprm->e_gid;
current->executable = bprm->inode; /* Store inode for file */
++bprm->inode->i_count; /* Count the open inode */
regs->eip = start_addr; /* Current EIP register */
regs->esp =
current->mm->start_stack = bprm->p;
}
/*
* Map the text pages
*/
#ifdef COFF_DEBUG
printk (".text: vaddr = %d, size = %d, scnptr = %d\n",
text_vaddr,
text_size,
text_scnptr);
#endif
status = do_mmap (fp,
text_vaddr & PAGE_MASK,
text_size + (text_vaddr & ~PAGE_MASK),
PROT_READ | PROT_EXEC,
MAP_FIXED | MAP_SHARED,
text_scnptr & PAGE_MASK);
status = (status == (text_vaddr & PAGE_MASK)) ? 0 : -ENOEXEC;
/*
* Map the data pages
*/
if (status >= 0 && data_size != 0) {
#ifdef COFF_DEBUG
printk (".data: vaddr = %d, size = %d, scnptr = %d\n",
data_vaddr,
data_size,
data_scnptr);
#endif
status = do_mmap (fp,
data_vaddr & PAGE_MASK,
data_size + (data_vaddr & ~PAGE_MASK),
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE,
data_scnptr & PAGE_MASK);
status = (status == (data_vaddr & PAGE_MASK)) ? 0 : -ENOEXEC;
}
/*
* Construct the bss data for the process. The bss ranges from the
* end of the data (which may not be on a page boundary) to the end
* of the bss section. Allocate any necessary pages for the data.
*/
if (status >= 0 && bss_size != 0) {
#ifdef COFF_DEBUG
printk (".bss: vaddr = %d, size = %d\n",
bss_vaddr,
bss_size);
#endif
zeromap_page_range (PAGE_ALIGN (bss_vaddr),
PAGE_ALIGN (bss_size),
PAGE_COPY);
status = clear_memory (bss_vaddr, bss_size);
}
/*
* Load any shared library for the executable.
*/
if (status >= 0 && lib_ok && lib_count != 0) {
int nIndex;
COFF_SCNHDR *sect_ptr = sect_bufr;
/*
* Find the library sections. (There should be at least one. It was counted
* earlier.) This will eventually recurse to our code and load the shared
* library with our own procedures.
*/
for (nIndex = 0; nIndex < sections; ++nIndex) {
long int sect_flags = COFF_LONG (sect_ptr->s_flags);
if (sect_flags == COFF_STYP_LIB) {
status = preload_library (bprm, sect_ptr, fp);
if (status != 0)
break;
}
sect_ptr = (COFF_SCNHDR *) &((char *) sect_ptr) [COFF_SCNHSZ];
}
}
/*
* Generate any needed trap for this process. If an error occurred then
* generate a segmentation violation. If the process is being debugged
* then generate the load trap. (Note: If this is a library load then
* do not generate the trap here. Pass the error to the caller who
* will do it for the process in the outer lay of this procedure call.)
*/
if (lib_ok) {
if (status < 0)
send_sig (SIGSEGV, current, 0); /* Generate the error trap */
else {
if (current->flags & PF_PTRACED)
send_sig (SIGTRAP, current, 0);
}
status = 0; /* We are committed. It can't fail */
}
}
/*
* Do any cleanup processing
*/
if (fd >= 0)
sys_close (fd); /* Close unused code file */
if (sect_bufr != NULL)
kfree (sect_bufr); /* Release section list buffer */
/*
* Return the completion status.
*/
#ifdef COFF_DEBUG
printk ("binfmt_coff: result = %d\n", status);
#endif
return (status);
}
int register_files(char* build, char* project, char* path) {
ssize_t res = 0;
int loaded = 0;
create_tables();
if (SQL("BEGIN")) { return -1; }
prune_old_entries(build, project);
//
// Enumerate the files in the path (DSTROOT) and associate them
// with the project name and version in the sqlite database.
// Uses ent->fts_number to mark which files we have and have
// not seen before.
//
// Skip the first result, since that is . of the DSTROOT itself.
char* path_argv[] = { path, NULL };
FTS* fts = fts_open(path_argv, FTS_PHYSICAL | FTS_COMFOLLOW | FTS_XDEV, compare);
FTSENT* ent = fts_read(fts); // throw away the entry for the DSTROOT itself
while ((ent = fts_read(fts)) != NULL) {
char filename[MAXPATHLEN+1];
char symlink[MAXPATHLEN+1];
ssize_t len;
// Filename
filename[0] = 0;
ent_filename(ent, filename, MAXPATHLEN);
// Symlinks
symlink[0] = 0;
if (ent->fts_info == FTS_SL || ent->fts_info == FTS_SLNONE) {
len = readlink(ent->fts_accpath, symlink, MAXPATHLEN);
if (len >= 0) symlink[len] = 0;
}
// Default to empty SHA-1 checksum
char* checksum = strdup(" ");
// Checksum regular files
if (ent->fts_info == FTS_F) {
int fd = open(ent->fts_accpath, O_RDONLY);
if (fd == -1) {
perror(filename);
return -1;
}
int isMachO;
res = register_libraries(fd, build, project, filename, &isMachO);
lseek(fd, (off_t)0, SEEK_SET);
if (isMachO && have_undo_prebinding() == 0) {
checksum = calculate_unprebound_digest(ent->fts_accpath);
} else {
checksum = calculate_digest(fd);
}
close(fd);
}
// register regular files and symlinks in the DB
if (ent->fts_info == FTS_F || ent->fts_info == FTS_SL || ent->fts_info == FTS_SLNONE) {
res = SQL("INSERT INTO files (build, project, path) VALUES (%Q,%Q,%Q)",
build, project, filename);
++loaded;
}
// add all regular files, directories, and symlinks to the manifest
if (ent->fts_info == FTS_F || ent->fts_info == FTS_D ||
ent->fts_info == FTS_SL || ent->fts_info == FTS_SLNONE) {
fprintf(stdout, "%s %o %d %d %lld .%s%s%s\n",
checksum,
ent->fts_statp->st_mode,
ent->fts_statp->st_uid,
ent->fts_statp->st_gid,
(ent->fts_info != FTS_D) ? ent->fts_statp->st_size : (off_t)0,
filename,
symlink[0] ? " -> " : "",
symlink[0] ? symlink : "");
}
free(checksum);
}
fts_close(fts);
if (SQL("COMMIT")) { return -1; }
fprintf(stderr, "%s - %d files registered.\n", project, loaded);
return (int)res;
}
