Rollback fixes and get_node_actions

5 files changed, 579 insertions, 545 deletions

diff --git a/src/rollback.cpp b/src/rollback.cpp
index b95cc7bf3..4dc462af6 100644
--- a/src/rollback.cpp
+++ b/src/rollback.cpp
@@ -48,41 +48,40 @@ sqlite3_stmt* dbs_knownActor_insert;
 sqlite3_stmt* dbs_knownNode_select;
 sqlite3_stmt* dbs_knownNode_insert;
 
-struct Stack
-{
+struct Stack {
 	int node;
 	int quantity;
 };
-struct ActionRow
-{
-	int			id;
-	int			actor;
-	int			timestamp;
-	int			type;
-	std::string	location, list;
-	int			index, add;
-	Stack		stack;
-	int			nodeMeta;
-	int			x, y, z;
-	int			oldNode;
-	int			oldParam1, oldParam2;
-	std::string	oldMeta;
-	int			newNode;
-	int			newParam1, newParam2;
-	std::string	newMeta;
-	int			guessed;
+struct ActionRow {
+	int         id;
+	int         actor;
+	time_t      timestamp;
+	int         type;
+	std::string location, list;
+	int         index, add;
+	Stack       stack;
+	int         nodeMeta;
+	int         x, y, z;
+	int         oldNode;
+	int         oldParam1, oldParam2;
+	std::string oldMeta;
+	int         newNode;
+	int         newParam1, newParam2;
+	std::string newMeta;
+	int         guessed;
 };
-struct Entity
-{
-	int			id;
-	std::string	name;
+
+struct Entity {
+	int         id;
+	std::string name;
 };
+
 typedef std::vector<Entity> Entities;
 
 Entities KnownActors;
 Entities KnownNodes;
 
-void registerNewActor (int id, std::string name)
+void registerNewActor(int id, std::string name)
 {
 	Entity newActor;
 
@@ -93,7 +92,8 @@ void registerNewActor (int id, std::string name)
 
 	//std::cout << "New actor registered: " << id << " | " << name << std::endl;
 }
-void registerNewNode (int id, std::string name)
+
+void registerNewNode(int id, std::string name)
 {
 	Entity newNode;
 
@@ -104,17 +104,19 @@ void registerNewNode (int id, std::string name)
 
 	//std::cout << "New node registered: " << id << " | " << name << std::endl;
 }
-int getActorId (std::string name)
+
+int getActorId(std::string name)
 {
 	Entities::const_iterator iter;
 
 	for (iter = KnownActors.begin(); iter != KnownActors.end(); ++iter)
-		if (iter->name == name)
+		if (iter->name == name) {
 			return iter->id;
+		}
 
-	sqlite3_reset     (dbs_knownActor_insert);
-	sqlite3_bind_text (dbs_knownActor_insert, 1, name.c_str(), -1, NULL);
-	sqlite3_step      (dbs_knownActor_insert);
+	sqlite3_reset(dbs_knownActor_insert);
+	sqlite3_bind_text(dbs_knownActor_insert, 1, name.c_str(), -1, NULL);
+	sqlite3_step(dbs_knownActor_insert);
 
 	int id = sqlite3_last_insert_rowid(dbh);
 
@@ -124,17 +126,19 @@ int getActorId (std::string name)
 
 	return id;
 }
-int getNodeId (std::string name)
+
+int getNodeId(std::string name)
 {
 	Entities::const_iterator iter;
 
 	for (iter = KnownNodes.begin(); iter != KnownNodes.end(); ++iter)
-		if (iter->name == name)
+		if (iter->name == name) {
 			return iter->id;
+		}
 
-	sqlite3_reset     (dbs_knownNode_insert);
-	sqlite3_bind_text (dbs_knownNode_insert, 1, name.c_str(), -1, NULL);
-	sqlite3_step      (dbs_knownNode_insert);
+	sqlite3_reset(dbs_knownNode_insert);
+	sqlite3_bind_text(dbs_knownNode_insert, 1, name.c_str(), -1, NULL);
+	sqlite3_step(dbs_knownNode_insert);
 
 	int id = sqlite3_last_insert_rowid(dbh);
 
@@ -142,31 +146,36 @@ int getNodeId (std::string name)
 
 	return id;
 }
-const char * getActorName (int id)
+
+const char * getActorName(int id)
 {
 	Entities::const_iterator iter;
 
 	//std::cout << "getActorName of id " << id << std::endl;
 
 	for (iter = KnownActors.begin(); iter != KnownActors.end(); ++iter)
-		if (iter->id == id)
+		if (iter->id == id) {
 			return iter->name.c_str();
+		}
 
 	return "";
 }
-const char * getNodeName (int id)
+
+const char * getNodeName(int id)
 {
 	Entities::const_iterator iter;
 
 	//std::cout << "getNodeName of id " << id << std::endl;
 
 	for (iter = KnownNodes.begin(); iter != KnownNodes.end(); ++iter)
-		if (iter->id == id)
+		if (iter->id == id) {
 			return iter->name.c_str();
+		}
 
 	return "";
 }
-Stack getStackFromString (std::string text)
+
+Stack getStackFromString(std::string text)
 {
 	Stack stack;
 
@@ -177,7 +186,8 @@ Stack getStackFromString (std::string text)
 
 	return stack;
 }
-std::string getStringFromStack (Stack stack)
+
+std::string getStringFromStack(Stack stack)
 {
 	std::string text;
 
@@ -187,199 +197,204 @@ std::string getStringFromStack (Stack stack)
 
 	return text;
 }
-bool SQL_createDatabase (void)
+
+bool SQL_createDatabase(void)
 {
 	infostream << "CreateDB:" << dbp << std::endl;
 
-	int dbs = sqlite3_exec(
-		dbh
-	,	"CREATE TABLE IF NOT EXISTS `actor` ("
-		"`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
-		"`name` TEXT NOT NULL);"
-		"CREATE TABLE IF NOT EXISTS `node` ("
-		"`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
-		"`name` TEXT NOT NULL);"
+	int dbs = sqlite3_exec(dbh,
+		"CREATE TABLE IF NOT EXISTS `actor` ("
+			"`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
+			"`name` TEXT NOT NULL);"
+			"CREATE TABLE IF NOT EXISTS `node` ("
+			"`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
+			"`name` TEXT NOT NULL);"
 		"CREATE TABLE IF NOT EXISTS `action` ("
-		"`id` INTEGER PRIMARY KEY AUTOINCREMENT,"
-		"`actor` INTEGER NOT NULL,"
-		"`timestamp` INTEGER NOT NULL,"
-		"`type` INTEGER NOT NULL,"
-		"`list` TEXT,"
-		"`index` INTEGER,"
-		"`add` INTEGER,"
-		"`stackNode` INTEGER,"
-		"`stackQuantity` INTEGER,"
-		"`nodeMeta` INTEGER,"
-		"`x` INT,"
-		"`y` INT,"
-		"`z` INT,"
-		"`oldNode` INTEGER,"
-		"`oldParam1` INTEGER,"
-		"`oldParam2` INTEGER,"
-		"`oldMeta` TEXT,"
-		"`newNode` INTEGER,"
-		"`newParam1` INTEGER,"
-		"`newParam2` INTEGER,"
-		"`newMeta` TEXT,"
-		"`guessedActor` INTEGER,"
-		"FOREIGN KEY (`actor`)   REFERENCES `actor`(`id`),"
-		"FOREIGN KEY (`oldNode`) REFERENCES `node`(`id`),"
-		"FOREIGN KEY (`newNode`) REFERENCES `node`(`id`));"
+			"`id` INTEGER PRIMARY KEY AUTOINCREMENT,"
+			"`actor` INTEGER NOT NULL,"
+			"`timestamp` TIMESTAMP NOT NULL,"
+			"`type` INTEGER NOT NULL,"
+			"`list` TEXT,"
+			"`index` INTEGER,"
+			"`add` INTEGER,"
+			"`stackNode` INTEGER,"
+			"`stackQuantity` INTEGER,"
+			"`nodeMeta` INTEGER,"
+			"`x` INT,"
+			"`y` INT,"
+			"`z` INT,"
+			"`oldNode` INTEGER,"
+			"`oldParam1` INTEGER,"
+			"`oldParam2` INTEGER,"
+			"`oldMeta` TEXT,"
+			"`newNode` INTEGER,"
+			"`newParam1` INTEGER,"
+			"`newParam2` INTEGER,"
+			"`newMeta` TEXT,"
+			"`guessedActor` INTEGER,"
+			"FOREIGN KEY (`actor`)   REFERENCES `actor`(`id`),"
+			"FOREIGN KEY (`oldNode`) REFERENCES `node`(`id`),"
+			"FOREIGN KEY (`newNode`) REFERENCES `node`(`id`));"
 		"CREATE INDEX IF NOT EXISTS `actionActor` ON `action`(`actor`);"
-		"CREATE INDEX IF NOT EXISTS `actionTimestamp` ON `action`(`timestamp`);"
-	,	NULL, NULL, NULL
-	);
-	if (dbs == SQLITE_ABORT)
+		"CREATE INDEX IF NOT EXISTS `actionTimestamp` ON `action`(`timestamp`);",
+		NULL, NULL, NULL);
+	if (dbs == SQLITE_ABORT) {
 		throw FileNotGoodException("Could not create sqlite3 database structure");
-	else
-	if (dbs != 0)
+	} else if (dbs != 0) {
 		throw FileNotGoodException("SQL Rollback: Exec statement to create table structure returned a non-zero value");
-	else
+	} else {
 		infostream << "SQL Rollback: SQLite3 database structure was created" << std::endl;
+	}
 
 	return true;
 }
-void SQL_databaseCheck (void)
+void SQL_databaseCheck(void)
 {
-	if (dbh) return;
+	if (dbh) {
+		return;
+	}
 
 	infostream << "Database connection setup" << std::endl;
 
 	bool needsCreate = !fs::PathExists(dbp);
-	int  dbo = sqlite3_open_v2(dbp.c_str(), &dbh, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
+	int  dbo = sqlite3_open_v2(dbp.c_str(), &dbh, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
+	                           NULL);
 
-	if (dbo != SQLITE_OK)
-	{
-		infostream
-		<<	"SQLROLLBACK: SQLite3 database failed to open: "
-		<<	sqlite3_errmsg(dbh)
-		<<	std::endl;
+	if (dbo != SQLITE_OK) {
+		infostream << "SQLROLLBACK: SQLite3 database failed to open: "
+		           << sqlite3_errmsg(dbh) << std::endl;
 		throw FileNotGoodException("Cannot open database file");
 	}
 
-	if (needsCreate) SQL_createDatabase();
+	if (needsCreate) {
+		SQL_createDatabase();
+	}
 
 	int dbr;
 
-	dbr = sqlite3_prepare_v2(
-		dbh
-	,	"INSERT INTO `action`"
-		"	(	`actor`, `timestamp`, `type`,"
-		"		`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodeMeta`,"
-		"		`x`, `y`, `z`,"
-		"		`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,"
-		"		`newNode`, `newParam1`, `newParam2`, `newMeta`,"
-		"		`guessedActor`"
-		"	)"
-		"VALUES"
-		"	(	?, ?, ?,"
-		"		?, ?, ?, ?, ?, ?,"
-		"	 	?, ?, ?,"
-		"	 	?, ?, ?, ?,"
-		"	 	?, ?, ?, ?,"
-		"	 	?"
-		"	);"
-	,	-1, &dbs_insert, NULL
-	);
-
-	if (dbr != SQLITE_OK)
+	dbr = sqlite3_prepare_v2(dbh,
+		"INSERT INTO `action` ("
+		"	`actor`, `timestamp`, `type`,"
+		"	`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodeMeta`,"
+		"	`x`, `y`, `z`,"
+		"	`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,"
+		"	`newNode`, `newParam1`, `newParam2`, `newMeta`,"
+		"	`guessedActor`"
+		") VALUES ("
+		"	?, ?, ?,"
+		"	?, ?, ?, ?, ?, ?,"
+		"	?, ?, ?,"
+		"	?, ?, ?, ?,"
+		"	?, ?, ?, ?,"
+		"	?"
+		");",
+		-1, &dbs_insert, NULL);
+
+	if (dbr != SQLITE_OK) {
 		throw FileNotGoodException(sqlite3_errmsg(dbh));
+	}
 
-	dbr = sqlite3_prepare_v2(
-		dbh
-	,	"REPLACE INTO `action`"
-		"	(	`actor`, `timestamp`, `type`,"
-		"		`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodeMeta`,"
-		"		`x`, `y`, `z`,"
-		"		`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,"
-		"		`newNode`, `newParam1`, `newParam2`, `newMeta`,"
-		"		`guessedActor`, `id`"
-		"	)"
-		"VALUES"
-		"	(	?, ?, ?,"
-		"		?, ?, ?, ?, ?, ?,"
-		"	 	?, ?, ?,"
-		"	 	?, ?, ?, ?,"
-		"	 	?, ?, ?, ?,"
-		"	 	?, ?"
-		"	);"
-	,	-1, &dbs_replace, NULL
-	);
-
-	if (dbr != SQLITE_OK)
+	dbr = sqlite3_prepare_v2(dbh,
+		"REPLACE INTO `action` ("
+		"	`actor`, `timestamp`, `type`,"
+		"	`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodeMeta`,"
+		"	`x`, `y`, `z`,"
+		"	`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,"
+		"	`newNode`, `newParam1`, `newParam2`, `newMeta`,"
+		"	`guessedActor`, `id`"
+		") VALUES ("
+		"	?, ?, ?,"
+		"	?, ?, ?, ?, ?, ?,"
+		"	?, ?, ?,"
+		"	?, ?, ?, ?,"
+		"	?, ?, ?, ?,"
+		"	?, ?"
+		");",
+		-1, &dbs_replace, NULL);
+
+	if (dbr != SQLITE_OK) {
 		throw FileNotGoodException(sqlite3_errmsg(dbh));
+	}
 
-	dbr = sqlite3_prepare_v2(dbh
-	,	"SELECT "
-		"		`actor`, `timestamp`, `type`"
-		"	,	`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`"
-		"	,	`x`, `y`, `z`"
-		"	,	`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`"
-		"	,	`newNode`, `newParam1`, `newParam2`, `newMeta`"
-		"	,	`guessedActor`"
+	dbr = sqlite3_prepare_v2(dbh,
+		"SELECT"
+		"	`actor`, `timestamp`, `type`,"
+		"	`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`,"
+		"	`x`, `y`, `z`,"
+		"	`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,"
+		"	`newNode`, `newParam1`, `newParam2`, `newMeta`,"
+		"	`guessedActor`"
 		" FROM	`action`"
 		" WHERE	`timestamp` >= ?"
-		" ORDER BY `timestamp` DESC, `id` DESC"
-	,	-1, &dbs_select, NULL
-	);
-	if (dbr != SQLITE_OK)
+		" ORDER BY `timestamp` DESC, `id` DESC",
+		-1, &dbs_select, NULL);
+	if (dbr != SQLITE_OK) {
 		throw FileNotGoodException(itos(dbr).c_str());
+	}
 
-	dbr = sqlite3_prepare_v2(dbh
-	,	"SELECT "
-		"		`actor`, `timestamp`, `type`"
-		"	,	`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`"
-		"	,	`x`, `y`, `z`"
-		"	,	`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`"
-		"	,	`newNode`, `newParam1`, `newParam2`, `newMeta`"
-		"	,	`guessedActor`"
+	dbr = sqlite3_prepare_v2(dbh,
+		"SELECT"
+		"	`actor`, `timestamp`, `type`,"
+		"	`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`,"
+		"	`x`, `y`, `z`,"
+		"	`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,"
+		"	`newNode`, `newParam1`, `newParam2`, `newMeta`,"
+		"	`guessedActor`"
 		" FROM	`action`"
 		" WHERE	`timestamp` >= ?"
 		" AND   `x` IS NOT NULL"
 		" AND   `y` IS NOT NULL"
 		" AND   `z` IS NOT NULL"
-		" AND   (ABS(`x`) - ABS(?)) <= ?"
-		" AND   (ABS(`y`) - ABS(?)) <= ?"
-		" AND   (ABS(`z`) - ABS(?)) <= ?"
+		" AND   ABS(`x` - ?) <= ?"
+		" AND   ABS(`y` - ?) <= ?"
+		" AND   ABS(`z` - ?) <= ?"
 		" ORDER BY `timestamp` DESC, `id` DESC"
-		" LIMIT 0,5"
-	,	-1, &dbs_select_range, NULL
-	);
-	if (dbr != SQLITE_OK)
+		" LIMIT 0,?",
+		-1, &dbs_select_range, NULL);
+	if (dbr != SQLITE_OK) {
 		throw FileNotGoodException(itos(dbr).c_str());
+	}
 
-	dbr = sqlite3_prepare_v2(dbh
-	,	"SELECT "
-		"		`actor`, `timestamp`, `type`"
-		"	,	`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`"
-		"	,	`x`, `y`, `z`"
-		"	,	`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`"
-		"	,	`newNode`, `newParam1`, `newParam2`, `newMeta`"
-		"	,	`guessedActor`"
+	dbr = sqlite3_prepare_v2(dbh,
+		"SELECT"
+		"	`actor`, `timestamp`, `type`,"
+		"	`list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`,"
+		"	`x`, `y`, `z`,"
+		"	`oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,"
+		"	`newNode`, `newParam1`, `newParam2`, `newMeta`,"
+		"	`guessedActor`"
 		" FROM	`action`"
 		" WHERE	`timestamp` >= ?"
 		" AND   `actor` = ?"
-		" ORDER BY `timestamp` DESC, `id` DESC"
-	,	-1, &dbs_select_withActor, NULL
-	);
-	if (dbr != SQLITE_OK)
+		" ORDER BY `timestamp` DESC, `id` DESC",
+		-1, &dbs_select_withActor, NULL);
+	if (dbr != SQLITE_OK) {
 		throw FileNotGoodException(itos(dbr).c_str());
+	}
 
-	dbr = sqlite3_prepare_v2(dbh, "SELECT `id`, `name` FROM `actor`", -1, &dbs_knownActor_select, NULL);
-	if (dbr != SQLITE_OK)
+	dbr = sqlite3_prepare_v2(dbh, "SELECT `id`, `name` FROM `actor`", -1,
+	                         &dbs_knownActor_select, NULL);
+	if (dbr != SQLITE_OK) {
 		throw FileNotGoodException(itos(dbr).c_str());
+	}
 
-	dbr = sqlite3_prepare_v2(dbh, "INSERT INTO `actor` (`name`) VALUES (?)", -1, &dbs_knownActor_insert, NULL);
-	if (dbr != SQLITE_OK)
+	dbr = sqlite3_prepare_v2(dbh, "INSERT INTO `actor` (`name`) VALUES (?)", -1,
+	                         &dbs_knownActor_insert, NULL);
+	if (dbr != SQLITE_OK) {
 		throw FileNotGoodException(itos(dbr).c_str());
+	}
 
-	dbr = sqlite3_prepare_v2(dbh, "SELECT `id`, `name` FROM `node`", -1, &dbs_knownNode_select, NULL);
-	if (dbr != SQLITE_OK)
+	dbr = sqlite3_prepare_v2(dbh, "SELECT `id`, `name` FROM `node`", -1,
+	                         &dbs_knownNode_select, NULL);
+	if (dbr != SQLITE_OK) {
 		throw FileNotGoodException(itos(dbr).c_str());
+	}
 
-	dbr = sqlite3_prepare_v2(dbh, "INSERT INTO `node` (`name`) VALUES (?)", -1, &dbs_knownNode_insert, NULL);
-	if (dbr != SQLITE_OK)
+	dbr = sqlite3_prepare_v2(dbh, "INSERT INTO `node` (`name`) VALUES (?)", -1,
+	                         &dbs_knownNode_insert, NULL);
+	if (dbr != SQLITE_OK) {
 		throw FileNotGoodException(itos(dbr).c_str());
+	}
 
 	infostream << "SQL prepared statements setup correctly" << std::endl;
 
@@ -388,54 +403,52 @@ void SQL_databaseCheck (void)
 	sqlite3_reset(dbs_knownActor_select);
 	while (SQLITE_ROW == (select = sqlite3_step(dbs_knownActor_select)))
 		registerNewActor(
-				sqlite3_column_int  (dbs_knownActor_select, 0),
-				reinterpret_cast<const char *>(sqlite3_column_text (dbs_knownActor_select, 1))
+		        sqlite3_column_int(dbs_knownActor_select, 0),
+		        reinterpret_cast<const char *>(sqlite3_column_text(dbs_knownActor_select, 1))
 		);
 
 	sqlite3_reset(dbs_knownNode_select);
 	while (SQLITE_ROW == (select = sqlite3_step(dbs_knownNode_select)))
 		registerNewNode(
-				sqlite3_column_int  (dbs_knownNode_select, 0),
-				reinterpret_cast<const char *>(sqlite3_column_text (dbs_knownNode_select, 1))
+		        sqlite3_column_int(dbs_knownNode_select, 0),
+		        reinterpret_cast<const char *>(sqlite3_column_text(dbs_knownNode_select, 1))
 		);
 
 	return;
 }
-bool SQL_registerRow (ActionRow row)
+bool SQL_registerRow(ActionRow row)
 {
 	SQL_databaseCheck();
 
-	sqlite3_stmt * dbs_do = (row.id)? dbs_replace: dbs_insert;
+	sqlite3_stmt * dbs_do = (row.id) ? dbs_replace : dbs_insert;
 
 	/*
 	std::cout
-		<< (row.id? "Replacing": "Inserting") 
+		<< (row.id? "Replacing": "Inserting")
 		<< " ActionRow" << std::endl;
 	*/
 	sqlite3_reset(dbs_do);
 
-	int bind [20 + (((bool) row.id)? 1: 0)], ii = 0;
+	int bind [20 + (((bool) row.id) ? 1 : 0)], ii = 0;
 	bool nodeMeta = false;
 
-	bind[ii++] = sqlite3_bind_int (dbs_do, 1, row.actor);
-	bind[ii++] = sqlite3_bind_int (dbs_do, 2, row.timestamp);
-	bind[ii++] = sqlite3_bind_int (dbs_do, 3, row.type);
+	bind[ii++] = sqlite3_bind_int(dbs_do, 1, row.actor);
+	bind[ii++] = sqlite3_bind_int64(dbs_do, 2, row.timestamp);
+	bind[ii++] = sqlite3_bind_int(dbs_do, 3, row.type);
 
-	if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
-	{
+	if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK) {
 		std::string loc		= row.location;
 		std::string locType	= loc.substr(0, loc.find(":"));
 		nodeMeta = (locType == "nodemeta");
 
-		bind[ii++] = sqlite3_bind_text (dbs_do, 4, row.list.c_str(), row.list.size(), NULL);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 5, row.index);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 6, row.add);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 7, row.stack.node);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 8, row.stack.quantity);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 9, (int) nodeMeta);
+		bind[ii++] = sqlite3_bind_text(dbs_do, 4, row.list.c_str(), row.list.size(), NULL);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 5, row.index);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 6, row.add);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 7, row.stack.node);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 8, row.stack.quantity);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 9, (int) nodeMeta);
 
-		if (nodeMeta)
-		{
+		if (nodeMeta) {
 			std::string x, y, z;
 			int	l, r;
 			l = loc.find(':') + 1;
@@ -444,64 +457,59 @@ bool SQL_registerRow (ActionRow row)
 			l = r + 1;
 			r = loc.find(',', l);
 			y = loc.substr(l, r - l);
-			z = loc.substr(r +1);
-			bind[ii++] = sqlite3_bind_int (dbs_do, 10, atoi(x.c_str()));
-			bind[ii++] = sqlite3_bind_int (dbs_do, 11, atoi(y.c_str()));
-			bind[ii++] = sqlite3_bind_int (dbs_do, 12, atoi(z.c_str()));
+			z = loc.substr(r + 1);
+			bind[ii++] = sqlite3_bind_int(dbs_do, 10, atoi(x.c_str()));
+			bind[ii++] = sqlite3_bind_int(dbs_do, 11, atoi(y.c_str()));
+			bind[ii++] = sqlite3_bind_int(dbs_do, 12, atoi(z.c_str()));
 		}
-	}
-		else
-	{
-		bind[ii++] = sqlite3_bind_null (dbs_do, 4);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 5);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 6);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 7);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 8);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 9);
+	} else {
+		bind[ii++] = sqlite3_bind_null(dbs_do, 4);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 5);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 6);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 7);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 8);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 9);
 	}
 
-	if (row.type == RollbackAction::TYPE_SET_NODE)
-	{
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 10, row.x);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 11, row.y);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 12, row.z);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 13, row.oldNode);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 14, row.oldParam1);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 15, row.oldParam2);
-		bind[ii++] = sqlite3_bind_text (dbs_do, 16, row.oldMeta.c_str(), row.oldMeta.size(), NULL);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 17, row.newNode);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 18, row.newParam1);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 19, row.newParam2);
-		bind[ii++] = sqlite3_bind_text (dbs_do, 20, row.newMeta.c_str(), row.newMeta.size(), NULL);
-		bind[ii++] = sqlite3_bind_int  (dbs_do, 21, row.guessed? 1: 0);
-	}
-		else
-	{
-		if (!nodeMeta)
-		{
-			bind[ii++] = sqlite3_bind_null (dbs_do, 10);
-			bind[ii++] = sqlite3_bind_null (dbs_do, 11);
-			bind[ii++] = sqlite3_bind_null (dbs_do, 12);
+	if (row.type == RollbackAction::TYPE_SET_NODE) {
+		bind[ii++] = sqlite3_bind_int(dbs_do, 10, row.x);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 11, row.y);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 12, row.z);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 13, row.oldNode);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 14, row.oldParam1);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 15, row.oldParam2);
+		bind[ii++] = sqlite3_bind_text(dbs_do, 16, row.oldMeta.c_str(), row.oldMeta.size(), NULL);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 17, row.newNode);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 18, row.newParam1);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 19, row.newParam2);
+		bind[ii++] = sqlite3_bind_text(dbs_do, 20, row.newMeta.c_str(), row.newMeta.size(), NULL);
+		bind[ii++] = sqlite3_bind_int(dbs_do, 21, row.guessed ? 1 : 0);
+	} else {
+		if (!nodeMeta) {
+			bind[ii++] = sqlite3_bind_null(dbs_do, 10);
+			bind[ii++] = sqlite3_bind_null(dbs_do, 11);
+			bind[ii++] = sqlite3_bind_null(dbs_do, 12);
 		}
-		bind[ii++] = sqlite3_bind_null (dbs_do, 13);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 14);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 15);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 16);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 17);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 18);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 19);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 20);
-		bind[ii++] = sqlite3_bind_null (dbs_do, 21);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 13);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 14);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 15);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 16);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 17);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 18);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 19);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 20);
+		bind[ii++] = sqlite3_bind_null(dbs_do, 21);
 	}
 
-	if (row.id)
-		bind[ii++] = sqlite3_bind_int (dbs_do, 22, row.id);
+	if (row.id) {
+		bind[ii++] = sqlite3_bind_int(dbs_do, 22, row.id);
+	}
 
 	for (ii = 0; ii < 20; ++ii)
-	if  (bind[ii] != SQLITE_OK)
-		infostream
-			<< "WARNING: failed to bind param " << ii + 1
-			<< " when inserting an entry in table setnode" << std::endl;
+		if (bind[ii] != SQLITE_OK)
+			infostream
+			                << "WARNING: failed to bind param " << ii + 1
+			                << " when inserting an entry in table setnode" << std::endl;
 
 	/*
 	std::cout << "========DB-WRITTEN==========" << std::endl;
@@ -543,60 +551,55 @@ bool SQL_registerRow (ActionRow row)
 	//	 std::cout << "WARNING: rollback action not written: " << sqlite3_errmsg(dbh) << std::endl;
 	//else std::cout << "Action correctly inserted via SQL" << std::endl;
 }
-std::list<ActionRow> actionRowsFromSelect (sqlite3_stmt* stmt)
+std::list<ActionRow> actionRowsFromSelect(sqlite3_stmt* stmt)
 {
 	std::list<ActionRow> rows;
 	const unsigned char * text;
 	size_t size;
 
-	while (SQLITE_ROW == sqlite3_step(stmt))
-	{
+	while (SQLITE_ROW == sqlite3_step(stmt)) {
 		ActionRow row;
 
-		row.actor		= sqlite3_column_int (stmt, 0);
-		row.timestamp	= sqlite3_column_int (stmt, 1); 
-		row.type		= sqlite3_column_int (stmt, 2);
-
-		if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
-		{
-			text				= sqlite3_column_text (stmt, 3);
-			size				= sqlite3_column_bytes(stmt, 3);
-			row.list			= std::string(reinterpret_cast<const char*>(text), size);
-			row.index			= sqlite3_column_int  (stmt, 4);
-			row.add				= sqlite3_column_int  (stmt, 5);
-			row.stack.node		= sqlite3_column_int  (stmt, 6);
-			row.stack.quantity	= sqlite3_column_int  (stmt, 7);
-			row.nodeMeta		= sqlite3_column_int  (stmt, 8);
+		row.actor     = sqlite3_column_int(stmt, 0);
+		row.timestamp = sqlite3_column_int64(stmt, 1);
+		row.type      = sqlite3_column_int(stmt, 2);
+
+		if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK) {
+			text               = sqlite3_column_text(stmt, 3);
+			size               = sqlite3_column_bytes(stmt, 3);
+			row.list           = std::string(reinterpret_cast<const char*>(text), size);
+			row.index          = sqlite3_column_int(stmt, 4);
+			row.add            = sqlite3_column_int(stmt, 5);
+			row.stack.node     = sqlite3_column_int(stmt, 6);
+			row.stack.quantity = sqlite3_column_int(stmt, 7);
+			row.nodeMeta       = sqlite3_column_int(stmt, 8);
 		}
 
-		if (row.type == RollbackAction::TYPE_SET_NODE || row.nodeMeta)
-		{
-			row.x = sqlite3_column_int (stmt,  9);
-			row.y = sqlite3_column_int (stmt, 10);
-			row.z = sqlite3_column_int (stmt, 11);
+		if (row.type == RollbackAction::TYPE_SET_NODE || row.nodeMeta) {
+			row.x = sqlite3_column_int(stmt,  9);
+			row.y = sqlite3_column_int(stmt, 10);
+			row.z = sqlite3_column_int(stmt, 11);
 		}
-		
-		if (row.type == RollbackAction::TYPE_SET_NODE)
-		{
-			row.oldNode		= sqlite3_column_int  (stmt, 12);
-			row.oldParam1	= sqlite3_column_int  (stmt, 13);
-			row.oldParam2	= sqlite3_column_int  (stmt, 14);
-			text			= sqlite3_column_text (stmt, 15);
-			size			= sqlite3_column_bytes(stmt, 15);
-			row.oldMeta		= std::string(reinterpret_cast<const char*>(text), size);
-			row.newNode		= sqlite3_column_int  (stmt, 16);
-			row.newParam1	= sqlite3_column_int  (stmt, 17);
-			row.newParam2	= sqlite3_column_int  (stmt, 18);
-			text			= sqlite3_column_text (stmt, 19);
-			size			= sqlite3_column_bytes(stmt, 19);
-			row.newMeta		= std::string(reinterpret_cast<const char*>(text), size);
-			row.guessed		= sqlite3_column_int  (stmt, 20);
+
+		if (row.type == RollbackAction::TYPE_SET_NODE) {
+			row.oldNode		= sqlite3_column_int(stmt, 12);
+			row.oldParam1 = sqlite3_column_int(stmt, 13);
+			row.oldParam2 = sqlite3_column_int(stmt, 14);
+			text          = sqlite3_column_text(stmt, 15);
+			size          = sqlite3_column_bytes(stmt, 15);
+			row.oldMeta   = std::string(reinterpret_cast<const char*>(text), size);
+			row.newNode   = sqlite3_column_int(stmt, 16);
+			row.newParam1 = sqlite3_column_int(stmt, 17);
+			row.newParam2 = sqlite3_column_int(stmt, 18);
+			text          = sqlite3_column_text(stmt, 19);
+			size          = sqlite3_column_bytes(stmt, 19);
+			row.newMeta   = std::string(reinterpret_cast<const char*>(text), size);
+			row.guessed   = sqlite3_column_int(stmt, 20);
 		}
 
-		row.location = row.nodeMeta? "nodemeta:": getActorName(row.actor);
+		row.location = row.nodeMeta ? "nodemeta:" : getActorName(row.actor);
 
-		if (row.nodeMeta)
-		{
+		if (row.nodeMeta) {
 			row.location.append(itos(row.x));
 			row.location.append(",");
 			row.location.append(itos(row.y));
@@ -646,25 +649,22 @@ std::list<ActionRow> actionRowsFromSelect (sqlite3_stmt* stmt)
 
 	return rows;
 }
-ActionRow actionRowFromRollbackAction (RollbackAction action)
+ActionRow actionRowFromRollbackAction(RollbackAction action)
 {
 	ActionRow row;
 
-	row.id			= 0;
-	row.actor		= getActorId(action.actor);
-	row.timestamp	= action.unix_time;
-	row.type		= action.type;
+	row.id        = 0;
+	row.actor     = getActorId(action.actor);
+	row.timestamp = action.unix_time;
+	row.type      = action.type;
 
-	if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
-	{
+	if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK) {
 		row.location = action.inventory_location;
 		row.list     = action.inventory_list;
 		row.index    = action.inventory_index;
 		row.add      = action.inventory_add;
 		row.stack    = getStackFromString(action.inventory_stack);
-	}
-		else
-	{
+	} else {
 		row.x         = action.p.X;
 		row.y         = action.p.Y;
 		row.z         = action.p.Z;
@@ -681,46 +681,44 @@ ActionRow actionRowFromRollbackAction (RollbackAction action)
 
 	return row;
 }
-std::list<RollbackAction> rollbackActionsFromActionRows (std::list<ActionRow> rows)
+std::list<RollbackAction> rollbackActionsFromActionRows(std::list<ActionRow> rows)
 {
 	std::list<RollbackAction> actions;
 	std::list<ActionRow>::const_iterator it;
 
-	for (it = rows.begin(); it != rows.end(); ++it)
-	{
+	for (it = rows.begin(); it != rows.end(); ++it) {
 		RollbackAction action;
-		action.actor		= (it->actor)? getActorName(it->actor): "";
-		action.unix_time	= it->timestamp;
-		action.type			= static_cast<RollbackAction::Type>(it->type);
-
-        switch (action.type)
-		{
-			case RollbackAction::TYPE_MODIFY_INVENTORY_STACK:
-
-				action.inventory_location   = it->location.c_str();
-				action.inventory_list       = it->list;
-				action.inventory_index      = it->index;
-				action.inventory_add        = it->add;
-				action.inventory_stack      = getStringFromStack(it->stack);
-				break;
-				
-			case RollbackAction::TYPE_SET_NODE:
-
-				action.p			= v3s16(it->x, it->y, it->z);
-				action.n_old.name	= getNodeName(it->oldNode);
-				action.n_old.param1 = it->oldParam1;
-				action.n_old.param2 = it->oldParam2;
-				action.n_old.meta	= it->oldMeta;
-				action.n_new.name	= getNodeName(it->newNode);
-				action.n_new.param1 = it->newParam1;
-				action.n_new.param2 = it->newParam2;
-				action.n_new.meta	= it->newMeta;
-				break;
-
-			default:
-
-				throw("W.T.F.");
-				break;
+		action.actor     = (it->actor) ? getActorName(it->actor) : "";
+		action.unix_time = it->timestamp;
+		action.type      = static_cast<RollbackAction::Type>(it->type);
+
+		switch (action.type) {
+		case RollbackAction::TYPE_MODIFY_INVENTORY_STACK:
+
+			action.inventory_location = it->location.c_str();
+			action.inventory_list     = it->list;
+			action.inventory_index    = it->index;
+			action.inventory_add      = it->add;
+			action.inventory_stack    = getStringFromStack(it->stack);
+			break;
+
+		case RollbackAction::TYPE_SET_NODE:
+
+			action.p            = v3s16(it->x, it->y, it->z);
+			action.n_old.name   = getNodeName(it->oldNode);
+			action.n_old.param1 = it->oldParam1;
+			action.n_old.param2 = it->oldParam2;
+			action.n_old.meta   = it->oldMeta;
+			action.n_new.name   = getNodeName(it->newNode);
+			action.n_new.param1 = it->newParam1;
+			action.n_new.param2 = it->newParam2;
+			action.n_new.meta   = it->newMeta;
+			break;
+
+		default:
+
+			throw ("W.T.F.");
+			break;
 		}
 
 		actions.push_back(action);
@@ -728,69 +726,83 @@ std::list<RollbackAction> rollbackActionsFromActionRows (std::list<ActionRow> ro
 
 	return actions;
 }
-std::list<ActionRow> SQL_getRowsSince (int firstTime, std::string actor = "")
+
+std::list<ActionRow> SQL_getRowsSince(time_t firstTime, std::string actor = "")
 {
-	sqlite3_stmt * dbs_stmt = (!actor.length())? dbs_select: dbs_select_withActor;
-	sqlite3_reset     (dbs_stmt);
-	sqlite3_bind_int  (dbs_stmt, 1, firstTime);
+	sqlite3_stmt *dbs_stmt = (!actor.length()) ? dbs_select : dbs_select_withActor;
+	sqlite3_reset(dbs_stmt);
+	sqlite3_bind_int64(dbs_stmt, 1, firstTime);
 
-	if (actor.length())
-		sqlite3_bind_int (dbs_stmt, 2, getActorId(actor));
+	if (actor.length()) {
+		sqlite3_bind_int(dbs_stmt, 2, getActorId(actor));
+	}
 
 	return actionRowsFromSelect(dbs_stmt);
 }
-std::list<ActionRow> SQL_getRowsSince_range (int firstTime, v3s16 p, int range)
+
+std::list<ActionRow> SQL_getRowsSince_range(time_t firstTime, v3s16 p, int range,
+                int limit)
 {
-	sqlite3_stmt * stmt = dbs_select_range;
+	sqlite3_stmt *stmt = dbs_select_range;
 	sqlite3_reset(stmt);
 
-	sqlite3_bind_int(stmt, 1, firstTime);
+	sqlite3_bind_int64(stmt, 1, firstTime);
 	sqlite3_bind_int(stmt, 2, (int) p.X);
 	sqlite3_bind_int(stmt, 3, range);
 	sqlite3_bind_int(stmt, 4, (int) p.Y);
 	sqlite3_bind_int(stmt, 5, range);
 	sqlite3_bind_int(stmt, 6, (int) p.Z);
 	sqlite3_bind_int(stmt, 7, range);
+	sqlite3_bind_int(stmt, 8, limit);
 
 	return actionRowsFromSelect(stmt);
 }
-std::list<RollbackAction> SQL_getActionsSince_range (int firstTime, v3s16 p, int range)
+
+std::list<RollbackAction> SQL_getActionsSince_range(time_t firstTime, v3s16 p, int range,
+                int limit)
 {
-	std::list<ActionRow> rows = SQL_getRowsSince_range(firstTime, p, range);
+	std::list<ActionRow> rows = SQL_getRowsSince_range(firstTime, p, range, limit);
 
 	return rollbackActionsFromActionRows(rows);
 }
-std::list<RollbackAction> SQL_getActionsSince (int firstTime, std::string actor = "")
+
+std::list<RollbackAction> SQL_getActionsSince(time_t firstTime, std::string actor = "")
 {
 	std::list<ActionRow> rows = SQL_getRowsSince(firstTime, actor);
 	return rollbackActionsFromActionRows(rows);
 }
-void TXT_migrate (std::string filepath)
+
+void TXT_migrate(std::string filepath)
 {
 	std::cout << "Migrating from rollback.txt to rollback.sqlite" << std::endl;
 	SQL_databaseCheck();
 
-	std::ifstream fh (filepath.c_str(), std::ios::in | std::ios::ate);
-	if (!fh.good()) throw("DIE");
+	std::ifstream fh(filepath.c_str(), std::ios::in | std::ios::ate);
+	if (!fh.good()) {
+		throw ("DIE");
+	}
 
-	int filesize = fh.tellg();
+	std::streampos filesize = fh.tellg();
 
-	if (filesize > 10)
-	{
+	if (filesize > 10) {
 		fh.seekg(0);
 
 		std::string bit;
 		int i   = 0;
 		int id  = 1;
-		int t   = 0;
-		do
-		{
+		time_t t   = 0;
+		do {
 			ActionRow row;
 
 			row.id = id;
 
 			// Get the timestamp
-			std::getline(fh, bit, ' '); bit = trim(bit); if (!atoi(trim(bit).c_str())) { std::getline(fh, bit); continue; }
+			std::getline(fh, bit, ' ');
+			bit = trim(bit);
+			if (!atoi(trim(bit).c_str())) {
+				std::getline(fh, bit);
+				continue;
+			}
 			row.timestamp = atoi(bit.c_str());
 
 			// Get the actor
@@ -800,44 +812,53 @@ void TXT_migrate (std::string filepath)
 			std::getline(fh, bit, '[');
 			std::getline(fh, bit, ' ');
 
-			if (bit == "modify_inventory_stack")
+			if (bit == "modify_inventory_stack") {
 				row.type = RollbackAction::TYPE_MODIFY_INVENTORY_STACK;
+			}
 
-			if (bit == "set_node")
+			if (bit == "set_node") {
 				row.type = RollbackAction::TYPE_SET_NODE;
+			}
 
-			if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
-			{
-											row.location = trim(deSerializeJsonString(fh));
-				std::getline(fh, bit, ' ');	row.list     = trim(deSerializeJsonString(fh));
+			if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK) {
+				row.location = trim(deSerializeJsonString(fh));
+				std::getline(fh, bit, ' ');
+				row.list     = trim(deSerializeJsonString(fh));
 				std::getline(fh, bit, ' ');
 				std::getline(fh, bit, ' ');
-											row.index    = atoi(trim(bit).c_str());
-				std::getline(fh, bit, ' '); row.add      = (int) ( trim(bit) == "add" );
-											row.stack    = getStackFromString(trim(deSerializeJsonString(fh)));
+				row.index    = atoi(trim(bit).c_str());
+				std::getline(fh, bit, ' ');
+				row.add      = (int)(trim(bit) == "add");
+				row.stack    = getStackFromString(trim(deSerializeJsonString(fh)));
 				std::getline(fh, bit);
-				
-			}
-			else
-				if (row.type == RollbackAction::TYPE_SET_NODE)
-			{
+			} else if (row.type == RollbackAction::TYPE_SET_NODE) {
 				std::getline(fh, bit, '(');
-				std::getline(fh, bit, ','); row.x       = atoi(trim(bit).c_str());
-				std::getline(fh, bit, ','); row.y       = atoi(trim(bit).c_str());
-				std::getline(fh, bit, ')'); row.z       = atoi(trim(bit).c_str());
-				std::getline(fh, bit, ' ');	row.oldNode = getNodeId(trim(deSerializeJsonString(fh)));
+				std::getline(fh, bit, ',');
+				row.x       = atoi(trim(bit).c_str());
+				std::getline(fh, bit, ',');
+				row.y       = atoi(trim(bit).c_str());
+				std::getline(fh, bit, ')');
+				row.z       = atoi(trim(bit).c_str());
+				std::getline(fh, bit, ' ');
+				row.oldNode = getNodeId(trim(deSerializeJsonString(fh)));
+				std::getline(fh, bit, ' ');
+				std::getline(fh, bit, ' ');
+				row.oldParam1 = atoi(trim(bit).c_str());
 				std::getline(fh, bit, ' ');
-				std::getline(fh, bit, ' '); row.oldParam1 = atoi(trim(bit).c_str());
-				std::getline(fh, bit, ' '); row.oldParam2 = atoi(trim(bit).c_str());
-											row.oldMeta   = trim(deSerializeJsonString(fh));
-				std::getline(fh, bit, ' ');	row.newNode   = getNodeId(trim(deSerializeJsonString(fh)));
+				row.oldParam2 = atoi(trim(bit).c_str());
+				row.oldMeta   = trim(deSerializeJsonString(fh));
 				std::getline(fh, bit, ' ');
-				std::getline(fh, bit, ' '); row.newParam1 = atoi(trim(bit).c_str());
-				std::getline(fh, bit, ' '); row.newParam2 = atoi(trim(bit).c_str());
-											row.newMeta   = trim(deSerializeJsonString(fh));
+				row.newNode   = getNodeId(trim(deSerializeJsonString(fh)));
 				std::getline(fh, bit, ' ');
 				std::getline(fh, bit, ' ');
-				std::getline(fh, bit);		row.guessed = (int) ( trim(bit) == "actor_is_guess" );
+				row.newParam1 = atoi(trim(bit).c_str());
+				std::getline(fh, bit, ' ');
+				row.newParam2 = atoi(trim(bit).c_str());
+				row.newMeta   = trim(deSerializeJsonString(fh));
+				std::getline(fh, bit, ' ');
+				std::getline(fh, bit, ' ');
+				std::getline(fh, bit);
+				row.guessed = (int)(trim(bit) == "actor_is_guess");
 			}
 
 			/*
@@ -870,43 +891,43 @@ void TXT_migrate (std::string filepath)
 			}
 			*/
 
-			if (i == 0)
-			{
+			if (i == 0) {
 				t = time(0);
 				sqlite3_exec(dbh, "BEGIN", NULL, NULL, NULL);
 			}
 
-			SQL_registerRow(row); ++i;
+			SQL_registerRow(row);
+			++i;
 
-			if (time(0) - t)
-			{
+			if (time(0) - t) {
 				sqlite3_exec(dbh, "COMMIT", NULL, NULL, NULL);
 				t = time(0) - t;
 				std::cout
-					<< "  Done: " << (int)(((float) fh.tellg() / (float) filesize) * 100) << "%"
-					<< "\tSpeed: " << i / t << " actions inserted per second   "
-					<< "\r";
-				std::cout.flush();
+				                << " Done: " << (int)(((float) fh.tellg() / (float) filesize) * 100) << "%"
+				                << " Speed: " << i / t << "/second     \r" << std::flush;
 				i = 0;
 			}
 
 			++id;
-		}
-		while (!fh.eof() && fh.good());
+		} while (!fh.eof() && fh.good());
+	} else {
+		errorstream << "Empty rollback log" << std::endl;
 	}
 
 	std::cout
-		<< "  Done: 100%" << std::endl
-		<< "  Now you can delete the old rollback.txt file." << std::endl;
+	                << " Done: 100%                                   " << std::endl
+	                << " Now you can delete the old rollback.txt file." << std::endl;
 }
+
 // Get nearness factor for subject's action for this action
 // Return value: 0 = impossible, >0 = factor
-static float getSuspectNearness(bool is_guess, v3s16 suspect_p, int suspect_t,
-		v3s16 action_p, int action_t)
+static float getSuspectNearness(bool is_guess, v3s16 suspect_p, time_t suspect_t,
+                                v3s16 action_p, time_t action_t)
 {
 	// Suspect cannot cause things in the past
-	if(action_t < suspect_t)
-		return 0; // 0 = cannot be
+	if (action_t < suspect_t) {
+		return 0;        // 0 = cannot be
+	}
 	// Start from 100
 	int f = 100;
 	// Distance (1 node = -x points)
@@ -914,22 +935,24 @@ static float getSuspectNearness(bool is_guess, v3s16 suspect_p, int suspect_t,
 	// Time (1 second = -x points)
 	f -= 1 * (action_t - suspect_t);
 	// If is a guess, halve the points
-	if(is_guess)
+	if (is_guess) {
 		f *= 0.5;
+	}
 	// Limit to 0
-	if(f < 0)
+	if (f < 0) {
 		f = 0;
+	}
 	return f;
 }
 class RollbackManager: public IRollbackManager
 {
 public:
 	// IRollbackManager interface
-	void reportAction(const RollbackAction &action_)
-	{
+	void reportAction(const RollbackAction &action_) {
 		// Ignore if not important
-		if  (!action_.isImportant(m_gamedef))
+		if (!action_.isImportant(m_gamedef)) {
 			return;
+		}
 
 		RollbackAction action = action_;
 		action.unix_time = time(0);
@@ -938,90 +961,96 @@ public:
 		action.actor = m_current_actor;
 		action.actor_is_guess = m_current_actor_is_guess;
 
-		if  (action.actor.empty()) // If actor is not known, find out suspect or cancel
-		{
+		if (action.actor.empty()) { // If actor is not known, find out suspect or cancel
 			v3s16 p;
-			if  (!action.getPosition(&p))
+			if (!action.getPosition(&p)) {
 				return;
+			}
 
 			action.actor = getSuspect(p, 83, 1);
-			if  (action.actor.empty())
+			if (action.actor.empty()) {
 				return;
+			}
 
 			action.actor_is_guess = true;
 		}
 
 		infostream
-			<<	"RollbackManager::reportAction():"
-			<<	" time=" << action.unix_time
-			<<	" actor=\"" << action.actor << "\""
-			<<	(action.actor_is_guess? " (guess)": "")
-			<<	" action=" << action.toString()
-			<<	std::endl;
+		                << "RollbackManager::reportAction():"
+		                << " time=" << action.unix_time
+		                << " actor=\"" << action.actor << "\""
+		                << (action.actor_is_guess ? " (guess)" : "")
+		                << " action=" << action.toString()
+		                << std::endl;
 		addAction(action);
 	}
-	std::string getActor()
-	{
+
+	std::string getActor() {
 		return m_current_actor;
 	}
-	bool isActorGuess()
-	{
+
+	bool isActorGuess() {
 		return m_current_actor_is_guess;
 	}
-	void setActor(const std::string &actor, bool is_guess)
-	{
+
+	void setActor(const std::string &actor, bool is_guess) {
 		m_current_actor = actor;
 		m_current_actor_is_guess = is_guess;
 	}
-	std::string getSuspect(v3s16 p, float nearness_shortcut, float min_nearness)
-	{
-		if(m_current_actor != "")
+
+	std::string getSuspect(v3s16 p, float nearness_shortcut, float min_nearness) {
+		if (m_current_actor != "") {
 			return m_current_actor;
+		}
 		int cur_time = time(0);
-		int first_time = cur_time - (100-min_nearness);
+		time_t first_time = cur_time - (100 - min_nearness);
 		RollbackAction likely_suspect;
 		float likely_suspect_nearness = 0;
-		for(std::list<RollbackAction>::const_reverse_iterator
-				i = m_action_latest_buffer.rbegin();
-				i != m_action_latest_buffer.rend(); i++)
-		{
-			if(i->unix_time < first_time)
+		for (std::list<RollbackAction>::const_reverse_iterator
+		     i = m_action_latest_buffer.rbegin();
+		     i != m_action_latest_buffer.rend(); i++) {
+			if (i->unix_time < first_time) {
 				break;
-			if(i->actor == "")
+			}
+			if (i->actor == "") {
 				continue;
+			}
 			// Find position of suspect or continue
 			v3s16 suspect_p;
-			if(!i->getPosition(&suspect_p))
+			if (!i->getPosition(&suspect_p)) {
 				continue;
+			}
 			float f = getSuspectNearness(i->actor_is_guess, suspect_p,
-					i->unix_time, p, cur_time);
-			if(f >= min_nearness && f > likely_suspect_nearness){
+			                             i->unix_time, p, cur_time);
+			if (f >= min_nearness && f > likely_suspect_nearness) {
 				likely_suspect_nearness = f;
 				likely_suspect = *i;
-				if(likely_suspect_nearness >= nearness_shortcut)
+				if (likely_suspect_nearness >= nearness_shortcut) {
 					break;
+				}
 			}
 		}
 		// No likely suspect was found
-		if(likely_suspect_nearness == 0)
+		if (likely_suspect_nearness == 0) {
 			return "";
+		}
 		// Likely suspect was found
 		return likely_suspect.actor;
 	}
-	void flush()
-	{
+
+	void flush() {
 		infostream << "RollbackManager::flush()" << std::endl;
 
 		sqlite3_exec(dbh, "BEGIN", NULL, NULL, NULL);
 
 		std::list<RollbackAction>::const_iterator iter;
 
-		for	(iter  = m_action_todisk_buffer.begin();
-			 iter != m_action_todisk_buffer.end();
-			 iter++)
-		{
-			if (iter->actor == "")
+		for (iter  = m_action_todisk_buffer.begin();
+		     iter != m_action_todisk_buffer.end();
+		     iter++) {
+			if (iter->actor == "") {
 				continue;
+			}
 
 			SQL_registerRow(actionRowFromRollbackAction(*iter));
 		}
@@ -1029,33 +1058,32 @@ public:
 		sqlite3_exec(dbh, "COMMIT", NULL, NULL, NULL);
 		m_action_todisk_buffer.clear();
 	}
+
 	RollbackManager(const std::string &filepath, IGameDef *gamedef):
 		m_filepath(filepath),
 		m_gamedef(gamedef),
-		m_current_actor_is_guess(false)
-	{
+		m_current_actor_is_guess(false) {
 		infostream
-			<< "RollbackManager::RollbackManager(" << filepath << ")"
-			<< std::endl;
-		
+		                << "RollbackManager::RollbackManager(" << filepath << ")"
+		                << std::endl;
+
 		// Operate correctly in case of still being given rollback.txt as filepath
 		std::string directory   =  filepath.substr(0, filepath.rfind(DIR_DELIM) + 1);
-		std::string filenameOld =  filepath.substr(1+ filepath.rfind(DIR_DELIM));
-		std::string filenameNew = (filenameOld == "rollback.txt")? "rollback.sqlite": filenameOld;
+		std::string filenameOld =  filepath.substr(filepath.rfind(DIR_DELIM) + 1);
+		std::string filenameNew = (filenameOld == "rollback.txt") ? "rollback.sqlite" :
+		                          filenameOld;
 		std::string filenameTXT	=  directory + "rollback.txt";
-		std::string migratingFlag = filepath;
-		migratingFlag.append(".migrating");
+		std::string migratingFlag = filepath + ".migrating";
 
 		infostream << "Directory: " << directory   << std::endl;
 		infostream << "CheckFor:  " << filenameTXT << std::endl;
 		infostream << "FileOld:   " << filenameOld << std::endl;
 		infostream << "FileNew:   " << filenameNew << std::endl;
-			
+
 		dbp = directory + filenameNew;
 
-		if ((fs::PathExists(filenameTXT) &&  fs::PathExists(migratingFlag))
-		||	(fs::PathExists(filenameTXT) && !fs::PathExists(dbp)))
-		{
+		if ((fs::PathExists(filenameTXT) && fs::PathExists(migratingFlag)) ||
+		    (fs::PathExists(filenameTXT) && !fs::PathExists(dbp))) {
 			std::ofstream of(migratingFlag.c_str());
 			TXT_migrate(filenameTXT);
 			fs::DeleteSingleFileOrEmptyDirectory(migratingFlag);
@@ -1063,74 +1091,54 @@ public:
 
 		SQL_databaseCheck();
 	}
-	~RollbackManager()
-	{
+
+	~RollbackManager() {
 		infostream << "RollbackManager::~RollbackManager()" << std::endl;
 		flush();
 	}
-	void addAction(const RollbackAction &action)
-	{
+
+	void addAction(const RollbackAction &action) {
 		m_action_todisk_buffer.push_back(action);
 		m_action_latest_buffer.push_back(action);
 
 		// Flush to disk sometimes
-		if(m_action_todisk_buffer.size() >= 500)
+		if (m_action_todisk_buffer.size() >= 500) {
 			flush();
+		}
 	}
-	std::list<RollbackAction> getEntriesSince(int first_time)
-	{
+
+	std::list<RollbackAction> getEntriesSince(time_t first_time) {
 		infostream
-			<< "RollbackManager::getEntriesSince(" << first_time << ")"
-			<< std::endl;
+		                << "RollbackManager::getEntriesSince(" << first_time << ")"
+		                << std::endl;
 
 		flush();
-		
+
 		std::list<RollbackAction> result = SQL_getActionsSince(first_time);
 
 		return result;
 	}
-	std::string getLastNodeActor(v3s16 p, int range, int seconds, v3s16 *act_p, int *act_seconds)
-	{
-		int cur_time = time(0);
-		int first_time = cur_time - seconds;
-
-		std::list<RollbackAction> action_buffer = SQL_getActionsSince_range(first_time, p, range);
-		std::list<RollbackAction>::const_reverse_iterator iter;
-
-		for (iter  = action_buffer.rbegin();
-			 iter != action_buffer.rend();
-			 iter++)
-		{
-			v3s16 action_p;
 
-			action_p.X = iter->p.X;
-			action_p.Y = iter->p.Y;
-			action_p.Z = iter->p.Z;
-			
-			if (act_p)
-				*act_p = action_p;
+	std::list<RollbackAction> getNodeActors(v3s16 pos, int range, time_t seconds, int limit) {
+		time_t cur_time = time(0);
+		time_t first_time = cur_time - seconds;
 
-			if (act_seconds)
-				*act_seconds = cur_time - iter->unix_time;
-
-			return iter->actor;
-		}
-
-		return "";
+		return SQL_getActionsSince_range(first_time, pos, range, limit);
 	}
-	std::list<RollbackAction> getRevertActions(const std::string &actor_filter, int seconds)
-	{
+
+	std::list<RollbackAction> getRevertActions(const std::string &actor_filter,
+	                time_t seconds) {
 		infostream
-			<< "RollbackManager::getRevertActions(" << actor_filter
-			<< ", " << seconds << ")"
-			<< std::endl;
+		                << "RollbackManager::getRevertActions(" << actor_filter
+		                << ", " << seconds << ")"
+		                << std::endl;
 
 		// Figure out time
-		int cur_time = time(0);
-		int first_time = cur_time - seconds;
-		
+		time_t cur_time = time(0);
+		time_t first_time = cur_time - seconds;
+
 		flush();
-		
+
 		std::list<RollbackAction> result = SQL_getActionsSince(first_time, actor_filter);
 
 		return result;
@@ -1148,3 +1156,4 @@ IRollbackManager *createRollbackManager(const std::string &filepath, IGameDef *g
 {
 	return new RollbackManager(filepath, gamedef);
 }
+
diff --git a/src/rollback.h b/src/rollback.h
index 46a76f583..eea7c59f2 100644
--- a/src/rollback.h
+++ b/src/rollback.h
@@ -36,17 +36,17 @@ public:
 	virtual bool isActorGuess() = 0;
 	virtual void setActor(const std::string &actor, bool is_guess) = 0;
 	virtual std::string getSuspect(v3s16 p, float nearness_shortcut,
-			float min_nearness) = 0;
+	                               float min_nearness) = 0;
 
-	virtual ~IRollbackManager(){}
+	virtual ~IRollbackManager() {}
 	virtual void flush() = 0;
-	// Get last actor that did something to position p, but not further than
+	// Get all actors that did something to position p, but not further than
 	// <seconds> in history
-	virtual std::string getLastNodeActor(v3s16 p, int range, int seconds,
-			v3s16 *act_p, int *act_seconds) = 0;
+	virtual std::list<RollbackAction> getNodeActors(v3s16 pos, int range,
+	                time_t seconds, int limit) = 0;
 	// Get actions to revert <seconds> of history made by <actor>
 	virtual std::list<RollbackAction> getRevertActions(const std::string &actor,
-			int seconds) = 0;
+	                time_t seconds) = 0;
 };
 
 IRollbackManager *createRollbackManager(const std::string &filepath, IGameDef *gamedef);
diff --git a/src/rollback_interface.h b/src/rollback_interface.h
index b2e8f3428..f16f82b40 100644
--- a/src/rollback_interface.h
+++ b/src/rollback_interface.h
@@ -63,7 +63,7 @@ struct RollbackAction
 		TYPE_MODIFY_INVENTORY_STACK,
 	} type;
 
-	int unix_time;
+	time_t unix_time;
 	std::string actor;
 	bool actor_is_guess;
 
diff --git a/src/script/lua_api/l_rollback.cpp b/src/script/lua_api/l_rollback.cpp
index d5abe176e..e7185b00b 100644
--- a/src/script/lua_api/l_rollback.cpp
+++ b/src/script/lua_api/l_rollback.cpp
@@ -24,21 +24,54 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "rollback.h"
 
 
-// rollback_get_last_node_actor(p, range, seconds) -> actor, p, seconds
-int ModApiRollback::l_rollback_get_last_node_actor(lua_State *L)
+void push_RollbackNode(lua_State *L, RollbackNode &node)
 {
-	v3s16 p = read_v3s16(L, 1);
+	lua_createtable(L, 0, 3);
+	lua_pushstring(L, node.name.c_str());
+	lua_setfield(L, -2, "name");
+	lua_pushnumber(L, node.param1);
+	lua_setfield(L, -2, "param1");
+	lua_pushnumber(L, node.param2);
+	lua_setfield(L, -2, "param2");
+}
+
+// rollback_get_node_actions(pos, range, seconds, limit) -> {{actor, pos, time, oldnode, newnode}, ...}
+int ModApiRollback::l_rollback_get_node_actions(lua_State *L)
+{
+	v3s16 pos = read_v3s16(L, 1);
 	int range = luaL_checknumber(L, 2);
-	int seconds = luaL_checknumber(L, 3);
+	time_t seconds = (time_t) luaL_checknumber(L, 3);
+	int limit = luaL_checknumber(L, 4);
 	Server *server = getServer(L);
 	IRollbackManager *rollback = server->getRollbackManager();
-	v3s16 act_p;
-	int act_seconds = 0;
-	std::string actor = rollback->getLastNodeActor(p, range, seconds, &act_p, &act_seconds);
-	lua_pushstring(L, actor.c_str());
-	push_v3s16(L, act_p);
-	lua_pushnumber(L, act_seconds);
-	return 3;
+
+	std::list<RollbackAction> actions = rollback->getNodeActors(pos, range, seconds, limit);
+	std::list<RollbackAction>::iterator iter = actions.begin();
+
+	lua_createtable(L, actions.size(), 0);
+	for (unsigned int i = 1; iter != actions.end(); ++iter, ++i) {
+		lua_pushnumber(L, i); // Push index
+		lua_createtable(L, 0, 5); // Make a table with enough space pre-allocated
+
+		lua_pushstring(L, iter->actor.c_str());
+		lua_setfield(L, -2, "actor");
+
+		push_v3s16(L, iter->p);
+		lua_setfield(L, -2, "pos");
+
+		lua_pushnumber(L, iter->unix_time);
+		lua_setfield(L, -2, "time");
+
+		push_RollbackNode(L, iter->n_old);
+		lua_setfield(L, -2, "oldnode");
+
+		push_RollbackNode(L, iter->n_new);
+		lua_setfield(L, -2, "newnode");
+
+		lua_settable(L, -3); // Add action table to main table
+	}
+
+	return 1;
 }
 
 // rollback_revert_actions_by(actor, seconds) -> bool, log messages
@@ -53,28 +86,19 @@ int ModApiRollback::l_rollback_revert_actions_by(lua_State *L)
 	bool success = server->rollbackRevertActions(actions, &log);
 	// Push boolean result
 	lua_pushboolean(L, success);
-	// Get the table insert function and push the log table
-	lua_getglobal(L, "table");
-	lua_getfield(L, -1, "insert");
-	int table_insert = lua_gettop(L);
-	lua_newtable(L);
-	int table = lua_gettop(L);
-	for(std::list<std::string>::const_iterator i = log.begin();
-			i != log.end(); i++)
-	{
-		lua_pushvalue(L, table_insert);
-		lua_pushvalue(L, table);
-		lua_pushstring(L, i->c_str());
-		if(lua_pcall(L, 2, 0, 0))
-			script_error(L);
+	lua_createtable(L, log.size(), 0);
+	unsigned long i = 0;
+	for(std::list<std::string>::const_iterator iter = log.begin();
+			iter != log.end(); ++i, ++iter) {
+		lua_pushnumber(L, i);
+		lua_pushstring(L, iter->c_str());
+		lua_settable(L, -3);
 	}
-	lua_remove(L, -2); // Remove table
-	lua_remove(L, -2); // Remove insert
 	return 2;
 }
 
 void ModApiRollback::Initialize(lua_State *L, int top)
 {
-	API_FCT(rollback_get_last_node_actor);
+	API_FCT(rollback_get_node_actions);
 	API_FCT(rollback_revert_actions_by);
 }
diff --git a/src/script/lua_api/l_rollback.h b/src/script/lua_api/l_rollback.h
index 86992a47e..3b01c0d8b 100644
--- a/src/script/lua_api/l_rollback.h
+++ b/src/script/lua_api/l_rollback.h
@@ -22,10 +22,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "lua_api/l_base.h"
 
-class ModApiRollback : public ModApiBase {
+class ModApiRollback : public ModApiBase
+{
 private:
-	// rollback_get_last_node_actor(p, range, seconds) -> actor, p, seconds
-	static int l_rollback_get_last_node_actor(lua_State *L);
+	// rollback_get_node_actions(pos, range, seconds) -> {{actor, pos, time, oldnode, newnode}, ...}
+	static int l_rollback_get_node_actions(lua_State *L);
 
 	// rollback_revert_actions_by(actor, seconds) -> bool, log messages
 	static int l_rollback_revert_actions_by(lua_State *L);