template<class T> inline void BasicColumn<T>::insert(std::size_t row_ndx, T value)
{
std::size_t size = this->size(); // Slow
TIGHTDB_ASSERT(row_ndx <= size);
std::size_t row_ndx_2 = row_ndx == size ? tightdb::npos : row_ndx;
std::size_t num_rows = 1;
do_insert(row_ndx_2, value, num_rows); // Throws
}
template<class T> inline void BasicColumn<T>::insert(std::size_t row_ndx, T value)
{
std::size_t size = this->size(); // Slow
REALM_ASSERT_3(row_ndx, <=, size);
std::size_t row_ndx_2 = row_ndx == size ? realm::npos : row_ndx;
std::size_t num_rows = 1;
do_insert(row_ndx_2, value, num_rows); // Throws
}
inline void StringEnumColumn::insert(size_t row_ndx, StringData value)
{
REALM_ASSERT_DEBUG(!(!m_nullable && value.is_null()));
size_t column_size = this->size();
REALM_ASSERT_3(row_ndx, <=, column_size);
size_t num_rows = 1;
bool is_append = row_ndx == column_size;
do_insert(row_ndx, value, num_rows, is_append); // Throws
}
inline void StringColumn::insert(std::size_t row_ndx, StringData value)
{
REALM_ASSERT(!(value.is_null() && !m_nullable));
std::size_t size = this->size();
REALM_ASSERT_3(row_ndx, <=, size);
std::size_t num_rows = 1;
bool is_append = row_ndx == size;
do_insert(row_ndx, value, num_rows, is_append); // Throws
}
// Implementing pure virtual method of ColumnBase.
inline void StringColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
size_t prior_num_rows)
{
REALM_ASSERT_DEBUG(prior_num_rows == size());
REALM_ASSERT(row_ndx <= prior_num_rows);
StringData value = m_nullable ? realm::null() : StringData("");
bool is_append = (row_ndx == prior_num_rows);
do_insert(row_ndx, value, num_rows_to_insert, is_append); // Throws
}
inline void BinaryColumn::insert_string(size_t row_ndx, StringData value)
{
size_t size = this->size(); // Slow
REALM_ASSERT_3(row_ndx, <=, size);
size_t row_ndx_2 = row_ndx == size ? realm::npos : row_ndx;
BinaryData value_2(value.data(), value.size());
bool add_zero_term = false;
size_t num_rows = 1;
do_insert(row_ndx_2, value_2, add_zero_term, num_rows); // Throws
}
inline void BinaryColumn::add(BinaryData value)
{
if (value.is_null() && !m_nullable)
throw LogicError(LogicError::column_not_nullable);
size_t row_ndx = realm::npos;
bool add_zero_term = false;
size_t num_rows = 1;
do_insert(row_ndx, value, add_zero_term, num_rows); // Throws
}
void buffer_insert_bytes(const char *buf, long len)
{
long rec_len = len;
view_reset_preferred_x(view);
if (len == 0)
return;
if (buf[len - 1] != '\n' && block_iter_is_eof(&view->cursor)) {
// force newline at EOF
do_insert("\n", 1);
rec_len++;
}
do_insert(buf, len);
record_insert(rec_len);
if (buffer->views.count > 1)
fix_cursors(block_iter_get_offset(&view->cursor), len, 0);
}
bool RSNHandshakeCapturer::process_packet(const PDU& pdu) {
const RSNEAPOL* eapol = pdu.find_pdu<RSNEAPOL>();
const Dot11Data* dot11 = pdu.find_pdu<Dot11Data>();
if (!eapol || !dot11) {
return false;
}
// Use this to identify each flow, regardless of the direction
pair<address_type, address_type> addresses;
addresses.first = min(dot11->src_addr(), dot11->dst_addr());
addresses.second = max(dot11->src_addr(), dot11->dst_addr());
// 1st packet
if (eapol->key_t() && eapol->key_ack() && !eapol->key_mic() && !eapol->install()) {
handshakes_[addresses].assign(eapol, eapol + 1);
}
// 2nd and 4th packets
else if (eapol->key_t() && !eapol->key_ack() && eapol->key_mic() && !eapol->install()) {
// 2nd packet won't have the secure bit set
if (!eapol->secure()) {
do_insert(addresses, eapol, 1);
}
// Otherwise, this should be the 4th and last packet
else if (do_insert(addresses, eapol, 3)) {
completed_handshakes_.push_back(
handshake_type(
addresses.first,
addresses.second,
handshakes_[addresses]
)
);
handshakes_.erase(addresses);
return true;
}
}
// 3nd packet
else if (eapol->key_t() && eapol->key_ack() && eapol->key_mic() && eapol->install()) {
do_insert(addresses, eapol, 2);
}
return false;
}
inline void BinaryColumn::insert(size_t row_ndx, BinaryData value)
{
if (value.is_null() && !m_nullable)
throw LogicError(LogicError::column_not_nullable);
size_t size = this->size(); // Slow
REALM_ASSERT_3(row_ndx, <=, size);
size_t row_ndx_2 = row_ndx == size ? realm::npos : row_ndx;
bool add_zero_term = false;
size_t num_rows = 1;
do_insert(row_ndx_2, value, add_zero_term, num_rows); // Throws
}
// Implementing pure virtual method of ColumnBase.
inline void BinaryColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
size_t prior_num_rows, bool insert_nulls)
{
REALM_ASSERT_DEBUG(prior_num_rows == size());
REALM_ASSERT(row_ndx <= prior_num_rows);
REALM_ASSERT(!insert_nulls || m_nullable);
size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
BinaryData value = m_nullable ? BinaryData() : BinaryData("", 0);
bool add_zero_term = false;
do_insert(row_ndx_2, value, add_zero_term, num_rows_to_insert); // Throws
}
static void test_static_exec( const testdata_t data[], size_t len, const char *delim )
{
usher_t *u = usher_alloc( delim, NULL );
usher_error_t err;
usher_glob_t glob;
const testdata_t *item;
size_t i, j, vlen;
char *sval;
for( i = 0; i < len; i++ ){
do_insert( u, i, data );
}
for( i = 0; i < len; i++ )
{
item = &data[i];
glob.nitems = 0;
glob.items = NULL;
err = usher_exec( u, item->key, &glob );
if( err ){
printf( "\nEXEC ERR[%zu]: %s -> %s\n", i, item->path, usher_strerror( err ) );
assert(0);
}
else if( glob.nitems != item->globs.nitems ){
printf(
"\nEXEC ERR[%zu]: %s -> number of catch param should be %zu but %zu\n",
i, item->path, item->globs.nitems, glob.nitems
);
printf( "key: %s\n", item->key );
assert(0);
}
for( j = 0; j < glob.nitems; j++ ){
assert( strcmp( (const char*)glob.items[j].name, (const char*)item->globs.items[j].name ) == 0 );
vlen = glob.items[j].tail - glob.items[j].head;
sval = pnalloc( vlen + 1, char );
memcpy( sval, glob.items[j].head, vlen );
sval[vlen] = 0;
assert( strcmp( sval, (const char*)item->globs.items[j].head ) == 0 );
pdealloc( sval );
}
usher_glob_dealloc( &glob );
}
usher_dealloc( u );
}
typename Backend::widget_handle do_insert(typename Backend::widget_handle& parent, edit_text<Backend>& element)
{
Backend::pre(element);
if (!element.name_m.name_m.empty())
{
do_insert(parent, element.name_m);
}
element.control_m = Backend::make_edit_text(parent,
element.rows_m,
element.scrollable_m,
element.password_m,
element.alt_text_m,
element);
return Backend::post(parent, element.control_m);
}
static ERL_NIF_TERM
evaluate_command(esqlite_command *cmd, esqlite_connection *conn)
{
esqlite_statement *stmt = NULL;
if(cmd->stmt) {
if(!enif_get_resource(cmd->env, cmd->stmt, esqlite_statement_type, (void **) &stmt)) {
return make_error_tuple(cmd->env, "invalid_statement");
}
}
switch(cmd->type) {
case cmd_open:
return do_open(cmd->env, conn, cmd->arg);
case cmd_update_hook_set:
return do_set_update_hook(cmd->env, conn, cmd->arg);
case cmd_exec:
return do_exec(cmd->env, conn, cmd->arg);
case cmd_changes:
return do_changes(cmd->env, conn, cmd->arg);
case cmd_prepare:
return do_prepare(cmd->env, conn, cmd->arg);
case cmd_multi_step:
return do_multi_step(cmd->env, conn->db, stmt->statement, cmd->arg);
case cmd_reset:
return do_reset(cmd->env, conn->db, stmt->statement);
case cmd_bind:
return do_bind(cmd->env, conn->db, stmt->statement, cmd->arg);
case cmd_column_names:
return do_column_names(cmd->env, stmt->statement);
case cmd_column_types:
return do_column_types(cmd->env, stmt->statement);
case cmd_close:
return do_close(cmd->env, conn, cmd->arg);
case cmd_insert:
return do_insert(cmd->env, conn, cmd->arg);
case cmd_get_autocommit:
return do_get_autocommit(cmd->env, conn);
default:
return make_error_tuple(cmd->env, "invalid_command");
}
}
static int
set_status_func(
struct xuser_cnts_state *data,
int user_id,
int status)
{
struct xuser_mongo_cnts_state *state = (struct xuser_mongo_cnts_state *) data;
struct team_extra *extra = do_get_entry(state, user_id);
if (!extra) return -1;
if (extra->status == status) return 0;
extra->status = status;
if (ej_uuid_is_nonempty(extra->uuid)) {
bson *doc = bson_new();
bson_append_int32(doc, "status", status);
bson_finish(doc);
return do_update(state, extra, NULL, doc);
} else {
return do_insert(state, extra);
}
}
void handle_insert_call(struct mg_connection* nc,
struct http_message* hm)
{
int err_check = db_file->header.num_files < db_file->header.max_files ? 0 :
ERR_FULL_DATABASE;
if (err_check == 0) {
char var_name[100];
char file_name[MAX_PIC_ID + 1];
const char* chunk;
size_t chunk_len = 0;
size_t n1 = 0;
size_t n2 = 0;
while ((n2 = mg_parse_multipart(hm->body.p + n1,
hm->body.len - n1,
var_name, sizeof(var_name),
file_name, sizeof(file_name),
&chunk, &chunk_len)) > 0) {
printf("var: %s, file_name: %s, size: %zu, chunk: [%.*s]\n",
var_name, file_name, chunk_len, (int) chunk_len, chunk);
n1 += n2;
}
err_check = do_insert(chunk, chunk_len, file_name, db_file);
// Success
if (err_check == 0) {
mg_printf(nc,
"HTTP/1.1 302 Found\r\n"
"Location: http://localhost:%s/index.html\r\n",
s_http_port);
nc->flags |= MG_F_SEND_AND_CLOSE;
}
}
if (err_check != 0) {
mg_error(nc, err_check);
}
}
static int
append_warning_func(
struct xuser_cnts_state *data,
int user_id,
int issuer_id,
const ej_ip_t *issuer_ip,
time_t issue_date,
const unsigned char *txt,
const unsigned char *cmt)
{
struct xuser_mongo_cnts_state *state = (struct xuser_mongo_cnts_state *) data;
struct team_extra *extra = do_get_entry(state, user_id);
if (!extra) return -1;
if (extra->warn_u == extra->warn_a) {
extra->warn_a *= 2;
if (!extra->warn_a) extra->warn_a = 8;
XREALLOC(extra->warns, extra->warn_a);
}
struct team_warning *cur_warn = NULL;
XCALLOC(cur_warn, 1);
extra->warns[extra->warn_u++] = cur_warn;
cur_warn->date = issue_date;
cur_warn->issuer_id = issuer_id;
cur_warn->issuer_ip = *issuer_ip;
cur_warn->text = xstrdup(txt);
cur_warn->comment = xstrdup(cmt);
if (ej_uuid_is_nonempty(extra->uuid)) {
bson *w = team_warning_bson_unparse(cur_warn);
bson *doc = bson_new();
bson_append_document(doc, "warnings", w);
bson_free(w); w = NULL;
bson_finish(doc);
return do_update(state, extra, "$push", doc);
} else {
return do_insert(state, extra);
}
}
bool PlanTableManager::InsertDataChunks(QString& str_sql_query, QString& str_sql_error) const {
namespace frd = format_reader::dbf;
namespace fr = format_reader;
frd::DbfFormatReader dbf_format_reader;
if (!dbf_format_reader.Open(table_absolute_file_path_))
return false;
fr::Record record;
int record_amount = 0;
table_helper_.TransactionBegin(str_sql_query);
while(dbf_format_reader.Read(record)) {
// exit by cancel operation
if (canceled_) return false;
if (is_excluded(allowed_regions_, record)) {
++record_amount;
continue;
}
do_insert(str_sql_query, record);
++record_amount;
if (record_amount % kDataChunkSize == 0) {
table_helper_.TransactionEnd(str_sql_query);
if (!execute_sql_query(str_sql_query, str_sql_error))
return false;
str_sql_query.clear();
table_helper_.TransactionBegin(str_sql_query);
}
}
table_helper_.TransactionEnd(str_sql_query);
if (!execute_sql_query(str_sql_query, str_sql_error))
return false;
// we skip the dublicate records
// assert(record_amount == dbf_format_reader.records_amount());
return true;
}
static ERL_NIF_TERM
evaluate_command(esqlite_command *cmd, esqlite_connection *conn)
{
switch(cmd->type) {
case cmd_open:
return do_open(cmd->env, conn, cmd->arg);
case cmd_exec:
return do_exec(cmd->env, conn, cmd->arg);
case cmd_prepare:
return do_prepare(cmd->env, conn, cmd->arg);
case cmd_step:
return do_step(cmd->env, conn->db, cmd->stmt);
case cmd_bind:
return do_bind(cmd->env, conn->db, cmd->stmt, cmd->arg);
case cmd_column_names:
return do_column_names(cmd->env, cmd->stmt);
case cmd_close:
return do_close(cmd->env, conn, cmd->arg);
case cmd_insert:
return do_insert(cmd->env, conn, cmd->arg);
default:
return make_error_tuple(cmd->env, "invalid_command");
}
}
static void run_application(MYSQL &mysql,
Ndb_cluster_connection &cluster_connection,
const char* table,
const char* db)
{
/********************************************
* Connect to database via mysql-c *
********************************************/
char db_stmt[256];
sprintf(db_stmt, "CREATE DATABASE %s\n", db);
mysql_query(&mysql, db_stmt);
sprintf(db_stmt, "USE %s", db);
if (mysql_query(&mysql, db_stmt) != 0) MYSQLERROR(mysql);
create_table(mysql, table);
/********************************************
* Connect to database via NdbApi *
********************************************/
// Object representing the database
Ndb myNdb( &cluster_connection, db );
if (myNdb.init()) APIERROR(myNdb.getNdbError());
/*
* Do different operations on database
*/
do_insert(myNdb, table);
do_update(myNdb, table);
do_delete(myNdb, table);
do_read(myNdb, table);
/*
* Drop the table
*/
drop_table(mysql, table);
sprintf(db_stmt, "DROP DATABASE %s\n", db);
mysql_query(&mysql, db_stmt);
}
void insert(const key_type & key, const value_type & value) {
m_root = do_insert(m_root, key, value);
}
int
main(int argc, const char** argv){
ndb_init();
int _help = 0;
const char* db = 0;
const char* connectstring1 = 0;
const char* connectstring2 = 0;
struct getargs args[] = {
{ "connectstring1", 'c',
arg_string, &connectstring1, "connectstring1", "" },
{ "connectstring2", 'C',
arg_string, &connectstring2, "connectstring2", "" },
{ "database", 'd', arg_string, &db, "Database", "" },
{ "usage", '?', arg_flag, &_help, "Print help", "" }
};
int num_args = sizeof(args) / sizeof(args[0]);
int optind = 0, i;
char desc[] =
"<tabname>+ \nThis program listen to events on specified tables\n";
if(getarg(args, num_args, argc, argv, &optind) ||
argv[optind] == NULL || _help) {
arg_printusage(args, num_args, argv[0], desc);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
// Connect to Ndb
Ndb_cluster_connection con(connectstring1);
if(con.connect(12, 5, 1) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb( &con, db ? db : "TEST_DB" );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
// Connect to Ndb and wait for it to become ready
while(MyNdb.waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
Ndb_cluster_connection *con2 = NULL;
Ndb *ndb2 = NULL;
if (connectstring2)
{
con2 = new Ndb_cluster_connection(connectstring2);
if(con2->connect(12, 5, 1) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
ndb2 = new Ndb( con2, db ? db : "TEST_DB" );
if(ndb2->init() != 0){
ERR(ndb2->getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
// Connect to Ndb and wait for it to become ready
while(ndb2->waitUntilReady() != 0)
ndbout << "Waiting for ndb to become ready..." << endl;
}
int result = 0;
NdbDictionary::Dictionary *myDict = MyNdb.getDictionary();
Vector<NdbDictionary::Event*> events;
Vector<NdbEventOperation*> event_ops;
int sz = 0;
for(i= optind; i<argc; i++)
{
const NdbDictionary::Table* table= myDict->getTable(argv[i]);
if(!table)
{
ndbout_c("Could not find table: %s, skipping", argv[i]);
continue;
}
BaseString name;
name.appfmt("EV-%s", argv[i]);
NdbDictionary::Event *myEvent= new NdbDictionary::Event(name.c_str());
myEvent->setTable(table->getName());
myEvent->addTableEvent(NdbDictionary::Event::TE_ALL);
for(int a = 0; a < table->getNoOfColumns(); a++){
myEvent->addEventColumn(a);
}
if (myDict->createEvent(* myEvent))
{
if(myDict->getNdbError().classification == NdbError::SchemaObjectExists)
{
g_info << "Event creation failed event exists. Removing...\n";
if (myDict->dropEvent(name.c_str()))
{
g_err << "Failed to drop event: " << myDict->getNdbError() << endl;
result = 1;
goto end;
}
// try again
if (myDict->createEvent(* myEvent))
{
g_err << "Failed to create event: " << myDict->getNdbError() << endl;
result = 1;
goto end;
}
}
else
{
g_err << "Failed to create event: " << myDict->getNdbError() << endl;
result = 1;
goto end;
}
}
events.push_back(myEvent);
NdbEventOperation* pOp = MyNdb.createEventOperation(name.c_str());
if ( pOp == NULL ) {
g_err << "Event operation creation failed" << endl;
result = 1;
goto end;
}
event_values.push_back(Vector<NdbRecAttr *>());
event_pre_values.push_back(Vector<NdbRecAttr *>());
for (int a = 0; a < table->getNoOfColumns(); a++)
{
event_values[sz].
push_back(pOp->getValue(table->getColumn(a)->getName()));
event_pre_values[sz].
push_back(pOp->getPreValue(table->getColumn(a)->getName()));
}
event_ops.push_back(pOp);
{
struct Table_info ti;
ti.id = sz;
table_infos.push_back(ti);
}
pOp->setCustomData((void *)&table_infos[sz]);
sz++;
}
for(i= 0; i<(int)event_ops.size(); i++)
{
if (event_ops[i]->execute())
{
g_err << "operation execution failed: " << event_ops[i]->getNdbError()
<< endl;
result = 1;
goto end;
}
}
struct Trans_arg trans_arg;
while(true)
{
while(MyNdb.pollEvents(100) == 0);
NdbEventOperation* pOp= MyNdb.nextEvent();
while(pOp)
{
Uint64 gci= pOp->getGCI();
Uint64 cnt_i= 0, cnt_u= 0, cnt_d= 0;
if (ndb2)
do_begin(ndb2, trans_arg);
do
{
switch(pOp->getEventType())
{
case NdbDictionary::Event::TE_INSERT:
cnt_i++;
if (ndb2)
do_insert(trans_arg, pOp);
break;
case NdbDictionary::Event::TE_DELETE:
cnt_d++;
if (ndb2)
do_delete(trans_arg, pOp);
break;
case NdbDictionary::Event::TE_UPDATE:
cnt_u++;
if (ndb2)
do_update(trans_arg, pOp);
break;
case NdbDictionary::Event::TE_CLUSTER_FAILURE:
break;
case NdbDictionary::Event::TE_ALTER:
break;
case NdbDictionary::Event::TE_DROP:
break;
case NdbDictionary::Event::TE_NODE_FAILURE:
break;
case NdbDictionary::Event::TE_SUBSCRIBE:
case NdbDictionary::Event::TE_UNSUBSCRIBE:
break;
default:
/* We should REALLY never get here. */
ndbout_c("Error: unknown event type: %u",
(Uint32)pOp->getEventType());
abort();
}
} while ((pOp= MyNdb.nextEvent()) && gci == pOp->getGCI());
if (ndb2)
do_commit(trans_arg);
ndbout_c("GCI: %lld events: %lld(I) %lld(U) %lld(D)", gci, cnt_i, cnt_u, cnt_d);
}
}
end:
for(i= 0; i<(int)event_ops.size(); i++)
MyNdb.dropEventOperation(event_ops[i]);
if (ndb2)
delete ndb2;
if (con2)
delete con2;
return NDBT_ProgramExit(NDBT_OK);
}
template<class T> inline void BasicColumn<T>::add(T value)
{
std::size_t row_ndx = tightdb::npos;
std::size_t num_rows = 1;
do_insert(row_ndx, value, num_rows); // Throws
}
inline void BasicColumn<T>::insert(std::size_t row_ndx, std::size_t num_rows, bool is_append)
{
std::size_t row_ndx_2 = is_append ? tightdb::npos : row_ndx;
T value = T();
do_insert(row_ndx_2, value, num_rows); // Throws
}
void
editor(int descr, dbref player, const char *command)
{
dbref program;
int arg[MAX_ARG + 1];
char buf[BUFFER_LEN];
const char *word[MAX_ARG + 1];
int i, j; /* loop variables */
program = PLAYER_CURR_PROG(player);
/* check to see if we are insert mode */
if (PLAYER_INSERT_MODE(player)) {
insert(player, command); /* insert it! */
return;
}
/* parse the commands */
for (i = 0; i <= MAX_ARG && *command; i++) {
while (*command && isspace(*command))
command++;
j = 0;
while (*command && !isspace(*command)) {
buf[j] = *command;
command++, j++;
}
buf[j] = '\0';
word[i] = alloc_string(buf);
if ((i == 1) && !string_compare(word[0], "def")) {
if (word[1] && (word[1][0] == '.' || (word[1][0] >= '0' && word[1][0] <= '9'))) {
notify(player, "Invalid macro name.");
return;
}
while (*command && isspace(*command))
command++;
word[2] = alloc_string(command);
if (!word[2])
notify(player, "Invalid definition syntax.");
else {
if (insert_macro(word[1], word[2], player, ¯otop)) {
notify(player, "Entry created.");
} else {
notify(player, "That macro already exists!");
}
}
for (; i >= 0; i--) {
if (word[i])
free((void *) word[i]);
}
return;
}
arg[i] = atoi(buf);
if (arg[i] < 0) {
notify(player, "Negative arguments not allowed!");
for (; i >= 0; i--) {
if (word[i])
free((void *) word[i]);
}
return;
}
}
i--;
while ((i >= 0) && !word[i])
i--;
if (i < 0) {
return;
} else {
switch (word[i][0]) {
case KILL_COMMAND:
if (!Wizard(player)) {
notify(player, "I'm sorry Dave, but I can't let you do that.");
} else {
if (kill_macro(word[0], player, ¯otop))
notify(player, "Macro entry deleted.");
else
notify(player, "Macro to delete not found.");
}
break;
case SHOW_COMMAND:
list_macros(word, i, player, 1);
break;
case SHORTSHOW_COMMAND:
list_macros(word, i, player, 0);
break;
case INSERT_COMMAND:
do_insert(player, program, arg, i);
notify(player, "Entering insert mode.");
break;
case DELETE_COMMAND:
do_delete(player, program, arg, i);
break;
case QUIT_EDIT_COMMAND:
do_quit(player, program);
notify(player, "Editor exited.");
break;
case COMPILE_COMMAND:
/* compile code belongs in compile.c, not in the editor */
do_compile(descr, player, program, 1);
notify(player, "Compiler done.");
break;
case LIST_COMMAND:
do_list(player, program, arg, i);
break;
case EDITOR_HELP_COMMAND:
spit_file(player, EDITOR_HELP_FILE);
break;
case VIEW_COMMAND:
val_and_head(player, arg, i);
break;
case UNASSEMBLE_COMMAND:
disassemble(player, program);
break;
case NUMBER_COMMAND:
toggle_numbers(player, arg, i);
break;
case PUBLICS_COMMAND:
list_publics(descr, player, arg, i);
break;
default:
notify(player, "Illegal editor command.");
break;
}
}
for (; i >= 0; i--) {
if (word[i])
free((void *) word[i]);
}
}
int do_gbcollect(struct pictdb_file* db_file, const char* db_name,
const char* tmp_name)
{
// Check arguments
if (db_file == NULL || db_name == NULL || tmp_name == NULL) {
return ERR_INVALID_ARGUMENT;
}
if (strlen(db_name) == 0 || strlen(db_name) > MAX_DB_NAME) {
return ERR_INVALID_FILENAME;
}
if (strlen(tmp_name) == 0 || strlen(tmp_name) > MAX_DB_NAME) {
return ERR_INVALID_FILENAME;
}
// Initialize new database
struct pictdb_file temp = {
.fpdb = NULL, .header = db_file->header, .metadata = NULL
};
int ret = do_create(tmp_name, &temp);
if (ret != 0) {
return ret;
}
struct pict_metadata* pics = db_file->metadata; // Will be used often
for (size_t i = 0; ret == 0 && i < db_file->header.max_files; ++i) {
char* image = NULL;
uint32_t size = 0;
// Read valid image from old db and insert it to the new one
if (pics[i].is_valid == NON_EMPTY) {
ret = do_read(pics[i].pict_id, RES_ORIG, &image, &size, db_file);
ret = ret == 0 ? do_insert(image, size, pics[i].pict_id, &temp) : ret;
// Resize the images that are resized in the old db.
for (int r = 0; ret == 0 && r < RES_ORIG; ++r) {
if (pics[i].size[r] != 0 && pics[i].offset[r] != 0) {
ret = lazily_resize(r, &temp, temp.header.num_files - 1);
}
}
free(image);
}
}
// Update the header
ret = ret == 0 ? update_header(&temp, &db_file->header) : ret;
do_close(db_file); // Close old db before deleting it
do_close(&temp);
if (ret != 0) {
remove(tmp_name);
} else {
// Remove old db and move new one
ret = remove(db_name);
ret = ret != -1 ? rename(tmp_name, db_name) : ret;
ret = ret == -1 ? ERR_IO : ret;
}
return ret;
}
int update_header(struct pictdb_file* temp,
const struct pictdb_header* orig_header)
{
temp->header.db_version = orig_header->db_version;
strcpy(temp->header.db_name, orig_header->db_name);
int ret = fseek(temp->fpdb, 0, SEEK_SET);
if (ret == 0) {
ret = fwrite(&temp->header, sizeof(struct pictdb_header), 1, temp->fpdb);
return ret == 1 ? 0 : ERR_IO;
}
return ERR_IO;
}
