Beispiel #1
0
bool RuleManager::LoadRules(Database *db, const char *ruleset) {

	int rsid = GetRulesetID(db, ruleset);
	if(rsid < 0) {
		_log(RULES__ERROR, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset);
		return(false);
	}

	_log(RULES__CHANGE, "Loading rule set '%s' (%d)", ruleset, rsid);

	m_activeRuleset = rsid;
	m_activeName = ruleset;

    std::string query = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id=%d", rsid);
    auto results = db->QueryDatabase(query);
	if (!results.Success())
	{
        LogFile->write(EQEMuLog::Error, "Error in LoadRules query %s: %s", query.c_str(), results.ErrorMessage().c_str());
		return false;
	}

    for(auto row = results.begin(); row != results.end(); ++row)
        if(!SetRule(row[0], row[1], nullptr, false))
            _log(RULES__ERROR, "Unable to interpret rule record for %s", row[0]);

	return true;
}
Beispiel #2
0
int RuleManager::_FindOrCreateRuleset(Database *db, const char *ruleset) {
	int res;

	res = GetRulesetID(db, ruleset);
	if(res >= 0)
		return(res);	//found and existing one...

	uint32 len = strlen(ruleset);
	char* rst = new char[2*len+1];
	db->DoEscapeString(rst, ruleset, len);

	uint32 new_id;
	char errbuf[MYSQL_ERRMSG_SIZE];
	char* query = 0;
	if (!db->RunQuery(query, MakeAnyLenString(&query,
		"INSERT INTO rule_sets (ruleset_id, name) "
		" VALUES(0, '%s')",
		rst),errbuf,nullptr,nullptr,&new_id))
	{
		_log(RULES__ERROR, "Fauled to create rule set in the database: %s: %s", query,errbuf);
		res = -1;
	} else {
		res = new_id;
	}
	safe_delete_array(query);

	return(res);
}
Beispiel #3
0
bool RuleManager::LoadRules(Database *db, const char *ruleset) {

	int rsid = GetRulesetID(db, ruleset);
	if(rsid < 0) {
		Log.Out(Logs::Detail, Logs::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset);
		return(false);
	}

	Log.Out(Logs::Detail, Logs::Rules, "Loading rule set '%s' (%d)", ruleset, rsid);

	m_activeRuleset = rsid;
	m_activeName = ruleset;

    std::string query = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id=%d", rsid);
    auto results = db->QueryDatabase(query);
	if (!results.Success())
	{
		return false;
	}

    for(auto row = results.begin(); row != results.end(); ++row)
        if(!SetRule(row[0], row[1], nullptr, false))
            Log.Out(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);

	return true;
}
Beispiel #4
0
bool RuleManager::LoadRules(Database *database, const char *ruleset_name) {
	
	int ruleset_id = GetRulesetID(database, ruleset_name);
	if (ruleset_id < 0) {
		Log.Out(Logs::Detail, Logs::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset_name);
		return(false);
	}

	Log.Out(Logs::Detail, Logs::Rules, "Loading rule set '%s' (%d)", ruleset_name, ruleset_id);

	m_activeRuleset = ruleset_id;
	m_activeName = ruleset_name;

	/* Load default ruleset values first if we're loading something other than default */
	if (strcasecmp(ruleset_name, "default") != 0){
		std::string default_ruleset_name = "default";
		int default_ruleset_id = GetRulesetID(database, default_ruleset_name.c_str());
		if (default_ruleset_id < 0) {
			Log.Out(Logs::Detail, Logs::Rules, "Failed to find default ruleset '%s' for load operation. Canceling.", default_ruleset_name.c_str());
			return(false);
		}
		Log.Out(Logs::Detail, Logs::Rules, "Loading rule set '%s' (%d)", default_ruleset_name.c_str(), default_ruleset_id);

		std::string query = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id = %d", default_ruleset_id);
		auto results = database->QueryDatabase(query);
		if (!results.Success())
			return false;

		for (auto row = results.begin(); row != results.end(); ++row)
		if (!SetRule(row[0], row[1], nullptr, false))
			Log.Out(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);
	}

	std::string query = StringFormat("SELECT rule_name, rule_value FROM rule_values WHERE ruleset_id=%d", ruleset_id);
	auto results = database->QueryDatabase(query);
	if (!results.Success())
		return false;

	for (auto row = results.begin(); row != results.end(); ++row)
	if (!SetRule(row[0], row[1], nullptr, false))
		Log.Out(Logs::Detail, Logs::Rules, "Unable to interpret rule record for %s", row[0]);

	return true;
}
Beispiel #5
0
int RuleManager::_FindOrCreateRuleset(Database *database, const char *in_ruleset_name) {

	int ruleset_id = GetRulesetID(database, in_ruleset_name);
	if (ruleset_id >= 0)
		return ruleset_id;	//found and existing one...

	uint32 len = strlen(in_ruleset_name);
	auto ruleset_name = new char[2 * len + 1];
	database->DoEscapeString(ruleset_name, in_ruleset_name, len);

	std::string query = StringFormat("INSERT INTO rule_sets (ruleset_id, name) VALUES(0, '%s')", ruleset_name);
	safe_delete_array(ruleset_name);
	auto results = database->QueryDatabase(query);
	if (!results.Success())
		return -1;

	return results.LastInsertedID();
}
Beispiel #6
0
int RuleManager::_FindOrCreateRuleset(Database *db, const char *ruleset) {

	int res = GetRulesetID(db, ruleset);
	if(res >= 0)
		return res;	//found and existing one...

	uint32 len = strlen(ruleset);
	char* rst = new char[2*len+1];
	db->DoEscapeString(rst, ruleset, len);

	std::string query = StringFormat("INSERT INTO rule_sets (ruleset_id, name) VALUES(0, '%s')", rst);
	safe_delete_array(rst);
	auto results = db->QueryDatabase(query);
	if (!results.Success())
	{
		return -1;
	}

    return results.LastInsertedID();
}
Beispiel #7
0
bool RuleManager::LoadRules(Database *db, const char *ruleset) {
	char errbuf[MYSQL_ERRMSG_SIZE];
	char *query = 0;
	MYSQL_RES *result;
	MYSQL_ROW row;

	int rsid = GetRulesetID(db, ruleset);
	if(rsid < 0) {
		_log(RULES__ERROR, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset);
		return(false);
	}

	_log(RULES__CHANGE, "Loading rule set '%s' (%d)", ruleset, rsid);

	m_activeRuleset = rsid;
	m_activeName = ruleset;

	if (db->RunQuery(query, MakeAnyLenString(&query,
		"SELECT rule_name, rule_value"
		" FROM rule_values"
		" WHERE ruleset_id=%d", rsid), errbuf, &result))
	{
		safe_delete_array(query);
		while((row = mysql_fetch_row(result))) {
			if(!SetRule(row[0], row[1], nullptr, false))
				_log(RULES__ERROR, "Unable to interpret rule record for %s", row[0]);
		}
		mysql_free_result(result);
	} else {
		safe_delete_array(query);
		LogFile->write(EQEMuLog::Error, "Error in LoadRules query %s: %s", query, errbuf);
		return(false);
	}

	return(true);
}