#include <cerrno>
#include <cstdio>
#include <cstdlib>
-#include <string>
#include <algorithm>
#include <mysql.h>
#include <errmsg.h>
-#include "user_ips.h"
-#include "user_conf.h"
-#include "user_stat.h"
+#include "stg/user_ips.h"
+#include "stg/user_conf.h"
+#include "stg/user_stat.h"
+#include "stg/blowfish.h"
+#include "stg/plugin_creator.h"
+#include "stg/logger.h"
#include "mysql_store.h"
-#include "blowfish.h"
#define adm_enc_passwd "cjeifY8m3"
-char qbuf[4096];
-using namespace std;
+namespace
+{
+char qbuf[4096];
const int pt_mega = 1024 * 1024;
-const string badSyms = "'`";
+const std::string badSyms = "'`";
const char repSym = '\"';
const int RepitTimes = 3;
-int GetInt(const string & str, int * val, int defaultVal)
+template <typename T>
+int GetInt(const std::string & str, T * val, T defaultVal = T())
{
char *res;
- *val = strtol(str.c_str(), &res, 10);
+ *val = static_cast<T>(strtoll(str.c_str(), &res, 10));
if (*res != 0)
{
return 0;
}
-int GetDouble(const string & str, double * val, double defaultVal)
+int GetDouble(const std::string & str, double * val, double defaultVal)
{
char *res;
return 0;
}
-int GetTime(const string & str, time_t * val, time_t defaultVal)
+int GetTime(const std::string & str, time_t * val, time_t defaultVal)
{
char *res;
}
//-----------------------------------------------------------------------------
-string ReplaceStr(string source, const string symlist, const char chgsym)
+std::string ReplaceStr(std::string source, const std::string & symlist, const char chgsym)
{
- string::size_type pos=0;
+ std::string::size_type pos=0;
- while( (pos = source.find_first_of(symlist,pos)) != string::npos)
+ while( (pos = source.find_first_of(symlist,pos)) != std::string::npos)
source.replace(pos, 1,1, chgsym);
return source;
}
-int GetULongLongInt(const string & str, uint64_t * val, uint64_t defaultVal)
+int GetULongLongInt(const std::string & str, uint64_t * val, uint64_t defaultVal)
{
char *res;
return 0;
}
-class MYSQL_STORE_CREATOR
-{
-private:
- MYSQL_STORE * ms;
-
-public:
- MYSQL_STORE_CREATOR()
- : ms(new MYSQL_STORE())
- {
- };
- ~MYSQL_STORE_CREATOR()
- {
- delete ms;
- };
+PLUGIN_CREATOR<MYSQL_STORE> msc;
+}
- MYSQL_STORE * GetStore()
- {
- return ms;
- };
-} msc;
+extern "C" STORE * GetStore();
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
STORE * GetStore()
{
-return msc.GetStore();
+return msc.GetPlugin();
}
//-----------------------------------------------------------------------------
MYSQL_STORE_SETTINGS::MYSQL_STORE_SETTINGS()
- : settings(NULL)
-{
-}
-//-----------------------------------------------------------------------------
-MYSQL_STORE_SETTINGS::~MYSQL_STORE_SETTINGS()
+ : settings(NULL),
+ errorStr(),
+ dbUser(),
+ dbPass(),
+ dbName(),
+ dbHost(),
+ schemaVersion(0)
{
-
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE_SETTINGS::ParseParam(const vector<PARAM_VALUE> & moduleParams,
- const string & name, string & result)
+int MYSQL_STORE_SETTINGS::ParseParam(const
std::vector<PARAM_VALUE> & moduleParams,
+ const std::string & name, std::string & result)
{
PARAM_VALUE pv;
pv.param = name;
-vector<PARAM_VALUE>::const_iterator pvi;
+
std::vector<PARAM_VALUE>::const_iterator pvi;
pvi = find(moduleParams.begin(), moduleParams.end(), pv);
if (pvi == moduleParams.end())
{
//-----------------------------------------------------------------------------
int MYSQL_STORE_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
{
-if (ParseParam(s.moduleParams, "dbuser", dbUser) < 0)
+if (ParseParam(s.moduleParams, "user", dbUser) < 0 &&
+ ParseParam(s.moduleParams, "dbuser", dbUser) < 0)
return -1;
-if (ParseParam(s.moduleParams, "rootdbpass", dbPass) < 0)
+if (ParseParam(s.moduleParams, "password", dbPass) < 0 &&
+ ParseParam(s.moduleParams, "rootdbpass", dbPass) < 0)
return -1;
-if (ParseParam(s.moduleParams, "dbname", dbName) < 0)
+if (ParseParam(s.moduleParams, "database", dbName) < 0 &&
+ ParseParam(s.moduleParams, "dbname", dbName) < 0)
return -1;
-if (ParseParam(s.moduleParams, "dbhost", dbHost) < 0)
+if (ParseParam(s.moduleParams, "server", dbHost) < 0 &&
+ ParseParam(s.moduleParams, "dbhost", dbHost) < 0)
return -1;
return 0;
}
//-----------------------------------------------------------------------------
-const string & MYSQL_STORE_SETTINGS::GetStrError() const
-{
-return errorStr;
-}
-//-----------------------------------------------------------------------------
-string MYSQL_STORE_SETTINGS::GetDBUser() const
-{
-return dbUser;
-}
-//-----------------------------------------------------------------------------
-string MYSQL_STORE_SETTINGS::GetDBPassword() const
-{
-return dbPass;
-}
-//-----------------------------------------------------------------------------
-string MYSQL_STORE_SETTINGS::GetDBHost() const
-{
-return dbHost;
-}
-//-----------------------------------------------------------------------------
-string MYSQL_STORE_SETTINGS::GetDBName() const
-{
-return dbName;
-}
-//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
MYSQL_STORE::MYSQL_STORE()
+ : errorStr(),
+ version("mysql_store v.0.67"),
+ storeSettings(),
+ settings(),
+ logger(GetPluginLogger(GetStgLogger(), "store_mysql"))
{
-version = "mysql_store v.0.67";
-};
-//-----------------------------------------------------------------------------
-MYSQL_STORE::~MYSQL_STORE()
-{
-};
-//-----------------------------------------------------------------------------
-void MYSQL_STORE::SetSettings(const MODULE_SETTINGS & s)
-{
-settings = s;
}
//-----------------------------------------------------------------------------
int MYSQL_STORE::MysqlQuery(const char* sQuery,MYSQL * sock) const
{
- int ret,i;
+ int ret;
if( (ret = mysql_query(sock,sQuery)) )
{
- for(i=0; i<RepitTimes; i++)
+ for(int i=0; i<RepitTimes; i++)
{
if( (ret = mysql_query(sock,sQuery)) )
;//need to send error result
{
int ret = storeSettings.ParseSettings(settings);
MYSQL mysql;
-MYSQL * sock;
mysql_init(&mysql);
if (ret)
errorStr = storeSettings.GetStrError();
errorStr = "Database password must be not empty. Please read Manual.";
return -1;
}
-
+ MYSQL * sock;
if (!(sock = mysql_real_connect(&mysql,storeSettings.GetDBHost().c_str(),
storeSettings.GetDBUser().c_str(),storeSettings.GetDBPassword().c_str(),
0,0,NULL,0)))
{
if(mysql_select_db(sock, storeSettings.GetDBName().c_str()))
{
- string res = "CREATE DATABASE " + storeSettings.GetDBName();
+ std::string res = "CREATE DATABASE " + storeSettings.GetDBName();
if(MysqlQuery(res.c_str(),sock))
{
}
ret = CheckAllTables(sock);
}
- }
- else
- ret = CheckAllTables(sock);
- mysql_close(sock);
+ }
+ else
+ {
+ ret = CheckAllTables(sock);
+ }
+ if (!ret)
+ {
+ logger("MYSQL_STORE: Current DB schema version: %d", schemaVersion);
+ MakeUpdates(sock);
+ }
+ mysql_close(sock);
}
-
}
return ret;
}
//-----------------------------------------------------------------------------
-const string & MYSQL_STORE::GetStrError() const
-{
-return errorStr;
-}
-//-----------------------------------------------------------------------------
-const string & MYSQL_STORE::GetVersion() const
-{
-return version;
-}
-//-----------------------------------------------------------------------------
-bool MYSQL_STORE::IsTablePresent(const string & str,MYSQL * sock)
+bool MYSQL_STORE::IsTablePresent(const std::string & str,MYSQL * sock)
{
MYSQL_RES* result;
return -1;
}
-unsigned int num_rows = mysql_num_rows(result);
+my_ulonglong num_rows = mysql_num_rows(result);
if(result)
mysql_free_result(result);
-return (num_rows == 1);
+return num_rows == 1;
}
//-----------------------------------------------------------------------------
int MYSQL_STORE::CheckAllTables(MYSQL * sock)
{
+//info-------------------------------------------------------------------------
+if(!IsTablePresent("info",sock))
+{
+ sprintf(qbuf,"CREATE TABLE info (version INTEGER NOT NULL)");
+
+ if(MysqlQuery(qbuf,sock))
+ {
+ errorStr = "Couldn't create info table With error:\n";
+ errorStr += mysql_error(sock);
+ mysql_close(sock);
+ return -1;
+ }
+
+ sprintf(qbuf,"INSERT INTO info SET version=0");
+
+ if(MysqlQuery(qbuf,sock))
+ {
+ errorStr = "Couldn't write default version. With error:\n";
+ errorStr += mysql_error(sock);
+ mysql_close(sock);
+ return -1;
+ }
+ schemaVersion = 0;
+}
+else
+{
+ std::vector<std::string> info;
+ if (GetAllParams(&info, "info", "version"))
+ schemaVersion = 0;
+ else
+ {
+ if (info.empty())
+ schemaVersion = 0;
+ else
+ GetInt(info.front(), &schemaVersion, 0);
+ }
+}
//admins-----------------------------------------------------------------------
if(!IsTablePresent("admins",sock))
{
}
//tariffs-----------------------------------------------------------------------
-string param, res;
+std::string param, res;
if(!IsTablePresent("tariffs",sock))
{
res = "CREATE TABLE tariffs (name VARCHAR(40) DEFAULT '' PRIMARY KEY,";
res += param;
}
- res += "PassiveCost DOUBLE DEFAULT 0.0, Fee DOUBLE DEFAULT 0.0,"\
- "Free DOUBLE DEFAULT 0.0, TraffType VARCHAR(10) DEFAULT '')";
+ res += "PassiveCost DOUBLE DEFAULT 0.0, Fee DOUBLE DEFAULT 0.0,"
+ "Free DOUBLE DEFAULT 0.0, TraffType VARCHAR(10) DEFAULT '',"
+ "period VARCHAR(32) NOT NULL DEFAULT 'month')";
if(MysqlQuery(res.c_str(),sock))
{
res += "PassiveCost=0.0, Fee=10.0, Free=0,"\
"SinglePrice0=1, SinglePrice1=1,PriceDayA1=0.75,PriceDayB1=0.75,"\
- "PriceNightA0=1.0,PriceNightB0=1.0,TraffType='up+down'";
+ "PriceNightA0=1.0,PriceNightB0=1.0,TraffType='up+down',period='month'";
if(MysqlQuery(res.c_str(),sock))
{
mysql_close(sock);
return -1;
}
+
+ sprintf(qbuf,"UPDATE info SET version=1");
+
+ if(MysqlQuery(qbuf,sock))
+ {
+ errorStr = "Couldn't write default version. With error:\n";
+ errorStr += mysql_error(sock);
+ mysql_close(sock);
+ return -1;
+ }
+ schemaVersion = 1;
}
//users-----------------------------------------------------------------------
res = "INSERT INTO users SET login='test',Address='',AlwaysOnline=0,"\
"Credit=0.0,CreditExpire=0,Down=0,Email='',DisabledDetailStat=0,"\
"StgGroup='',IP='192.168.1.1',Note='',Passive=0,Password='123456',"\
- "Phone='', RealName='',Tariff='tariff',TariffChange='',Userdata0='',"\
- "Userdata1='',";
+ "Phone='', RealName='',Tariff='tariff',TariffChange='',NAS='',";
+
+ for (int i = 0; i < USERDATA_NUM; i++)
+ {
+ strprintf(¶m, " Userdata%d='',", i);
+ res += param;
+ }
for (int i = 0; i < DIR_NUM; i++)
{
return 0;
}
//-----------------------------------------------------------------------------
+int MYSQL_STORE::MakeUpdates(MYSQL * sock)
+{
+if (schemaVersion < 1)
+ {
+ if (MysqlQuery("ALTER TABLE tariffs ADD period VARCHAR(32) NOT NULL DEFAULT 'month'", sock))
+ {
+ errorStr = "Couldn't update tariffs table to version 1. With error:\n";
+ errorStr += mysql_error(sock);
+ mysql_close(sock);
+ return -1;
+ }
+ if (MysqlQuery("UPDATE info SET version = 1", sock))
+ {
+ errorStr = "Couldn't update DB schema version to 1. With error:\n";
+ errorStr += mysql_error(sock);
+ mysql_close(sock);
+ return -1;
+ }
+ schemaVersion = 1;
+ logger("MYSQL_STORE: Updated DB schema to version %d", schemaVersion);
+ }
+return 0;
+}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::GetAllParams(vector<string> * ParamList,
- const string & table, const string & name) const
+int MYSQL_STORE::GetAllParams(std::vector<std::string> * ParamList,
+ const std::string & table, const std::string & name) const
{
MYSQL_RES *res;
MYSQL_ROW row;
MYSQL * sock=NULL;
-unsigned int num,i;
+my_ulonglong num, i;
ParamList->clear();
num = mysql_num_rows(res);
-for(i=0;i<num;i++)
+for(i = 0; i < num; i++)
{
row = mysql_fetch_row(res);
ParamList->push_back(row[0]);
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::GetUsersList(vector<string> * usersList) const
+int MYSQL_STORE::GetUsersList(std::vector<std::string> * usersList) const
{
if(GetAllParams(usersList, "users", "login"))
return -1;
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::GetAdminsList(vector<string> * adminsList) const
+int MYSQL_STORE::GetAdminsList(std::vector<std::string> * adminsList) const
{
if(GetAllParams(adminsList, "admins", "login"))
return -1;
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::GetTariffsList(vector<string> * tariffsList) const
+int MYSQL_STORE::GetTariffsList(std::vector<std::string> * tariffsList) const
{
if(GetAllParams(tariffsList, "tariffs", "name"))
return -1;
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::AddUser(const string & login) const
+int MYSQL_STORE::AddUser(const std::string & login) const
{
-sprintf(qbuf,"INSERT INTO users SET login='%s'", login.c_str());
-
-if(MysqlSetQuery(qbuf))
+std::string query = "INSERT INTO users SET login='" + login + "',Note='',NAS=''";
+
+for (int i = 0; i < USERDATA_NUM; i++)
+ query += ",Userdata" + x2str(i) + "=''";
+
+if(MysqlSetQuery(query.c_str()))
{
errorStr = "Couldn't add user:\n";
//errorStr += mysql_error(sock);
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::DelUser(const string & login) const
+int MYSQL_STORE::DelUser(const std::string & login) const
{
sprintf(qbuf,"DELETE FROM users WHERE login='%s' LIMIT 1", login.c_str());
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::RestoreUserConf(USER_CONF * conf, const string & login) const
+int MYSQL_STORE::RestoreUserConf(USER_CONF * conf, const std::string & login) const
{
MYSQL_RES *res;
MYSQL_ROW row;
MYSQL * sock;
-string query;
+std::string query;
query = "SELECT login, Password, Passive, Down, DisabledDetailStat, \
AlwaysOnline, Tariff, Address, Phone, Email, Note, \
row = mysql_fetch_row(res);
-string param;
-
conf->password = row[1];
if (conf->password.empty())
return -1;
}
-if (GetInt(row[2],&conf->passive, 0) != 0)
+if (GetInt(row[2],&conf->passive) != 0)
{
mysql_free_result(res);
errorStr = "User \'" + login + "\' data not read. Parameter Passive.";
return -1;
}
-if (GetInt(row[3], &conf->disabled, 0) != 0)
+if (GetInt(row[3], &conf->disabled) != 0)
{
mysql_free_result(res);
errorStr = "User \'" + login + "\' data not read. Parameter Down.";
return -1;
}
-if (GetInt(row[4], &conf->disabledDetailStat, 0) != 0)
+if (GetInt(row[4], &conf->disabledDetailStat) != 0)
{
mysql_free_result(res);
errorStr = "User \'" + login + "\' data not read. Parameter DisabledDetailStat.";
return -1;
}
-if (GetInt(row[5], &conf->alwaysOnline, 0) != 0)
+if (GetInt(row[5], &conf->alwaysOnline) != 0)
{
mysql_free_result(res);
errorStr = "User \'" + login + "\' data not read. Parameter AlwaysOnline.";
GetTime(row[15+USERDATA_NUM], &conf->creditExpire, 0);
-string ipStr = row[16+USERDATA_NUM];
+std::string ipStr = row[16+USERDATA_NUM];
USER_IPS i;
try
{
i = StrToIPS(ipStr);
}
-catch (const string & s)
+catch (const std::string & s)
{
mysql_free_result(res);
errorStr = "User \'" + login + "\' data not read. Parameter IP address. " + s;
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::RestoreUserStat(USER_STAT * stat, const string & login) const
+int MYSQL_STORE::RestoreUserStat(USER_STAT * stat, const std::string & login) const
{
MYSQL_RES *res;
MYSQL_ROW row;
MYSQL * sock;
-string query;
+std::string query;
query = "SELECT ";
if (GetULongLongInt(row[startPos+i*2], &traff, 0) != 0)
{
mysql_free_result(res);
- errorStr = "User \'" + login + "\' stat not read. Parameter " + string(s);
+ errorStr = "User \'" + login + "\' stat not read. Parameter " + std::string(s);
mysql_close(sock);
return -1;
}
- stat->down[i] = traff;
+ stat->monthDown[i] = traff;
sprintf(s, "U%d", i);
if (GetULongLongInt(row[startPos+i*2+1], &traff, 0) != 0)
{
mysql_free_result(res);
- errorStr = "User \'" + login + "\' stat not read. Parameter " + string(s);
+ errorStr = "User \'" + login + "\' stat not read. Parameter " + std::string(s);
mysql_close(sock);
return -1;
}
- stat->up[i] = traff;
+ stat->monthUp[i] = traff;
}//for
startPos += (2*DIR_NUM);
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::SaveUserConf(const USER_CONF & conf, const string & login) const
+int MYSQL_STORE::SaveUserConf(const USER_CONF & conf, const std::string & login) const
{
-string param;
-string res;
+std::string param;
+std::string res;
strprintf(&res,"UPDATE users SET Password='%s', Passive=%d, Down=%d, DisabledDetailStat = %d, "\
"AlwaysOnline=%d, Tariff='%s', Address='%s', Phone='%s', Email='%s', "\
strprintf(¶m, " CreditExpire=%d,", conf.creditExpire);
res += param;
-stringstream ipStr;
+std::ostringstream ipStr;
ipStr << conf.ips;
strprintf(¶m, " IP='%s'", ipStr.str().c_str());
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::SaveUserStat(const USER_STAT & stat, const string & login) const
+int MYSQL_STORE::SaveUserStat(const USER_STAT & stat, const std::string & login) const
{
-string param;
-string res;
+std::string param;
+std::string res;
res = "UPDATE users SET";
for (int i = 0; i < DIR_NUM; i++)
{
- strprintf(¶m, " D%d=%lld,", i, stat.down[i]);
+ strprintf(¶m, " D%d=%lld,", i, stat.monthDown[i]);
res += param;
- strprintf(¶m, " U%d=%lld,", i, stat.up[i]);
+ strprintf(¶m, " U%d=%lld,", i, stat.monthUp[i]);
res += param;
}
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::WriteLogString(const string & str, const string & login) const
+int MYSQL_STORE::WriteLogString(const std::string & str, const std::string & login) const
{
-string res, tempStr;
+std::string res, tempStr;
time_t t;
tm * lt;
return -1;
}
-unsigned int num_rows = mysql_num_rows(result);
+my_ulonglong num_rows = mysql_num_rows(result);
mysql_free_result(result);
strprintf(&res, "%s -- %s",LogDate(t), str.c_str());
-string send;
+std::string send;
strprintf(&send,"INSERT INTO logs_%02d_%4d SET login='%s', text='%s'",
lt->tm_mon+1, lt->tm_year+1900,
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::WriteUserChgLog(const string & login,
- const string & admLogin,
+int MYSQL_STORE::WriteUserChgLog(const std::string & login,
+ const std::string & admLogin,
uint32_t admIP,
- const string & paramName,
- const string & oldValue,
- const string & newValue,
- const string & message) const
+ const std::string & paramName,
+ const std::string & oldValue,
+ const std::string & newValue,
+ const std::string & message) const
{
-string userLogMsg = "Admin \'" + admLogin + "\', " + inet_ntostring(admIP) + ": \'"
+std::string userLogMsg = "Admin \'" + admLogin + "\', " + inet_ntostring(admIP) + ": \'"
+ paramName + "\' parameter changed from \'" + oldValue +
"\' to \'" + newValue + "\'. " + message;
return WriteLogString(userLogMsg, login);
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::WriteUserConnect(const string & login, uint32_t ip) const
+int MYSQL_STORE::WriteUserConnect(const std::string & login, uint32_t ip) const
{
-string logStr = "Connect, " + inet_ntostring(ip);
+std::string logStr = "Connect, " + inet_ntostring(ip);
return WriteLogString(logStr, login);
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::WriteUserDisconnect(const string & login,
+int MYSQL_STORE::WriteUserDisconnect(const std::string & login,
const DIR_TRAFF & up,
const DIR_TRAFF & down,
const DIR_TRAFF & sessionUp,
const DIR_TRAFF & sessionDown,
double cash,
- double freeMb,
- const std::string & reason) const
+ double /*freeMb*/,
+ const std::string & /*reason*/) const
{
-string logStr = "Disconnect, ";
-stringstream sssu;
-stringstream sssd;
-stringstream ssmu;
-stringstream ssmd;
-stringstream sscash;
+std::string logStr = "Disconnect, ";
+std::ostringstream sssu;
+std::ostringstream sssd;
+std::ostringstream ssmu;
+std::ostringstream ssmd;
+std::ostringstream sscash;
ssmu << up;
ssmd << down;
}
//-----------------------------------------------------------------------------
int MYSQL_STORE::SaveMonthStat(const USER_STAT & stat, int month, int year,
- const string & login) const
+ const std::string & login) const
{
-string param, res;
+std::string param, res;
strprintf(&res, "INSERT INTO stat SET login='%s', month=%d, year=%d,",
login.c_str(), month+1, year+1900);
for (int i = 0; i < DIR_NUM; i++)
{
- strprintf(¶m, " U%d=%lld,", i, stat.up[i]);
+ strprintf(¶m, " U%d=%lld,", i, stat.monthUp[i]);
res += param;
- strprintf(¶m, " D%d=%lld,", i, stat.down[i]);
+ strprintf(¶m, " D%d=%lld,", i, stat.monthDown[i]);
res += param;
}
return 0;
}
//-----------------------------------------------------------------------------*/
-int MYSQL_STORE::AddAdmin(const string & login) const
+int MYSQL_STORE::AddAdmin(const std::string & login) const
{
sprintf(qbuf,"INSERT INTO admins SET login='%s'", login.c_str());
return 0;
}
//-----------------------------------------------------------------------------*/
-int MYSQL_STORE::DelAdmin(const string & login) const
+int MYSQL_STORE::DelAdmin(const std::string & login) const
{
sprintf(qbuf,"DELETE FROM admins where login='%s' LIMIT 1", login.c_str());
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::RestoreAdmin(ADMIN_CONF * ac, const string & login) const
+int MYSQL_STORE::RestoreAdmin(ADMIN_CONF * ac, const std::string & login) const
{
char pass[ADM_PASSWD_LEN + 1];
char password[ADM_PASSWD_LEN + 1];
char passwordE[2*ADM_PASSWD_LEN + 2];
BLOWFISH_CTX ctx;
-string p;
+memset(password, 0, sizeof(password));
+
+std::string p;
MYSQL_RES *res;
MYSQL_ROW row;
MYSQL * sock;
row = mysql_fetch_row(res);
p = row[1];
-int a;
if(p.length() == 0)
{
ac->password = password;
-if (GetInt(row[2], &a, 0) == 0)
+uint16_t a;
+
+if (GetInt(row[2], &a) == 0)
ac->priv.userConf = a;
else
{
return -1;
}
-if (GetInt(row[3], &a, 0) == 0)
+if (GetInt(row[3], &a) == 0)
ac->priv.userPasswd = a;
else
{
return -1;
}
-if (GetInt(row[4], &a, 0) == 0)
+if (GetInt(row[4], &a) == 0)
ac->priv.userStat = a;
else
{
return -1;
}
-if (GetInt(row[5], &a, 0) == 0)
+if (GetInt(row[5], &a) == 0)
ac->priv.userCash = a;
else
{
return -1;
}
-if (GetInt(row[6], &a, 0) == 0)
+if (GetInt(row[6], &a) == 0)
ac->priv.userAddDel = a;
else
{
return -1;
}
-if (GetInt(row[7], &a, 0) == 0)
+if (GetInt(row[7], &a) == 0)
ac->priv.tariffChg = a;
else
{
return -1;
}
-if (GetInt(row[8], &a, 0) == 0)
+if (GetInt(row[8], &a) == 0)
ac->priv.adminChg = a;
else
{
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::AddTariff(const string & name) const
+int MYSQL_STORE::AddTariff(const std::string & name) const
{
sprintf(qbuf,"INSERT INTO tariffs SET name='%s'", name.c_str());
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::DelTariff(const string & name) const
+int MYSQL_STORE::DelTariff(const std::string & name) const
{
sprintf(qbuf,"DELETE FROM tariffs WHERE name='%s' LIMIT 1", name.c_str());
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::RestoreTariff(TARIFF_DATA * td, const string & tariffName) const
+int MYSQL_STORE::RestoreTariff(TARIFF_DATA * td, const std::string & tariffName) const
{
MYSQL_RES *res;
MYSQL_ROW row;
return -1;
}
-string str;
+std::string str;
td->tariffConf.name = tariffName;
row = mysql_fetch_row(res);
-string param;
+std::string param;
for (int i = 0; i<DIR_NUM; i++)
{
strprintf(¶m, "Time%d", i);
td->dirPrice[i].priceNightB /= (1024*1024);
strprintf(¶m, "Threshold%d", i);
- if (GetInt(row[5+i*8], &td->dirPrice[i].threshold, 0) < 0)
+ if (GetInt(row[5+i*8], &td->dirPrice[i].threshold) < 0)
{
mysql_free_result(res);
errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
}
strprintf(¶m, "SinglePrice%d", i);
- if (GetInt(row[8+i*8], &td->dirPrice[i].singlePrice, 0) < 0)
+ if (GetInt(row[8+i*8], &td->dirPrice[i].singlePrice) < 0)
{
mysql_free_result(res);
errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
}
strprintf(¶m, "NoDiscount%d", i);
- if (GetInt(row[7+i*8], &td->dirPrice[i].noDiscount, 0) < 0)
+ if (GetInt(row[7+i*8], &td->dirPrice[i].noDiscount) < 0)
{
mysql_free_result(res);
errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
return -1;
}
+if (schemaVersion > 0)
+{
+ str = row[5+8*DIR_NUM];
+ param = "Period";
+
+ if (str.length() == 0)
+ {
+ mysql_free_result(res);
+ errorStr = "Cannot read tariff " + tariffName + ". Parameter " + param;
+ mysql_close(sock);
+ return -1;
+ }
+
+ td->tariffConf.period = TARIFF::StringToPeriod(str);
+ }
+else
+ {
+ td->tariffConf.period = TARIFF::MONTH;
+ }
+
mysql_free_result(res);
mysql_close(sock);
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::SaveTariff(const TARIFF_DATA & td, const string & tariffName) const
+int MYSQL_STORE::SaveTariff(const TARIFF_DATA & td, const std::string & tariffName) const
{
-string param;
+std::string param;
-string res="UPDATE tariffs SET";
+std::string res="UPDATE tariffs SET";
for (int i = 0; i < DIR_NUM; i++)
{
td.dirPrice[i].threshold);
res += param;
- string s;
+ std::string s;
strprintf(¶m, " Time%d", i);
strprintf(&s, "%0d:%0d-%0d:%0d",
res += " TraffType='max'";
break;
}
+
+if (schemaVersion > 0)
+ res += ", Period='" + TARIFF::PeriodToString(td.tariffConf.period) + "'";
+
strprintf(¶m, " WHERE name='%s' LIMIT 1", tariffName.c_str());
res += param;
if(MysqlSetQuery(res.c_str()))
{
- errorStr = "Couldn't save admin:\n";
+ errorStr = "Couldn't save tariff:\n";
//errorStr += mysql_error(sock);
return -1;
}
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::WriteDetailedStat(const map<IP_DIR_PAIR, STAT_NODE> & statTree,
+int MYSQL_STORE::WriteDetailedStat(const std::map<IP_DIR_PAIR, STAT_NODE> & statTree,
time_t lastStat,
- const string & login) const
+ const std::string & login) const
{
-string res, stTime, endTime, tempStr;
+std::string res, stTime, endTime, tempStr;
time_t t;
tm * lt;
return -1;
}
-unsigned int num_rows = mysql_num_rows(result);
+my_ulonglong num_rows = mysql_num_rows(result);
mysql_free_result(result);
endTime.c_str()
);
-map<IP_DIR_PAIR, STAT_NODE>::const_iterator stIter;
+std::map<IP_DIR_PAIR, STAT_NODE>::const_iterator stIter;
stIter = statTree.begin();
while (stIter != statTree.end())
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::AddMessage(STG_MSG * msg, const string & login) const
+int MYSQL_STORE::AddMessage(STG_MSG * msg, const std::string & login) const
{
struct timeval tv;
gettimeofday(&tv, NULL);
-msg->header.id = ((long long)tv.tv_sec) * 1000000 + ((long long)tv.tv_usec);
+msg->header.id = static_cast<uint64_t>(tv.tv_sec) * 1000000 + static_cast<uint64_t>(tv.tv_usec);
sprintf(qbuf,"INSERT INTO messages SET login='%s', id=%lld",
login.c_str(),
- (long long)msg->header.id
+ static_cast<long long>(msg->header.id)
);
if(MysqlSetQuery(qbuf))
return EditMessage(*msg, login);
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::EditMessage(const STG_MSG & msg, const string & login) const
+int MYSQL_STORE::EditMessage(const STG_MSG & msg, const std::string & login) const
{
-string res;
+std::string res;
strprintf(&res,"UPDATE messages SET type=%d, lastSendTime=%u, creationTime=%u, "\
"showTime=%u, stgRepeat=%d, repeatPeriod=%u, text='%s' "\
msg.header.repeatPeriod,
(ReplaceStr(msg.text,badSyms,repSym)).c_str(),
login.c_str(),
- (long long)msg.header.id
+ msg.header.id
);
if(MysqlSetQuery(res.c_str()))
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::GetMessage(uint64_t id, STG_MSG * msg, const string & login) const
+int MYSQL_STORE::GetMessage(uint64_t id, STG_MSG * msg, const std::string & login) const
{
MYSQL_RES *res;
MYSQL_ROW row;
MYSQL * sock;
-sprintf(qbuf,"SELECT * FROM messages WHERE login='%s' AND id=%lld LIMIT 1",
- login.c_str(), id);
+sprintf(qbuf,"SELECT * FROM messages WHERE login='%s' AND id=%llu LIMIT 1",
+ login.c_str(), static_cast<unsigned long long>(id));
if(MysqlGetQuery(qbuf,sock))
{
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::DelMessage(uint64_t id, const string & login) const
+int MYSQL_STORE::DelMessage(uint64_t id, const std::string & login) const
{
sprintf(qbuf,"DELETE FROM messages WHERE login='%s' AND id=%lld LIMIT 1",
- login.c_str(),(long long)id);
+ login.c_str(), static_cast<long long>(id));
if(MysqlSetQuery(qbuf))
{
return 0;
}
//-----------------------------------------------------------------------------
-int MYSQL_STORE::GetMessageHdrs(vector<STG_MSG_HDR> * hdrsList, const string & login) const
+int MYSQL_STORE::GetMessageHdrs(std::vector<STG_MSG_HDR> * hdrsList, const std::string & login) const
{
MYSQL_RES *res;
MYSQL_ROW row;
return -1;
}
-unsigned int i, num_rows = mysql_num_rows(res);
-long long int unsigned id = 0;
+unsigned int i;
+my_ulonglong num_rows = mysql_num_rows(res);
+uint64_t id = 0;
-for (i=0; i<num_rows; i++)
+for (i = 0; i < num_rows; i++)
{
row = mysql_fetch_row(res);
if (str2x(row[1], id))
git.stg.codes / stg.git / blobdiff