/* * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* * Author : Boris Mikhailenko */ #include "stg/servconf.h" #include "netunit.h" #include "parsers/simple.h" #include "parsers/server_info.h" #include "parsers/get_admins.h" #include "parsers/get_admin.h" #include "parsers/chg_admin.h" #include "parsers/get_tariffs.h" #include "parsers/get_tariff.h" #include "parsers/chg_tariff.h" #include "parsers/auth_by.h" #include "parsers/get_users.h" #include "parsers/get_user.h" #include "parsers/chg_user.h" #include "parsers/get_services.h" #include "parsers/get_service.h" #include "parsers/chg_service.h" #include "parsers/base.h" #include "stg/common.h" #include #include #include using namespace STG; class SERVCONF::IMPL { public: IMPL(const std::string & server, uint16_t port, const std::string & login, const std::string & password); const std::string & GetStrError() const; static void Start(void * data, const char * el, const char ** attr); static void End(void * data, const char * el); int RawXML(const std::string & request, RAW_XML::CALLBACK f, void * data); template int Exec(const std::string & request, C callback, void * data) { P cp(callback, data); return ExecImpl(request, cp); } template int Exec(const std::string & tag, const std::string & request, C callback, void * data) { P cp(tag, callback, data); return ExecImpl(request, cp); } private: NETTRANSACT nt; std::string errorMsg; XML_Parser parser; static bool ParserRecv(void * data, const std::string & chunk, bool final); static bool SimpleRecv(void * data, const std::string & chunk, bool final); int ExecImpl(const std::string & request, PARSER & cp); }; bool SERVCONF::IMPL::ParserRecv(void * data, const std::string & chunk, bool final) { SERVCONF::IMPL * sc = static_cast(data); if (XML_Parse(sc->parser, chunk.c_str(), chunk.length(), final) == XML_STATUS_ERROR) { strprintf(&sc->errorMsg, "XML parse error at line %d: %s", static_cast(XML_GetCurrentLineNumber(sc->parser)), XML_ErrorString(XML_GetErrorCode(sc->parser))); printf("%s\n", sc->errorMsg.c_str()); return false; } return true; } bool SERVCONF::IMPL::SimpleRecv(void * data, const std::string & chunk, bool /*final*/) { *static_cast(data) += chunk; return true; } SERVCONF::SERVCONF(const std::string & server, uint16_t port, const std::string & login, const std::string & password) : pImpl(new IMPL(server, port, login, password)) { } SERVCONF::~SERVCONF() { delete pImpl; } int SERVCONF::ServerInfo(SERVER_INFO::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::RawXML(const std::string & request, RAW_XML::CALLBACK f, void * data) { return pImpl->RawXML(request, f, data); } // -- Admins -- int SERVCONF::GetAdmins(GET_ADMINS::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::GetAdmin(const std::string & login, GET_ADMIN::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::ChgAdmin(const ADMIN_CONF_RES & conf, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("ChgAdmin", "", f, data); } int SERVCONF::AddAdmin(const std::string & login, const ADMIN_CONF_RES & conf, SIMPLE::CALLBACK f, void * data) { int res = pImpl->Exec("AddAdmin", "", f, data); if (res != st_ok) return res; return pImpl->Exec("ChgAdmin", "", f, data); } int SERVCONF::DelAdmin(const std::string & login, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("DelAdmin", "", f, data); } // -- Tariffs -- int SERVCONF::GetTariffs(GET_TARIFFS::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::GetTariff(const std::string & name, GET_TARIFF::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::ChgTariff(const TARIFF_DATA_RES & tariffData, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("SetTariff", "" + CHG_TARIFF::Serialize(tariffData) + "", f, data); } int SERVCONF::AddTariff(const std::string & name, const TARIFF_DATA_RES & tariffData, SIMPLE::CALLBACK f, void * data) { int res = pImpl->Exec("AddTariff", "", f, data); if (res != st_ok) return res; return pImpl->Exec("SetTariff", "" + CHG_TARIFF::Serialize(tariffData) + "", f, data); } int SERVCONF::DelTariff(const std::string & name, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("DelTariff", "", f, data); } // -- Users -- int SERVCONF::GetUsers(GET_USERS::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::GetUser(const std::string & login, GET_USER::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::ChgUser(const std::string & login, const USER_CONF_RES & conf, const USER_STAT_RES & stat, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("" + CHG_USER::Serialize(conf, stat) + "", f, data); } int SERVCONF::DelUser(const std::string & login, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("DelUser", "", f, data); } int SERVCONF::AddUser(const std::string & login, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("AddUser", "", f, data); } int SERVCONF::AuthBy(const std::string & login, AUTH_BY::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::SendMessage(const std::string & login, const std::string & text, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("SendMessage", "", f, data); } int SERVCONF::CheckUser(const std::string & login, const std::string & password, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("CheckUser", "", f, data); } // -- Services -- int SERVCONF::GetServices(GET_SERVICES::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::GetService(const std::string & name, GET_SERVICE::CALLBACK f, void * data) { return pImpl->Exec("", f, data); } int SERVCONF::ChgService(const SERVICE_CONF_RES & conf, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("SetService", "" + CHG_SERVICE::Serialize(conf) + "", f, data); } int SERVCONF::AddService(const std::string & name, const SERVICE_CONF_RES & conf, SIMPLE::CALLBACK f, void * data) { int res = pImpl->Exec("AddService", "", f, data); if (res != st_ok) return res; return pImpl->Exec("SetService", "" + CHG_SERVICE::Serialize(conf) + "", f, data); } int SERVCONF::DelService(const std::string & name, SIMPLE::CALLBACK f, void * data) { return pImpl->Exec("DelService", "", f, data); } const std::string & SERVCONF::GetStrError() const { return pImpl->GetStrError(); } //----------------------------------------------------------------------------- SERVCONF::IMPL::IMPL(const std::string & server, uint16_t port, const std::string & login, const std::string & password) : nt( server, port, login, password ) { parser = XML_ParserCreate(NULL); nt.SetRxCallback(this, ParserRecv); } //----------------------------------------------------------------------------- void SERVCONF::IMPL::Start(void * data, const char * el, const char ** attr) { PARSER * currParser = static_cast(data); currParser->ParseStart(el, attr); } //----------------------------------------------------------------------------- void SERVCONF::IMPL::End(void * data, const char * el) { PARSER * currParser = static_cast(data); currParser->ParseEnd(el); } //----------------------------------------------------------------------------- const std::string & SERVCONF::IMPL::GetStrError() const { return errorMsg; } //----------------------------------------------------------------------------- int SERVCONF::IMPL::ExecImpl(const std::string & request, PARSER & cp) { XML_ParserReset(parser, NULL); XML_SetElementHandler(parser, Start, End); XML_SetUserData(parser, &cp); int ret = 0; if ((ret = nt.Connect()) != st_ok) { errorMsg = nt.GetError(); return ret; } if ((ret = nt.Transact(request.c_str())) != st_ok) { errorMsg = nt.GetError(); return ret; } if ((ret = nt.Disconnect()) != st_ok) { errorMsg = nt.GetError(); return ret; } return st_ok; } int SERVCONF::IMPL::RawXML(const std::string & request, RAW_XML::CALLBACK f, void * data) { std::string response; nt.SetRxCallback(&response, SimpleRecv); int ret = 0; if ((ret = nt.Connect()) != st_ok) { nt.SetRxCallback(this, ParserRecv); errorMsg = nt.GetError(); f(false, errorMsg, "", data); return ret; } if ((ret = nt.Transact(request.c_str())) != st_ok) { nt.SetRxCallback(this, ParserRecv); errorMsg = nt.GetError(); f(false, errorMsg, "", data); return ret; } if ((ret = nt.Disconnect()) != st_ok) { nt.SetRxCallback(this, ParserRecv); errorMsg = nt.GetError(); f(false, errorMsg, "", data); return ret; } nt.SetRxCallback(this, ParserRecv); f(true, "", response, data); return st_ok; }