PentHertz
/
subscriberRegistry
mirror of https://github.com/PentHertz/subscriberRegistry.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
subscriberRegistry/SubscriberRegistry.cpp

763 lines
22 KiB
C++
Raw Permalink Blame History

/*
* Copyright 2011 Kestrel Signal Processing, Inc.
* Copyright 2011, 2012, 2013, 2014 Range Networks, Inc.
*
* This software is distributed under the terms of the GNU Affero Public License.
* See the COPYING file in the main directory for details.
*
* This use of this software may be subject to additional restrictions.
* See the LEGAL file in the main directory for details.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "SubscriberRegistry.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "sqlite3.h"
#include <iostream>
#include <sstream>
#include <fstream>
#include <algorithm> // for sort()
#include <Configuration.h>
extern ConfigurationTable gConfig;
using namespace std;
static const char* createRRLPTable = {
"CREATE TABLE IF NOT EXISTS RRLP ("
"id INTEGER PRIMARY KEY, "
"name VARCHAR(80) not null, "
"latitude real not null, "
"longitude real not null, "
"error real not null, "
"time text not null "
")"
};
static const char* createDDTable = {
"CREATE TABLE IF NOT EXISTS DIALDATA_TABLE ("
"id INTEGER PRIMARY KEY, "
"exten VARCHAR(40) NOT NULL DEFAULT '', "
"dial VARCHAR(128) NOT NULL DEFAULT '' "
")"
};
static const char* createRateTable = {
"create table if not exists rates (service varchar(30) not null, rate integer not null)"
};
static const char* createSBTable = {
"CREATE TABLE IF NOT EXISTS SIP_BUDDIES ("
"id integer primary key, "
"name VARCHAR(80) not null, "
"context VARCHAR(80), "
"callingpres VARCHAR(30) DEFAULT 'allowed_not_screened', "
"deny VARCHAR(95), "
"permit VARCHAR(95), "
"secret VARCHAR(80), "
"md5secret VARCHAR(80), "
"remotesecret VARCHAR(250), "
"transport VARCHAR(10), "
"host VARCHAR(31) default '' not null, "
"nat VARCHAR(5) DEFAULT 'no' not null, "
"type VARCHAR(10) DEFAULT 'friend' not null, "
"accountcode VARCHAR(20), "
"amaflags VARCHAR(13), "
"callgroup VARCHAR(10), "
"callerid VARCHAR(80), "
"defaultip VARCHAR(40) DEFAULT '0.0.0.0', "
"dtmfmode VARCHAR(7) DEFAULT 'info', "
"fromuser VARCHAR(80), "
"fromdomain VARCHAR(80), "
"insecure VARCHAR(4), "
"language CHAR(2), "
"mailbox VARCHAR(50), "
"pickupgroup VARCHAR(10), "
"qualify CHAR(3), "
"regexten VARCHAR(80), "
"rtptimeout CHAR(3), "
"rtpholdtimeout CHAR(3), "
"setvar VARCHAR(100), "
"disallow VARCHAR(100) DEFAULT 'all', "
"allow VARCHAR(100) DEFAULT 'gsm' not null, "
"fullcontact VARCHAR(80), "
"ipaddr VARCHAR(45), "
"port int(5) DEFAULT 5062, "
"username VARCHAR(80), "
"defaultuser VARCHAR(80), "
"subscribecontext VARCHAR(80), "
"directmedia VARCHAR(3), "
"trustrpid VARCHAR(3), "
"sendrpid VARCHAR(3), "
"progressinband VARCHAR(5), "
"promiscredir VARCHAR(3), "
"useclientcode VARCHAR(3), "
"callcounter VARCHAR(3), "
"busylevel int(11) default 1, "
"allowoverlap VARCHAR(3) DEFAULT 'no', "
"allowsubscribe VARCHAR(3) DEFAULT 'no', "
"allowtransfer VARCHAR(3) DEFAULT 'no', "
"ignoresdpversion VARCHAR(3) DEFAULT 'no', "
"template VARCHAR(100), "
"videosupport VARCHAR(6) DEFAULT 'no', "
"maxcallbitrate int(11), "
"rfc2833compensate VARCHAR(3) DEFAULT 'yes', "
"'session-timers' VARCHAR(10) DEFAULT 'accept', "
"'session-expires' int(6) DEFAULT 1800, "
"'session-minse' int(6) DEFAULT 90, "
"'session-refresher' VARCHAR(3) DEFAULT 'uas', "
"t38pt_usertpsource VARCHAR(3), "
"outboundproxy VARCHAR(250), "
"callbackextension VARCHAR(250), "
"registertrying VARCHAR(3) DEFAULT 'yes', "
"timert1 int(6) DEFAULT 500, "
"timerb int(9), "
"qualifyfreq int(6) DEFAULT 120, "
"contactpermit VARCHAR(250), "
"contactdeny VARCHAR(250), "
"lastms int(11) DEFAULT 0 not null, "
"regserver VARCHAR(100), "
"regseconds int(11) DEFAULT 0 not null, "
"useragent VARCHAR(100), "
"cancallforward CHAR(3) DEFAULT 'yes' not null, "
"canreinvite CHAR(3) DEFAULT 'no' not null, "
"mask VARCHAR(95), "
"musiconhold VARCHAR(100), "
"restrictcid CHAR(3), "
"calllimit int(5) default 1, "
"WhiteListFlag timestamp not null default '0', "
"WhiteListCode varchar(8) not null default '0', "
"rand varchar(33) default '', "
"sres varchar(33) default '', "
"ki varchar(33) default '', "
"kc varchar(33) default '', "
"prepaid int(1) DEFAULT 0 not null, " // flag to indicate prepaid customer
"account_balance int(9) default 0 not null, " // current account, neg is debt, pos is credit
"RRLPSupported int(1) default 1 not null, "
"hardware VARCHAR(20), "
"regTime INTEGER default 0 NOT NULL, " // Unix time of most recent registration
"a3_a8 varchar(45) default NULL"
")"
};
static const char* createMEMSBTable = {
"CREATE TABLE IF NOT EXISTS memcache.mem_sip_buddies ("
"username varchar(80) primary key, "
"ipaddr varchar(45), "
"port int(5) default 5062, "
"rand varchar(33) default '', "
"sres varchar(33) default ''"
")"
};
int SubscriberRegistry::init()
{
string ldb = gConfig.getStr("SubscriberRegistry.db");
size_t p = ldb.find_last_of('/');
if (p == string::npos) {
LOG(EMERG) << "SubscriberRegistry.db not in a directory?";
mDB = NULL;
return 1;
}
string dir = ldb.substr(0, p);
struct stat buf;
if (stat(dir.c_str(), &buf)) {
LOG(EMERG) << dir << " does not exist";
mDB = NULL;
return 1;
}
mNumSQLTries=gConfig.getNum("Control.NumSQLTries");
int rc = sqlite3_open(ldb.c_str(),&mDB);
if (rc) {
LOG(EMERG) << "Cannot open SubscriberRegistry database: " << ldb << " error: " << sqlite3_errmsg(mDB);
sqlite3_close(mDB);
mDB = NULL;
return 1;
}
if (!sqlite3_command(mDB,createRRLPTable,mNumSQLTries)) {
LOG(EMERG) << "Cannot create RRLP table";
return 1;
}
if (!sqlite3_command(mDB,createDDTable,mNumSQLTries)) {
LOG(EMERG) << "Cannot create DIALDATA_TABLE table";
return 1;
}
if (!sqlite3_command(mDB,createRateTable,mNumSQLTries)) {
LOG(EMERG) << "Cannot create rate table";
return 1;
}
if (!sqlite3_command(mDB,createSBTable,mNumSQLTries)) {
LOG(EMERG) << "Cannot create SIP_BUDDIES table";
return 1;
}
// Set high-concurrency WAL mode.
if (!sqlite3_command(mDB,enableWAL,mNumSQLTries)) {
LOG(EMERG) << "Cannot enable WAL mode on database at " << ldb << ", error message: " << sqlite3_errmsg(mDB);
}
#ifndef SR_API_ONLY
// memory based sip_buddies table
if (!sqlite3_command(mDB,"attach database ':memory:' as memcache",mNumSQLTries)) {
LOG(EMERG) << "Cannot create memcache database";
return 1;
}
if (!sqlite3_command(mDB,createMEMSBTable,mNumSQLTries)) {
LOG(EMERG) << "Cannot create memcache mem_sip_buddies table";
return 1;
}
if (!sqlite3_command(mDB,"INSERT INTO mem_sip_buddies SELECT username, ipaddr, port, rand, sres FROM sip_buddies",mNumSQLTries)) {
LOG(EMERG) << "Cannot populate mem_sip_buddies table with disk contents";
return 1;
}
if (!sqlite3_command(mDB,"ALTER TABLE mem_sip_buddies ADD dirty INTEGER DEFAULT 0",mNumSQLTries)) {
LOG(EMERG) << "Cannot add dirty column to mem_sip_buddies table";
return 1;
}
// Start the sync thread
mSyncer.start((void*(*)(void*))subscriberRegistrySyncer,NULL);
#endif
return 0;
}
string SubscriberRegistry::getResultsAsString(string query)
{
sqlite3_stmt *stmt;
if (sqlite3_prepare_statement(mDB, &stmt, query.c_str(), 5)) {
std::cout << " - sqlite3_prepare_statement() failed" << std::endl;
return "";
}
int state;
int row = 0;
int col;
int colMax = sqlite3_column_count(stmt);
const char* colName;
const char* colText;
ostringstream colNames;
ostringstream colTexts;
while (1) {
state = sqlite3_step(stmt);
if (state == SQLITE_ROW) {
for (col = 0; col < colMax; col++) {
colName = (const char*)sqlite3_column_name(stmt, col);
colText = (const char*)sqlite3_column_text(stmt, col);
if (row == 0) {
colNames << colName << " ";
}
if (colText == NULL) {
colTexts << "NULL" << " ";
} else {
colTexts << colText << " ";
}
}
} else if (state == SQLITE_DONE) {
break;
// TODO : handle more SQLITE_FAILURECODES here
} else {
return " - failed in while(1) in } else {";
}
colTexts << std::endl;
row++;
}
sqlite3_finalize(stmt);
ostringstream s;
string title = colNames.str();
if (title.length()) {
s << title << std::endl;
s << colTexts << std::endl;
} else {
s << " - none found" << std::endl;
}
return s.str();
}
vector<string> SubscriberRegistry::getTableColumns(string tableName)
{
vector<string> colNames;
stringstream tmp;
tmp << "select * from " << tableName << " limit 1";
sqlite3_stmt *stmt;
if (sqlite3_prepare_statement(mDB, &stmt, tmp.str().c_str(), 5)) {
std::cout << " - getTableColumns() - sqlite3_prepare_statement() failed" << std::endl;
return colNames;
}
tmp.str("");
int state;
int col;
int colMax = sqlite3_column_count(stmt);
while (1) {
state = sqlite3_step(stmt);
if (state == SQLITE_ROW) {
for (col = 0; col < colMax; col++) {
tmp << (const char*)sqlite3_column_name(stmt, col);
colNames.push_back(tmp.str());
tmp.str("");
}
} else if (state == SQLITE_DONE) {
break;
// TODO : handle more SQLITE_FAILURECODES here
} else {
std::cout << " - getTableColumns() - failed in while(1) in } else {" << std::endl;
return colNames;
}
}
sqlite3_finalize(stmt);
return colNames;
}
#ifndef SR_API_ONLY
string SubscriberRegistry::generateSyncToDiskQuery()
{
vector<string> columns = getTableColumns("sip_buddies");
if (!columns.size()) {
LOG(DEBUG) << "sip_buddies is empty";
return "";
}
sort(columns.begin(), columns.end());
std::stringstream ss;
unsigned i;
ss << "replace into sip_buddies (ipaddr, port, rand, sres, ";
for (i = 0; i < columns.size(); i++) {
if (columns[i].compare("ipaddr") == 0 || columns[i].compare("port") == 0 ||
columns[i].compare("rand") == 0 || columns[i].compare("sres") == 0) {
continue;
}
if (i != 0) {
ss << ", ";
}
if (columns[i].find("-") != std::string::npos) {
ss << "'" << columns[i] << "'";
} else {
ss << columns[i];
}
}
ss << ") select src.ipaddr, src.port, src.rand, src.sres, ";
for (i = 0; i < columns.size(); i++) {
if (columns[i].compare("ipaddr") == 0 || columns[i].compare("port") == 0 ||
columns[i].compare("rand") == 0 || columns[i].compare("sres") == 0) {
continue;
}
if (i != 0) {
ss << ", ";
}
ss << "dest.";
if (columns[i].find("-") != std::string::npos) {
ss << "'" << columns[i] << "'";
} else {
ss << columns[i];
}
}
ss << " from mem_sip_buddies src ";
ss << "inner join sip_buddies dest on src.username = dest.username ";
ss << "where src.dirty = \"1\"";
return ss.str();
}
bool SubscriberRegistry::syncMemoryDB()
{
bool ret = true;
string syncToDisk = generateSyncToDiskQuery();
string cleanDirty = "update mem_sip_buddies set dirty = \"0\"";
string syncFromDiskAddNewEntries = "INSERT INTO mem_sip_buddies "
"(username, ipaddr, port, rand, sres, dirty) "
"SELECT sip_buddies.username, sip_buddies.ipaddr, sip_buddies.port, sip_buddies.rand, sip_buddies.sres, '0' FROM sip_buddies "
"LEFT OUTER JOIN mem_sip_buddies ON (mem_sip_buddies.username=sip_buddies.username) "
"WHERE mem_sip_buddies.username IS NULL";
string syncFromDiskDeleteOldEntries = "DELETE FROM mem_sip_buddies "
"WHERE username IN "
"(SELECT mem_sip_buddies.username FROM mem_sip_buddies"
" LEFT JOIN sip_buddies ON mem_sip_buddies.username=sip_buddies.username"
" WHERE sip_buddies.username IS NULL"
")";
Timeval timer;
mLock.lock();
// this string is only non-empty if there are entries in sip_buddies
if (syncToDisk.length()) {
// sync dirty entries to disk
if (sqlUpdate(syncToDisk.c_str()) == FAILURE) {
LOG(ERR) << "syncToDisk failed";
} else {
// if it succeeds, mark these entries as clean again
LOG(INFO) << "syncToDisk succeeded";
if (sqlUpdate(cleanDirty.c_str()) == FAILURE) {
LOG(ERR) << "cleanDirty failed";
} else {
LOG(INFO) << "cleanDirty succeeded";
}
}
// sync new rows from the disk into memory
if (sqlUpdate(syncFromDiskAddNewEntries.c_str()) == FAILURE) {
LOG(ERR) << "syncFromDiskAddNewEntries failed";
} else {
LOG(INFO) << "syncFromDiskAddNewEntries succeeded";
}
}
// delete old entries from memory no longer found on the disk
if (sqlUpdate(syncFromDiskDeleteOldEntries.c_str()) == FAILURE) {
LOG(ERR) << "syncFromDiskDeleteOldEntries failed";
} else {
LOG(INFO) << "syncFromDiskDeleteOldEntries succeeded";
}
mLock.unlock();
LOG(INFO) << "syncMemoryDB() locked the db for " << timer.elapsed() << "ms";
return ret;
}
#endif
SubscriberRegistry::~SubscriberRegistry()
{
if (mDB) sqlite3_close(mDB);
}
SubscriberRegistry::Status SubscriberRegistry::sqlLocal(const char *query, char **resultptr)
{
LOG(INFO) << query;
if (!resultptr) {
if (!sqlite3_command(db(), query, mNumSQLTries)) return FAILURE;
return SUCCESS;
}
sqlite3_stmt *stmt;
if (sqlite3_prepare_statement(db(), &stmt, query, mNumSQLTries)) {
LOG(ERR) << "sqlite3_prepare_statement problem with query \"" << query << "\"";
return FAILURE;
}
int src = sqlite3_run_query(db(), stmt, mNumSQLTries);
if (src != SQLITE_ROW) {
sqlite3_finalize(stmt);
return FAILURE;
}
char *column = (char*)sqlite3_column_text(stmt, 0);
if (!column) {
LOG(ERR) << "Subscriber registry returned a NULL column.";
sqlite3_finalize(stmt);
return FAILURE;
}
*resultptr = strdup(column);
sqlite3_finalize(stmt);
return SUCCESS;
}
char *SubscriberRegistry::sqlQuery(const char *unknownColumn, const char *table, const char *knownColumn, const char *knownValue)
{
char *result = NULL;
SubscriberRegistry::Status st;
ostringstream os;
os << "select " << unknownColumn << " from " << table << " where " << knownColumn << " = \"" << knownValue << "\"";
// try to find locally
st = sqlLocal(os.str().c_str(), &result);
if ((st == SUCCESS) && result) {
// got it. return it.
LOG(INFO) << "result = " << result;
return result;
}
// didn't find locally
LOG(INFO) << "not found: " << os.str();
return NULL;
}
/*
* Check for two of the same values for a single unknown
*/
char *SubscriberRegistry::sqlQuery2(const char *unknownColumn, const char *table, const char *knownColumn, const char *knownValue1, const char *knownValue2)
{
char *result = NULL;
SubscriberRegistry::Status st;
ostringstream os;
// select knownValue from table where knownColumn IN ('knownValue1', 'knownValue2')
os << "select " << unknownColumn << " from " << table << " where " << knownColumn << " IN (\'"
<< knownValue1 << "\', " << "\'" << knownValue2 << "\')";
//LOG(INFO) << "QUERY STRING = " << os.str().c_str();
// try to find locally
st = sqlLocal(os.str().c_str(), &result);
if ((st == SUCCESS) && result) {
// got it. return it.
LOG(INFO) << "result = " << result;
return result;
}
// didn't find locally
LOG(INFO) << "not found: " << os.str();
return NULL;
}
SubscriberRegistry::Status SubscriberRegistry::sqlUpdate(const char *stmt)
{
LOG(INFO) << stmt;
return sqlLocal(stmt, NULL);
}
string SubscriberRegistry::imsiGet(string imsi, string key)
{
string name = imsi.substr(0,4) == "IMSI" ? imsi : "IMSI" + imsi;
char *st = sqlQuery(key.c_str(), "sip_buddies", "username", name.c_str());
if (!st) {
LOG(INFO) << "cannot get key " << key << " for username " << name;
return "";
}
return st;
}
#ifndef SR_API_ONLY
bool SubscriberRegistry::imsiSet(string imsi, string key, string value)
{
string name = imsi.substr(0,4) == "IMSI" ? imsi : "IMSI" + imsi;
ostringstream os;
os << "update mem_sip_buddies set dirty = \"1\", " << key << " = \"" << value << "\" where username = \"" << name << "\"";
mLock.lock();
SubscriberRegistry::Status ret = sqlUpdate(os.str().c_str());
mLock.unlock();
return ret == FAILURE;
}
bool SubscriberRegistry::imsiSet(string imsi, string key1, string value1, string key2, string value2)
{
string name = imsi.substr(0,4) == "IMSI" ? imsi : "IMSI" + imsi;
ostringstream os;
os << "update mem_sip_buddies set dirty = \"1\", " << key1 << " = \"" << value1 << "\"," << key2 << " = \"" << value2 << "\" where username = \"" << name << "\"";
mLock.lock();
SubscriberRegistry::Status ret = sqlUpdate(os.str().c_str());
mLock.unlock();
return ret == FAILURE;
}
#endif
/*
* Get IMSI from phone number
* Should be able to get rid of this one
*/
char *SubscriberRegistry::getIMSI(const char *ISDN)
{
if (!ISDN) {
LOG(WARNING) << "SubscriberRegistry::getIMSI attempting lookup of NULL ISDN";
return NULL;
}
LOG(INFO) << "getIMSI(" << ISDN << ")";
return sqlQuery("dial", "dialdata_table", "exten", ISDN);
}
/*
* This version handle phone number with or without a plus at the beginning
* This should work for all uses of getIMSI
*
*/
char *SubscriberRegistry::getIMSI2(const char *ISDN)
{
if (!ISDN) {
LOG(WARNING) << "SubscriberRegistry::getIMSI2 attempting lookup of NULL ISDN";
return NULL;
}
LOG(INFO) << "getIMSI2(" << ISDN << ")";
char* str2;
char localstr[50];
if (ISDN[0] == '+') {
str2 = (char *) &ISDN[1]; // ISDN has plus remove plus for str2
} else {
// ISDN no plus add plus to str2
strcpy(&localstr[0], "+");
strncat(localstr, ISDN, sizeof(localstr)-1);
localstr[sizeof(localstr)-1] = 0;
str2 = localstr;
}
// Two strings one with plus one without
return sqlQuery2("dial", "dialdata_table", "exten", ISDN, (const char*) str2);
}
char *SubscriberRegistry::getCLIDLocal(const char* IMSI)
{
if (!IMSI) {
LOG(WARNING) << "SubscriberRegistry::getCLIDLocal attempting lookup of NULL IMSI";
return NULL;
}
LOG(INFO) << "getCLIDLocal(" << IMSI << ")";
return sqlQuery("callerid", "sip_buddies", "username", IMSI);
}
char *SubscriberRegistry::getCLIDGlobal(const char* IMSI)
{
if (!IMSI) {
LOG(WARNING) << "SubscriberRegistry::getCLIDGlobal attempting lookup of NULL IMSI";
return NULL;
}
LOG(INFO) << "getCLIDGlobal(" << IMSI << ")";
return sqlQuery("callerid", "sip_buddies", "username", IMSI);
}
char *SubscriberRegistry::getRegistrationIP(const char* IMSI)
{
if (!IMSI) {
LOG(WARNING) << "SubscriberRegistry::getRegistrationIP attempting lookup of NULL IMSI";
return NULL;
}
LOG(INFO) << "getRegistrationIP(" << IMSI << ")";
return sqlQuery("ipaddr", "sip_buddies", "username", IMSI);
}
SubscriberRegistry::Status SubscriberRegistry::setRegTime(const char* IMSI)
{
if (!IMSI) {
LOG(WARNING) << "SubscriberRegistry::setRegTime attempting set for NULL IMSI";
return FAILURE;
}
unsigned now = (unsigned)time(NULL);
ostringstream os;
os << "update sip_buddies set regTime = " << now << " where username = " << '"' << IMSI << '"';
return sqlUpdate(os.str().c_str());
}
SubscriberRegistry::Status SubscriberRegistry::addUser(const char* IMSI, const char* CLID)
{
if (!IMSI) {
LOG(WARNING) << "SubscriberRegistry::addUser attempting add of NULL IMSI";
return FAILURE;
}
if (!CLID) {
LOG(WARNING) << "SubscriberRegistry::addUser attempting add of NULL CLID";
return FAILURE;
}
LOG(INFO) << "addUser(" << IMSI << "," << CLID << ")";
ostringstream os;
os << "insert into sip_buddies (name, username, type, context, host, callerid, canreinvite, allow, dtmfmode, ipaddr, port) values (";
os << "\"" << IMSI << "\"";
os << ",";
os << "\"" << IMSI << "\"";
os << ",";
os << "\"" << "friend" << "\"";
os << ",";
os << "\"" << "phones" << "\"";
os << ",";
os << "\"" << "dynamic" << "\"";
os << ",";
os << "\"" << CLID << "\"";
os << ",";
os << "\"" << "no" << "\"";
os << ",";
os << "\"" << "gsm" << "\"";
os << ",";
os << "\"" << "info" << "\"";
os << ",";
os << "\"" << "127.0.0.1" << "\"";
os << ",";
os << "\"" << "5062" << "\"";
os << ")";
os << ";";
SubscriberRegistry::Status st = sqlUpdate(os.str().c_str());
ostringstream os2;
os2 << "insert into dialdata_table (exten, dial) values (";
os2 << "\"" << CLID << "\"";
os2 << ",";
os2 << "\"" << IMSI << "\"";
os2 << ")";
SubscriberRegistry::Status st2 = sqlUpdate(os2.str().c_str());
return st == SUCCESS && st2 == SUCCESS ? SUCCESS : FAILURE;
}
char *SubscriberRegistry::mapCLIDGlobal(const char *local)
{
if (!local) {
LOG(WARNING) << "SubscriberRegistry::mapCLIDGlobal attempting lookup of NULL local";
return NULL;
}
LOG(INFO) << "mapCLIDGlobal(" << local << ")";
char *IMSI = getIMSI2(local);
if (!IMSI) return NULL;
char *global = getCLIDGlobal(IMSI);
free(IMSI);
return global;
}
SubscriberRegistry::Status SubscriberRegistry::RRLPUpdate(string name, string lat, string lon, string err){
ostringstream os;
os << "insert into RRLP (name, latitude, longitude, error, time) values (" <<
'"' << name << '"' << "," <<
lat << "," <<
lon << "," <<
err << "," <<
"datetime('now')"
")";
LOG(INFO) << os.str();
return sqlUpdate(os.str().c_str());
}
#ifndef SR_API_ONLY
extern SubscriberRegistry gSubscriberRegistry;
void* subscriberRegistrySyncer(void*)
{
while (true) {
sleep(15);
gSubscriberRegistry.syncMemoryDB();
}
return NULL;
}
#endif
// vim: ts=4 sw=4
Reference in New Issue View Git Blame Copy Permalink