416 lines
9.7 KiB
C++
416 lines
9.7 KiB
C++
/*
|
|
* Copyright 2009 Kestrel Signal Processing, 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 "HLR.h"
|
|
#include <Logger.h>
|
|
#include <Threads.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <map>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
|
|
using namespace std;
|
|
|
|
|
|
/**
|
|
Not all systems include getline, so we provide our own.
|
|
@param fp A FILE* to read
|
|
@return a C string to be freed by the caller.
|
|
*/
|
|
char *getline(FILE *fp)
|
|
{
|
|
size_t bSize = 200;
|
|
unsigned i = 0;
|
|
char *buf = (char*)malloc(bSize);
|
|
while (true) {
|
|
char c = getc(fp);
|
|
// EOF?
|
|
if (feof(fp)) {
|
|
free(buf);
|
|
return NULL;
|
|
}
|
|
// EOL?
|
|
if (c=='\n') {
|
|
buf[i]='\0';
|
|
LOG(DEBUG) << "getline got: " << buf;
|
|
return buf;
|
|
}
|
|
buf[i++] = c;
|
|
// resize buffer?
|
|
if (i==bSize) {
|
|
bSize *= 2;
|
|
buf=(char*)realloc(buf,bSize);
|
|
if (!buf) {
|
|
LOG(ERROR) << "line too big for memory";
|
|
buf[i]='\0';
|
|
return buf;
|
|
}
|
|
}
|
|
}
|
|
// not reached
|
|
return NULL;
|
|
}
|
|
|
|
const HLR::Status HLR::CombinedStatus[4][4] = {
|
|
{SUCCESS,FAILURE,DELAYED,TRYAGAIN},
|
|
{FAILURE,FAILURE,FAILURE,FAILURE},
|
|
{DELAYED,DELAYED,DELAYED,DELAYED},
|
|
{TRYAGAIN,TRYAGAIN,TRYAGAIN,TRYAGAIN}
|
|
};
|
|
|
|
|
|
|
|
char *AsteriskHLR::getAsteriskLine(const char* command, const char* tag)
|
|
{
|
|
LOG(DEBUG) << "getAsteriskLine cmd=\"" << command << "\" tag=\"" << tag << "\"";
|
|
char fullCommand[100];
|
|
if (strlen(command)>100) {
|
|
LOG(ERROR) << "Asterisk command too long";
|
|
return NULL;
|
|
}
|
|
sprintf(fullCommand,"asterisk -rx \"%s\"", command);
|
|
FILE* asterisk = popen(fullCommand,"r");
|
|
if (!asterisk) {
|
|
LOG(ALARM) << "Asterisk call \"" << command << "\" failed";
|
|
return NULL;
|
|
}
|
|
while (!feof(asterisk)) {
|
|
char * line = getline(asterisk);
|
|
if (!line) break;
|
|
if (strstr(line,tag)) {
|
|
pclose(asterisk);
|
|
LOG(DEBUG) << "getAsteriskLine got: " << line;
|
|
return line;
|
|
}
|
|
free(line);
|
|
}
|
|
pclose(asterisk);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
char *AsteriskHLR::getIMSI(const char *ISDN)
|
|
{
|
|
if (!ISDN) {
|
|
LOG(WARN) << "AsteriskHLR::getIMSI attempting lookup of NULL IMSI";
|
|
return NULL;
|
|
}
|
|
reloadConfig();
|
|
char *cached = mIMSICache.read(ISDN);
|
|
if (cached) return cached;
|
|
|
|
char command[100];
|
|
sprintf(command,"dialplan show %s@sip-local", ISDN);
|
|
char *line = getAsteriskLine(command,ISDN);
|
|
// No line means the ISDN isn't resolvable in the dialplan.
|
|
if (!line) return NULL;
|
|
char *SIP = strstr(line,"SIP");
|
|
char *digits;
|
|
char *IMSI;
|
|
if (!SIP) goto badParse;
|
|
// A valid entry is 22-23 digits, and maybe some trailing chars.
|
|
if (strlen(SIP)<22) goto badParse;
|
|
// Skip "SIP".
|
|
digits = SIP+4;
|
|
// You can't just initialize this after the goto,
|
|
// at least on some compliers.
|
|
char *endp;
|
|
endp = strchr(digits,')');
|
|
if (!endp) goto badParse;
|
|
*endp = '\0';
|
|
IMSI = strdup(digits);
|
|
free(line);
|
|
mIMSICache.write(ISDN,IMSI);
|
|
return IMSI;
|
|
|
|
badParse:
|
|
// Getting here isn't always an error.
|
|
// It may just mean the number isn't in the registry.
|
|
LOG(DEBUG) << "AsteriskHLR cannot parse " << line;
|
|
free(line);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
char *AsteriskHLR::getCLIDLocal(const char* IMSI)
|
|
{
|
|
reloadConfig();
|
|
char *cached = mCLIDLocalCache.read(IMSI);
|
|
if (cached) return cached;
|
|
|
|
char command[100];
|
|
sprintf(command,"sip show user %s", IMSI);
|
|
char *line = getAsteriskLine(command,"Callerid");
|
|
// No line means the IMSI is not provisioned.
|
|
if (!line) return NULL;
|
|
// Isolate the string we need.
|
|
char *numberStart;
|
|
char *numberEnd;
|
|
char *CLID;
|
|
numberStart = strchr(line,'<');
|
|
if (!numberStart) goto badParse;
|
|
numberEnd = strchr(numberStart,'>');
|
|
if (!numberEnd) goto badParse;
|
|
*numberEnd = '\0';
|
|
CLID = strdup(numberStart+1);
|
|
free(line);
|
|
mCLIDLocalCache.write(IMSI,CLID);
|
|
return CLID;
|
|
|
|
// Handle errors here.
|
|
badParse:
|
|
LOG(ERROR) << "AsteriskHLR::getCLIDLocal cannot parse " << line;
|
|
free(line);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
char *AsteriskHLR::getCLIDGlobal(const char* IMSI)
|
|
{
|
|
reloadConfig();
|
|
char *cached = mCLIDGlobalCache.read(IMSI);
|
|
if (cached) return cached;
|
|
|
|
// FIXME
|
|
LOG(WARN) << "AsteriskHLR::getCLIDGlobal need to implement!!";
|
|
return strdup("883510001250000");
|
|
}
|
|
|
|
|
|
|
|
char *AsteriskHLR::mapCLIDGlobal(const char *local)
|
|
{
|
|
char *IMSI = getIMSI(local);
|
|
if (!IMSI) return NULL;
|
|
char *global = getCLIDGlobal(IMSI);
|
|
free(IMSI);
|
|
return global;
|
|
}
|
|
|
|
|
|
|
|
char *AsteriskHLR::getRegistrationIP(const char* IMSI)
|
|
{
|
|
char *cached = mRegistrationCache.read(IMSI);
|
|
if (cached) return cached;
|
|
|
|
char command[100];
|
|
sprintf(command,"database showkey SIP/Registry/%s", IMSI);
|
|
char *line = getAsteriskLine(command,IMSI);
|
|
// No line means the user isn't registered.
|
|
if (!line) return NULL;
|
|
|
|
// Find the first three colons
|
|
char *first;
|
|
char *second;
|
|
char *third;
|
|
char *IPString;
|
|
// : #1, start of IP #
|
|
first = strchr(line,':');
|
|
if (!first) goto badParse;
|
|
first++;
|
|
// Skip leading spaces
|
|
while (isspace(*first)) first++;
|
|
// : #2, start of port #
|
|
second = strchr(first+1,':');
|
|
if (!second) goto badParse;
|
|
// : #3, end of port #
|
|
third = strchr(second+1,':');
|
|
if (!third) goto badParse;
|
|
|
|
// Get the string we need
|
|
*third = '\0';
|
|
IPString = strdup(first);
|
|
free(line);
|
|
mRegistrationCache.write(IMSI,IPString,20);
|
|
return IPString;
|
|
|
|
// Handle errors here.
|
|
badParse:
|
|
LOG(ERROR) << "AsteriskHLR::getRegistrationIP cannot parse " << line;
|
|
free(line);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
HLR::Status AsteriskHLR::addUser(const char* IMSI, const char* CLID)
|
|
{
|
|
if (lockedConfig()) return TRYAGAIN;
|
|
// Open the config file.
|
|
static const char filename[] = "/etc/asterisk/sip.conf";
|
|
FILE *cf = fopen(filename,"a");
|
|
if (!cf) {
|
|
LOG(ALARM) << "AsteriskHLR::asddUser cannot open " << filename;
|
|
return HLR::FAILURE;
|
|
}
|
|
// The standard user template.
|
|
// FIXME -- This should somehow be configurable in real time.
|
|
time_t now = time(NULL);
|
|
fprintf(cf,";provisioned %s",ctime(&now));
|
|
fprintf(cf,"[%s]\n",IMSI);
|
|
fprintf(cf,"callerid=%s\n",CLID);
|
|
fprintf(cf,"canreinvite=no\ntype=friend\ncontext=sip-local\nallow=gsm\nhost=dynamic\ndtmfmode=info\n\n");
|
|
// All done.
|
|
fclose(cf);
|
|
// Reload the config.
|
|
mNeedSIPReload = true;
|
|
HLR::Status stat1 = reloadSIP();
|
|
// Go ahead and add the extension now, too.
|
|
HLR::Status stat2 = addAddress(IMSI,CLID);
|
|
|
|
return CombinedStatus[stat1][stat2];
|
|
}
|
|
|
|
|
|
HLR::Status AsteriskHLR::addAddress(const char* IMSI, const char* address)
|
|
{
|
|
if (lockedConfig()) return TRYAGAIN;
|
|
|
|
// extensions.conf needs to #include "extensions.local.conf"
|
|
|
|
// Open the config file.
|
|
static const char filename[] = "/etc/asterisk/extensions.local.conf";
|
|
FILE *cf = fopen(filename,"a");
|
|
if (!cf) {
|
|
LOG(ALARM) << "AsteriskHLR::asddAddress cannot open " << filename;
|
|
return FAILURE;
|
|
}
|
|
time_t now = time(NULL);
|
|
fprintf(cf,";provisioned %s",ctime(&now));
|
|
fprintf(cf,"exten => %s,1,Dial(SIP/%s)\n", address, IMSI);
|
|
fclose(cf);
|
|
// Reload the config.
|
|
mNeedDialplanReload = true;
|
|
return reloadDialplan();
|
|
}
|
|
|
|
|
|
|
|
HLR::Status AsteriskHLR::reloadSIP()
|
|
{
|
|
LOG(DEBUG) << "AsteriskHLR::reloadSIP needReload=" << mNeedSIPReload << " elapsed=" << mLastSIPReloadTime.elapsed();
|
|
if (!mNeedSIPReload) return SUCCESS;
|
|
if (mLastSIPReloadTime.elapsed()<1000*mHoldoffTime) return DELAYED;
|
|
if (system("asterisk -rx \"sip reload\"")) {
|
|
LOG(ALARM) << "AsteriskHLR::reloadSIP Asterisk call failed";
|
|
return FAILURE;
|
|
}
|
|
mLastSIPReloadTime.now();
|
|
mNeedSIPReload = false;
|
|
return SUCCESS;
|
|
}
|
|
|
|
|
|
HLR::Status AsteriskHLR::reloadDialplan()
|
|
{
|
|
LOG(DEBUG) << "AsteriskHLR::reloadDialplan needReload=" << mNeedDialplanReload << " elapsed=" << mLastDialplanReloadTime.elapsed();
|
|
if (!mNeedDialplanReload) return SUCCESS;
|
|
if (mLastDialplanReloadTime.elapsed()<1000*mHoldoffTime) return DELAYED;
|
|
if (system("asterisk -rx \"dialplan reload\"")) {
|
|
LOG(ALARM) << "AsteriskHLR::reloadDialplan Asterisk call failed";
|
|
return FAILURE;
|
|
}
|
|
mLastDialplanReloadTime.now();
|
|
mNeedDialplanReload = false;
|
|
return SUCCESS;
|
|
}
|
|
|
|
|
|
HLR::Status AsteriskHLR::reloadConfig()
|
|
{
|
|
return CombinedStatus[reloadSIP()][reloadDialplan()];
|
|
}
|
|
|
|
|
|
|
|
|
|
void HLRCache::write(const char* key, const char* value, unsigned lifetime)
|
|
{
|
|
mLock.lock();
|
|
if (mTable.size()>MaxSize) flush();
|
|
mTable[key] = HLRCacheEntry(value,lifetime);
|
|
mLock.unlock();
|
|
}
|
|
|
|
|
|
char* HLRCache::read(const char* key)
|
|
{
|
|
if (!key) return NULL;
|
|
char *retVal = NULL;
|
|
mLock.lock();
|
|
map<string,HLRCacheEntry>::iterator itr = mTable.find(key);
|
|
if (itr==mTable.end()) {
|
|
mLock.unlock();
|
|
return NULL;
|
|
}
|
|
if (itr!=mTable.end()) retVal = strdup(itr->second.value());
|
|
if (itr->second.expired()) {
|
|
mTable.erase(itr);
|
|
mLock.unlock();
|
|
return NULL;
|
|
}
|
|
mLock.unlock();
|
|
return retVal;
|
|
}
|
|
|
|
|
|
void HLRCache::flush()
|
|
{
|
|
// Discard expired entries.
|
|
// FIXME -- Implement this.
|
|
}
|
|
|
|
|
|
|
|
bool AsteriskHLR::lockedConfig()
|
|
{
|
|
// Return true if the lockfile exists.
|
|
struct stat dummy;
|
|
int s = stat("/etc/asterisk/HLR.lock",&dummy);
|
|
LOG(DEBUG) << "AsteriskHLR::lockedConfig stat=" << s;
|
|
return s==0;
|
|
}
|
|
|
|
|
|
bool AsteriskHLR::useGateway(const char* ISDN)
|
|
{
|
|
// FIXME -- Do something more general in Asterisk.
|
|
// This is a hack for Burning Man.
|
|
int cmp = strncmp(ISDN,"88351000125",11);
|
|
return cmp!=0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// vim: ts=4 sw=4
|