313 lines
8.7 KiB
C++
313 lines
8.7 KiB
C++
/**
|
|
* register.cpp
|
|
* This file is part of the YATE Project http://YATE.null.ro
|
|
*
|
|
* Ask for a registration from this module.
|
|
*
|
|
* Yet Another Telephony Engine - a fully featured software PBX and IVR
|
|
* Copyright (C) 2004 Null Team
|
|
*
|
|
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#include <telengine.h>
|
|
|
|
#include <stdio.h>
|
|
#include <libpq-fe.h>
|
|
|
|
using namespace TelEngine;
|
|
|
|
static PGconn *conn=0;
|
|
Mutex dbmutex;
|
|
|
|
static unsigned s_route_rq = 0;
|
|
static unsigned s_route_err = 0;
|
|
static unsigned s_route_yes = 0;
|
|
static unsigned s_route_no = 0;
|
|
|
|
class AuthHandler : public MessageHandler
|
|
{
|
|
public:
|
|
AuthHandler(const char *name)
|
|
: MessageHandler(name) { }
|
|
virtual bool received(Message &msg);
|
|
};
|
|
|
|
class RegistHandler : public MessageHandler
|
|
{
|
|
public:
|
|
RegistHandler(const char *name)
|
|
: MessageHandler(name),m_init(false) { }
|
|
virtual bool received(Message &msg);
|
|
bool init();
|
|
bool m_init;
|
|
};
|
|
|
|
class UnRegistHandler : public MessageHandler
|
|
{
|
|
public:
|
|
UnRegistHandler(const char *name)
|
|
: MessageHandler(name) { }
|
|
virtual bool received(Message &msg);
|
|
};
|
|
|
|
class RouteHandler : public MessageHandler
|
|
{
|
|
public:
|
|
RouteHandler(const char *name)
|
|
: MessageHandler(name) { }
|
|
virtual bool received(Message &msg);
|
|
};
|
|
|
|
class StatusHandler : public MessageHandler
|
|
{
|
|
public:
|
|
StatusHandler(const char *name, unsigned prio = 1)
|
|
: MessageHandler(name,prio) { }
|
|
virtual bool received(Message &msg);
|
|
};
|
|
/**
|
|
* I can't remeber why i have made this class :)
|
|
class RegistThread : public Thread
|
|
{
|
|
public:
|
|
RegistThread();
|
|
~RegistThread();
|
|
void run(void);
|
|
};
|
|
*/
|
|
class RegistPlugin : public Plugin
|
|
{
|
|
public:
|
|
RegistPlugin();
|
|
~RegistPlugin();
|
|
virtual void initialize();
|
|
private:
|
|
AuthHandler *m_authhandler;
|
|
RegistHandler *m_registhandler;
|
|
UnRegistHandler *m_unregisthandler;
|
|
RouteHandler *m_routehandler;
|
|
StatusHandler *m_statushandler;
|
|
};
|
|
|
|
bool AuthHandler::received(Message &msg)
|
|
{
|
|
// const char *calltime = c_safe(msg.getValue("time"));
|
|
String username = c_safe(msg.getValue("username"));
|
|
|
|
Lock lock(dbmutex);
|
|
if (!conn)
|
|
return false;
|
|
|
|
String s = "SELECT password FROM register WHERE username='" + username + "'";
|
|
PGresult *respgsql = PQexec(conn,(const char *)s);
|
|
if (!respgsql || PQresultStatus(respgsql) != PGRES_TUPLES_OK)
|
|
{
|
|
Debug(DebugFail,"Failed to query from database: %s",
|
|
PQerrorMessage(conn));
|
|
return false;
|
|
}
|
|
if (PQntuples(respgsql) == 0) {
|
|
Debug(DebugFail,"No user.");
|
|
return false;
|
|
}
|
|
msg.retValue() << PQgetvalue(respgsql,0,0);
|
|
return true;
|
|
};
|
|
|
|
bool RegistHandler::init()
|
|
{
|
|
/**
|
|
* We must clear the routing table when loading the new table, to not
|
|
* leave any garbage there
|
|
*/
|
|
String s = "DELETE FROM routepaid";
|
|
PGresult *respgsql = PQexec(conn,(const char *)s);
|
|
if (PQresultStatus(respgsql) != PGRES_COMMAND_OK)
|
|
{
|
|
Debug(DebugFail,"Failed to clear the routepaid table: %s",
|
|
PQerrorMessage(conn));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool RegistHandler::received(Message &msg)
|
|
{
|
|
if (!m_init)
|
|
{
|
|
init();
|
|
m_init= true;
|
|
}
|
|
String username = c_safe(msg.getValue("username"));
|
|
String techno = c_safe(msg.getValue("techno"));
|
|
String data = c_safe(msg.getValue("data"));
|
|
|
|
Lock lock(dbmutex);
|
|
if (!conn)
|
|
return false;
|
|
|
|
String c = "SELECT credit,price,e164,context FROM register WHERE username='" + username + "'";
|
|
PGresult *respgsql = PQexec(conn,(const char *)c);
|
|
if (!respgsql || PQresultStatus(respgsql) != PGRES_TUPLES_OK)
|
|
{
|
|
Debug(DebugFail,"Failed to query from database: %s",
|
|
PQerrorMessage(conn));
|
|
return false;
|
|
}
|
|
if (PQntuples(respgsql) == 0) {
|
|
Debug(DebugFail,"No credit.");
|
|
return false;
|
|
}
|
|
|
|
String price = PQgetvalue(respgsql,0,1);
|
|
String prefix = PQgetvalue(respgsql,0,2);
|
|
String context = PQgetvalue(respgsql,0,3);
|
|
if (price.null())
|
|
price = 0;
|
|
if (context.null())
|
|
context = "default";
|
|
|
|
c = "INSERT INTO routepaid (context,prefix,tehno,data,price,username) VALUES ('" + context + "','" + prefix + "','" + techno + "','" + data + "'," + price +",'" + username + "')";
|
|
|
|
PGresult *respgsql1 = PQexec(conn,(const char *)c);
|
|
if (!respgsql1 || PQresultStatus(respgsql1) != PGRES_COMMAND_OK)
|
|
Debug(DebugFail,"Failed to insert in database: %s",
|
|
PQerrorMessage(conn));
|
|
msg.retValue() = prefix;
|
|
return true;
|
|
};
|
|
|
|
bool UnRegistHandler::received(Message &msg)
|
|
{
|
|
String username = c_safe(msg.getValue("username"));
|
|
|
|
Lock lock(dbmutex);
|
|
if (!conn)
|
|
return false;
|
|
|
|
String s = "DELETE from routepaid WHERE username='" + username + "'";
|
|
PGresult *respgsql = PQexec(conn,(const char *)s);
|
|
if (PQresultStatus(respgsql) != PGRES_COMMAND_OK)
|
|
{
|
|
Debug(DebugFail,"Failed to query from database: %s",
|
|
PQerrorMessage(conn));
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
bool RouteHandler::received(Message &msg)
|
|
{
|
|
unsigned long long tmr = Time::now();
|
|
String called(msg.getValue("called"));
|
|
if (called.null())
|
|
return false;
|
|
Lock lock(dbmutex);
|
|
if (!conn)
|
|
return false;
|
|
s_route_rq++;
|
|
String context = c_safe(msg.getValue("context","default"));
|
|
String s = "SELECT tehno,data,length (prefix) as lll,price"
|
|
" from routepaid where prefix= substring('" + called + "',1,length(prefix))"
|
|
" and context='" + context + "' order by lll desc LIMIT 1";
|
|
Debug(DebugInfo,"%s",s.c_str());
|
|
PGresult *respgsql = PQexec(conn,(const char *)s);
|
|
if (!respgsql || PQresultStatus(respgsql) != PGRES_TUPLES_OK)
|
|
{
|
|
Debug(DebugFail,"Failed to query from database: %s",
|
|
PQerrorMessage(conn));
|
|
s_route_err++;
|
|
return false;
|
|
}
|
|
if (PQntuples(respgsql) == 0) {
|
|
Debug(DebugFail,"No route.");
|
|
s_route_no++;
|
|
return false;
|
|
}
|
|
msg.retValue() = String(PQgetvalue(respgsql,0,1));
|
|
Debug(DebugInfo,"Routing call to '%s' in context '%s' using '%s' tehnology and data in %llu usec",
|
|
called.c_str(),context.c_str(),msg.retValue().c_str(),Time::now()-tmr);
|
|
s_route_yes++;
|
|
return true;
|
|
};
|
|
|
|
bool StatusHandler::received(Message &msg)
|
|
{
|
|
msg.retValue() << "name=register,type=misc;conn=" << (conn != 0) <<"\n";
|
|
return false;
|
|
}
|
|
|
|
RegistPlugin::RegistPlugin()
|
|
: m_authhandler(0),m_registhandler(0),m_routehandler(0),m_statushandler(0)
|
|
{
|
|
Output("Loaded module Registration");
|
|
}
|
|
|
|
RegistPlugin::~RegistPlugin()
|
|
{
|
|
if (conn) {
|
|
PQfinish(conn);
|
|
conn = 0;
|
|
}
|
|
}
|
|
|
|
void RegistPlugin::initialize()
|
|
{
|
|
char *pgoptions=NULL, *pgtty=NULL;
|
|
Output("Initializing module Register for PostgreSQL");
|
|
Configuration cfg(Engine::configFile("register"));
|
|
const char *pghost = c_safe(cfg.getValue("general","host","localhost"));
|
|
const char *pgport = c_safe(cfg.getValue("general","port","5432"));
|
|
const char *dbName = c_safe(cfg.getValue("general","database","yate"));
|
|
const char *dbUser = c_safe(cfg.getValue("general","user","postgres"));
|
|
const char *dbPass = c_safe(cfg.getValue("general","password"));
|
|
|
|
Lock lock(dbmutex);
|
|
if (conn)
|
|
PQfinish(conn);
|
|
conn = PQsetdbLogin(pghost,pgport,pgoptions,pgtty,dbName,dbUser,dbPass);
|
|
if (PQstatus(conn) == CONNECTION_BAD) {
|
|
Debug(DebugFail, "Connection to database '%s' failed.", dbName);
|
|
Debug(DebugFail, "%s", PQerrorMessage(conn));
|
|
PQfinish(conn);
|
|
conn = 0;
|
|
return;
|
|
}
|
|
if (!m_registhandler) {
|
|
Output("Installing Registering handler");
|
|
Engine::install(m_registhandler = new RegistHandler("user.register"));
|
|
}
|
|
if (!m_unregisthandler) {
|
|
Output("Installing UnRegistering handler");
|
|
Engine::install(m_unregisthandler = new UnRegistHandler("user.unregister"));
|
|
}
|
|
if (!m_authhandler) {
|
|
Output("Installing Authentification handler");
|
|
Engine::install(m_authhandler = new AuthHandler("user.auth"));
|
|
}
|
|
if (!m_routehandler) {
|
|
Output("Installing Route handler");
|
|
Engine::install(m_routehandler = new RouteHandler("call.route"));
|
|
}
|
|
if (!m_statushandler) {
|
|
Output("Installing Status handler");
|
|
Engine::install(m_statushandler = new StatusHandler("engine.status"));
|
|
}
|
|
}
|
|
|
|
INIT_PLUGIN(RegistPlugin);
|
|
/* vi: set ts=8 sw=4 sts=4 noet: */
|