void UtlHashMap::copyInto(UtlHashMap& into) const
{
UtlHashMapIterator i(*this);
while (i() != NULL)
{
into.insertKeyAndValue(i.key(), i.value());
}
}
void
PermissionDB::getIdentities (
const UtlString& permission,
ResultSet& rResultSet ) const
{
// This should erase the contents of the existing resultset
rResultSet.destroyAll();
if ( !permission.isNull() && (m_pFastDB != NULL) )
{
// Thread Local Storage
m_pFastDB->attach();
dbQuery query;
// Primary Key is the uriPermission's identity
query="permission=", permission;
// Search to see if we have a Credential Row
dbCursor< PermissionRow > cursor;
if ( cursor.select(query) > 0 )
{
do {
UtlHashMap record;
UtlString* identityValue =
new UtlString ( cursor->identity );
UtlString* permissionValue =
new UtlString ( cursor->permission );
// Memory Leak fixes, make shallow copies of static keys
UtlString* identityKey = new UtlString( gIdentityKey );
UtlString* permissionKey = new UtlString( gPermissionKey );
record.insertKeyAndValue (
identityKey, identityValue );
record.insertKeyAndValue (
permissionKey, permissionValue );
rResultSet.addValue(record);
} while ( cursor.next() );
}
// Commit the rows to memory - multiprocess workaround
m_pFastDB->detach(0);
}
}
void
UserLocationDB::getLocations (
const UtlString& identityString,
ResultSet& rResultSet ) const
{
// This should erase the contents of the existing resultset
rResultSet.clear();
if ( !identityString.isNull() && ( m_pFastDB != NULL) )
{
// Thread Local Storage
m_pFastDB->attach();
dbQuery query;
query="identity=",identityString;
// Search to see if we have a Credential Row
dbCursor< UserLocationRow > cursor;
if ( cursor.select(query) > 0 )
{
do {
UtlHashMap record;
UtlString* identityValue =
new UtlString ( cursor->identity );
UtlString* locationValue =
new UtlString ( cursor->location );
// Memory Leak fixes, make shallow copies of static keys
UtlString* identityKey = new UtlString( gIdentityKey );
UtlString* locationKey = new UtlString( gLocationKey );
record.insertKeyAndValue (
identityKey, identityValue );
record.insertKeyAndValue (
locationKey, locationValue );
rResultSet.addValue(record);
} while ( cursor.next() );
}
// Commit the rows to memory - multiprocess workaround
m_pFastDB->detach(0);
}
}
void
ResultSet::addValue( const UtlHashMap& record )
{
UtlHashMap* pNewRecord = new UtlHashMap() ;
UtlContainable* pObj ;
// Proceed with shallow copy
UtlHashMapIterator itor(const_cast<UtlHashMap&>(record)) ;
while ((pObj = (UtlContainable*) itor()) != NULL)
{
pNewRecord->insertKeyAndValue(itor.key(), itor.value()) ;
}
append(pNewRecord) ;
}
void
ExtensionDB::getAllRows(ResultSet& rResultSet) const
{
// Clear the out any previous records
rResultSet.destroyAll();
if ( m_pFastDB != NULL )
{
// must do this first to ensure process/tls integrity
m_pFastDB->attach();
dbCursor< ExtensionRow > cursor;
if ( cursor.select() > 0 )
{
do {
UtlHashMap record;
UtlString* uriValue =
new UtlString ( cursor->uri );
UtlString* extensionValue =
new UtlString ( cursor->extension );
// Memory Leak fixes, make shallow copies of static keys
UtlString* uriKey = new UtlString( gUriKey );
UtlString* extensionKey = new UtlString( gExtensionKey );
record.insertKeyAndValue (
uriKey, uriValue );
record.insertKeyAndValue (
extensionKey, extensionValue );
rResultSet.addValue(record);
} while (cursor.next());
}
// commit rows and also ensure process/tls integrity
m_pFastDB->detach(0);
}
}
void
UserForwardDB::getAllRows(ResultSet& rResultSet) const
{
// Clear the out any previous records
rResultSet.destroyAll();
if (m_pFastDB != NULL)
{
// must do this first to ensure process/tls integrity
m_pFastDB->attach();
dbCursor< UserForwardRow > cursor;
if ( cursor.select() > 0 )
{
do {
UtlHashMap record;
UtlString* identityValue =
new UtlString ( cursor->identity );
UtlString* cfwdtimeValue =
new UtlString ( cursor->cfwdtime );
// Memory Leak fixes, make shallow copies of static keys
UtlString* identityKey = new UtlString( gIdentityKey );
UtlString* cfwdtimeKey = new UtlString( gCfwdtimeKey );
record.insertKeyAndValue (
identityKey, identityValue );
record.insertKeyAndValue (
cfwdtimeKey, cfwdtimeValue );
rResultSet.addValue(record);
} while (cursor.next());
}
// commit rows and also ensure process/tls integrity
m_pFastDB->detach(0);
}
}
void
RegistrationDB::getAllRows ( ResultSet& rResultSet ) const
{
// Clear out any previous records
rResultSet.destroyAll();
if ( m_pFastDB != NULL )
{
SMART_DB_ACCESS;
dbCursor< RegistrationRow > cursor;
if ( cursor.select() > 0 )
{
do {
UtlHashMap record;
UtlString* uriValue = new UtlString(cursor->uri);
UtlString* callidValue = new UtlString(cursor->callid);
UtlString* contactValue = new UtlString(cursor->contact);
UtlInt* expiresValue = new UtlInt(cursor->expires);
UtlInt* cseqValue = new UtlInt(cursor->cseq);
UtlString* qvalueValue = new UtlString(cursor->qvalue);
UtlString* primaryValue = new UtlString(cursor->primary);
UtlLongLongInt* updateNumberValue = new UtlLongLongInt(cursor->update_number);
// Memory Leak fixes, make shallow copies of static keys
UtlString* uriKey = new UtlString(gUriKey);
UtlString* callidKey = new UtlString(gCallidKey);
UtlString* contactKey = new UtlString(gContactKey);
UtlString* expiresKey = new UtlString(gExpiresKey);
UtlString* cseqKey = new UtlString(gCseqKey);
UtlString* qvalueKey = new UtlString(gQvalueKey);
UtlString* primaryKey = new UtlString(gPrimaryKey);
UtlString* updateNumberKey = new UtlString(gUpdateNumberKey);
record.insertKeyAndValue(uriKey, uriValue);
record.insertKeyAndValue(callidKey, callidValue);
record.insertKeyAndValue(contactKey, contactValue);
record.insertKeyAndValue(expiresKey, expiresValue);
record.insertKeyAndValue(cseqKey, cseqValue);
record.insertKeyAndValue(qvalueKey, qvalueValue);
record.insertKeyAndValue(primaryKey, primaryValue);
record.insertKeyAndValue(updateNumberKey, updateNumberValue);
rResultSet.addValue(record);
} while (cursor.next());
}
}
else
{
OsSysLog::add(FAC_DB, PRI_CRIT, "RegistrationDB::getAllRows failed - no DB");
}
}
void
UserLocationDB::getAllRows(ResultSet& rResultSet) const
{
// Clear the results
rResultSet.destroyAll();
if ( m_pFastDB != NULL )
{
// Thread Local Storage
m_pFastDB->attach();
dbCursor< UserLocationRow > cursor;
if ( cursor.select() > 0 )
{
do {
UtlHashMap record;
UtlString* identityValue =
new UtlString ( cursor->identity );
UtlString* locationValue =
new UtlString ( cursor->location );
// Memory Leak fixes, make shallow copies of static keys
UtlString* identityKey = new UtlString( gIdentityKey );
UtlString* locationKey = new UtlString( gLocationKey );
record.insertKeyAndValue (
identityKey, identityValue );
record.insertKeyAndValue (
locationKey, locationValue );
rResultSet.addValue(record);
} while (cursor.next());
}
// Commit rows to memory - multiprocess workaround
m_pFastDB->detach(0);
}
}
// Fill in a map of process names and states (as UtlStrings)
void SipxProcessManager::getProcessStateAll(UtlHashMap& processStates //< key->name, value->state string
)
{
processStates.destroyAll();
SipxProcess* process;
// the lock is not required with the Iterator
UtlHashBagIterator processes(mProcesses);
while ((process = dynamic_cast<SipxProcess*>(processes())))
{
if ( 0 != process->compareTo(SUPERVISOR_PROCESS_NAME) )
{
processStates.insertKeyAndValue(new UtlString(process->data()),
new UtlString(process->GetCurrentState()->name())
);
}
}
}
void SipPublishContentMgr::publishDefault(const char* eventTypeKey,
const char* eventType,
SipPublishContentMgrDefaultConstructor*
defaultConstructor,
UtlBoolean fullState)
{
Os::Logger::instance().log(FAC_SIP, PRI_DEBUG,
"SipPublishContentMgr::publishDefault eventTypeKey '%s', eventType '%s', fullState %d, defaultConstructor %p",
eventTypeKey, eventType, fullState, defaultConstructor);
// Construct the key to look up.
UtlString key;
key.append(CONTENT_KEY_SEPARATOR);
key.append(eventTypeKey);
lock();
// Determine the storage we will be using.
UtlHashMap* pContent;
if (fullState)
{
pContent = &mDefaultContentConstructors;
}
else
{
pContent = &mDefaultPartialContentConstructors;
}
// Remove any old value first.
pContent->destroy(&key);
// Add the default constructor.
if (defaultConstructor)
{
UtlString* key_heap = new UtlString(key);
pContent->insertKeyAndValue(key_heap, defaultConstructor);
}
// Do not call the observer for the content change since this is default
// content.
unlock();
}
void
SipRedirectorGateway::processForm(const HttpRequestContext& requestContext,
const HttpMessage& request,
HttpMessage*& response)
{
UtlString string_get("get");
UtlString string_set("set");
UtlString string_prefix("prefix");
UtlString string_destination("destination");
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"%s::processForm entered", mLogName.data());
UtlString* user;
// Process the request.
// Get the body of the request.
const HttpBody* request_body = request.getBody();
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"%s::processForm A *** request body is '%s'",
mLogName.data(), request_body->getBytes());
// Get the values from the form.
if (request_body->isMultipart())
{
// Extract the values from the form data.
UtlHashMap values;
int c = request_body->getMultipartCount();
for (int i = 0; i < c; i++)
{
UtlString* name = new UtlString;
if (request_body->getMultipart(i)->getPartHeaderValue("name", *name))
{
const char* v;
int l;
request_body->getMultipartBytes(i, &v, &l);
// Strip leading and trailing whitespace from values.
UtlString* value = new UtlString(v, l);
value->strip(UtlString::both);
OsSysLog::add(FAC_SIP, PRI_CRIT,
"%s::processForm "
"form value '%s' = '%s'",
mLogName.data(), name->data(), value->data());
// 'name' and 'value' are now owned by 'values'.
values.insertKeyAndValue(name, value);
}
else
{
// 'name' is not owned by 'values' and we have to delete it.
delete name;
}
}
if (values.findValue(&string_get))
{
// This is a "get gateway" request.
// Insert the HTML into the response.
HttpBody* response_body = new HttpBody(form, -1, CONTENT_TYPE_TEXT_HTML);
response->setBody(response_body);
}
else if (values.findValue(&string_set))
{
// This is a "set gateway" request.
// Validate the routing prefix.
UtlString* prefix =
dynamic_cast <UtlString*> (values.findValue(&string_prefix));
if (prefixIsValid(*prefix))
{
// Validate the destination.
UtlString* destination =
dynamic_cast <UtlString*>
(values.findValue(&string_destination));
if (destination_is_valid(destination))
{
OsSysLog::add(FAC_SIP, PRI_CRIT,
"%s::processForm "
"add mapping '%s' -> '%s'",
mLogName.data(), prefix->data(), destination->data());
mMapLock.acquire();
// Insert the mapping.
mMapUserToContacts.insertKeyAndValue(prefix, destination);
mMapContactsToUser.insertKeyAndValue(destination, prefix);
mMapLock.release();
writeMappings();
}
}
// Insert the HTML into the response.
HttpBody* response_body = new HttpBody(form, -1, CONTENT_TYPE_TEXT_HTML);
response->setBody(response_body);
}
else
{
// Incomprehensible request.
// Insert the HTML into the response.
HttpBody* response_body = new HttpBody(form, -1, CONTENT_TYPE_TEXT_HTML);
response->setBody(response_body);
}
}
else
{
// Incomprehensible request.
// Insert the default HTML into the response.
HttpBody* response_body = new HttpBody(form, -1, CONTENT_TYPE_TEXT_HTML);
response->setBody(response_body);
}
#if 0
#if 0
// This is quite a chore, because getMultipartBytes gets the entire
// multipart section, including the trailing delimiter, rather than just
// the body, which is what we need.
const char* value;
int length;
request_body->getMultipartBytes(0, &value, &length);
#if 0
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"%s::processForm A *** seeing '%.*s'", mLogName.data(), length, value);
#endif
// Advance 'value' over the first \r\n\r\n, which ends the headers.
const char* s = strstr(value, "\r\n\r\n");
if (s)
{
s += 4; // Allow for length of \r\n\r\n.
length -= s - value;
value = s;
}
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"%s::processForm B *** seeing '%.*s'", mLogName.data(), length, value);
#if 0
// Search backward for the last \r, excepting the one in the second-to-last
// position, which marks the end of the contents.
if (length >= 3)
{
for (s = value + length - 3;
!(s == value || *s == '\r');
s--)
{
/* empty */
}
length = s - value;
}
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"%s::processForm seeing '%.*s'", mLogName.data(), length, value);
#endif
// Add the mappings.
const char* error_msg;
int error_location;
UtlBoolean success =
addMappings(value, length, user, error_msg, error_location);
// Construct the response.
response = new HttpMessage();
// Send 200 OK reply.
response->setResponseFirstHeaderLine(HTTP_PROTOCOL_VERSION,
HTTP_OK_CODE,
HTTP_OK_TEXT);
// Construct the HTML.
char buffer1[100];
#if 0
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"%s::processForm *** domain '%s'",
mLogName.data(), Gatewayredirector->mDomainName.data());
#endif
if (success)
{
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"%s::processForm success user '%s'",
mLogName.data(), user->data());
sprintf(buffer1, "<code>sip:<font size=\"+1\">%s</font>@%s:65070</code> redirects to:<br />",
user->data(), Gatewayredirector->mDomainName.data());
}
else
{
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"%s::processForm failure error_msg '%s', error_location %d",
mLogName.data(), error_msg, error_location);
strcpy(buffer1, "<i>Error:</i>");
}
// Transcribe the input value into buffer2.
char buffer2[FORM_SIZE];
char* p;
int i;
if (success)
{
// An impossible location.
error_location = -1;
}
for (p = buffer2, i = 0;
;
i++)
{
// If this is the error location, insert the error message.
if (i == error_location)
{
*p++ = '!';
*p++ = '-';
*p++ = '-';
strcpy(p, error_msg);
p += strlen(error_msg);
*p++ = '-';
*p++ = '-';
*p++ = '!';
}
// Test for ending the loop after testing to insert the error message,
// because the error message may be after the last character.
if (i >= length)
{
break;
}
switch (value[i])
{
case '<':
*p++ = '&';
*p++ = 'l';
*p++ = 't';
*p++ = ';';
break;
case '>':
*p++ = '&';
*p++ = 'g';
*p++ = 't';
*p++ = ';';
break;
case '&':
*p++ = '&';
*p++ = 'a';
*p++ = 'm';
*p++ = 'p';
*p++ = ';';
break;
default:
*p++ = value[i];
break;
}
}
*p++ = '\0';
#endif
#endif
}
int main(int argc, char* argv[])
{
parseArgs(argc, argv);
initLogger(argv);
OsEvent taskDone;
Url url(xmlrpcURI);
if (MemCheckDelay)
{
// Delay 45 seconds to allow memcheck start
printf("Wating %d seconds for start of memcheck ...", MemCheckDelay);
OsTask::delay(MemCheckDelay * 1000);
printf("starting\n");
}
// If an input file was specified we start up the number
// of specified threads to execute that input file. If number
// of threads wasn't specified we start up 1 thread.
if (bInputFile)
{
int signaled = 0;
for (int i=0; i<numThreads; i++)
{
ClientTask* pTask = new ClientTask(&taskDone);
pTask->start();
}
// Wait for threads to shut down
while (signaled < numThreads)
{
taskDone.wait();
taskDone.reset();
++signaled;
}
exit(0);
}
switch (Method)
{
case Version: // --version <xmlrpc URI> <dataset>
{
if (optind < argc)
{
fprintf(stderr, "Too many arguments: '%s'\n", argv[optind]);
showHelp(argv);
exit(1);
}
requestVersion(url);
break;
}
case Get: // --get <xmlrpc URI> <dataset> <name> ...
{
UtlSList names;
// copy remaining arguments into the names list
while (optind < argc)
{
names.append(new UtlString(argv[optind++]));
}
requestGet(url, names);
break;
}
case Set: // --set <xmlrpc URI> <dataset> <name> <value> [ <name> <value> ] ...
{
UtlHashMap parameters;
// copy remaining arguments into the names list
while (optind + 1 < argc)
{
UtlString* setName = new UtlString(argv[optind++]);
UtlString* setValue = new UtlString(argv[optind++]);
parameters.insertKeyAndValue(setName, setValue);
}
if (optind < argc)
{
fprintf(stderr, "name '%s' without a value\n", argv[optind]);
showHelp(argv);
exit(1);
}
if (parameters.isEmpty())
{
fprintf(stderr, "must specify at least one name and value\n");
showHelp(argv);
exit(1);
}
else
{
requestSet(url, parameters);
parameters.destroyAll();
}
break;
}
case Delete: // --delete <xmlrpc URI> <dataset> <name> ...
{
UtlSList names;
// copy remaining arguments into the names list
while (optind < argc)
{
names.append(new UtlString(argv[optind++]));
}
requestDelete(url, names);
break;
}
default:
fprintf(stderr, "No method specified\n");
showHelp(argv);
exit(1);
}
if (MemCheckDelay)
{
// Delay 45 seconds to allow memcheck start
printf("Wating %d seconds for stop of memcheck ...", MemCheckDelay);
OsTask::delay(MemCheckDelay * 1000);
printf("starting\n");
}
exit(0);
}
void testRegistrationSet()
{
ResultSet registrations;
size_t row;
for (row = 0; row < sizeof(regdata)/sizeof(RegistrationRow); row++)
{
UtlHashMap regRow;
UtlString* uriKey = new UtlString("uri");
UtlString* uriValue = new UtlString(regdata[row].uri);
regRow.insertKeyAndValue(uriKey, uriValue);
UtlString* callidKey = new UtlString("callid");
UtlString* callidValue = new UtlString(regdata[row].callid);
regRow.insertKeyAndValue(callidKey, callidValue);
UtlString* contactKey = new UtlString("contact");
UtlString* contactValue = new UtlString(regdata[row].contact);
regRow.insertKeyAndValue(contactKey, contactValue);
UtlString* expiresKey = new UtlString("expires");
UtlString* expiresValue = new UtlString(regdata[row].expires);
regRow.insertKeyAndValue(expiresKey, expiresValue);
UtlString* cseqKey = new UtlString("cseq");
UtlString* cseqValue = new UtlString(regdata[row].cseq);
regRow.insertKeyAndValue(cseqKey, cseqValue);
UtlString* qvalueKey = new UtlString("qvalue");
UtlString* qvalueValue = new UtlString(regdata[row].qvalue);
regRow.insertKeyAndValue(qvalueKey, qvalueValue);
UtlString* instanceIdKey = new UtlString("instance_id");
UtlString* instanceIdValue = new UtlString(regdata[row].instance_id);
regRow.insertKeyAndValue(instanceIdKey, instanceIdValue);
UtlString* gruuKey = new UtlString("gruu");
UtlString* gruuValue = new UtlString(regdata[row].gruu);
regRow.insertKeyAndValue(gruuKey, gruuValue);
UtlString* pathKey = new UtlString("path");
UtlString* pathValue = new UtlString(regdata[row].path);
regRow.insertKeyAndValue(pathKey, pathValue);
registrations.addValue(regRow);
}
Url target("http://server.exmple.com");
XmlRpcRequest request(target,"RPC.METHOD");
request.addParam(®istrations);
UtlString requestBody;
ssize_t bodyLength;
request.mpRequestBody->getBytes(&requestBody, &bodyLength);
const char* correctRequestBody =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<methodCall>\n"
"<methodName>RPC.METHOD</methodName>\n"
"<params>\n"
"<param>\n"
"<value><array><data>\n"
"<value><struct>\n"
"<member>\n"
"<name>gruu</name><value><string>sip:[email protected];gr</string></value>\n"
"</member>\n"
"<member>\n"
"<name>path</name><value><string><sip:visitme.com>,<sip:overhere.com>,<sip:comemyway.com></string></value>\n"
"</member>\n"
"<member>\n"
"<name>uri</name><value><string>sip:[email protected]</string></value>\n"
"</member>\n"
"<member>\n"
"<name>contact</name><value><string>sip:[email protected]:6012</string></value>\n"
"</member>\n"
"<member>\n"
"<name>qvalue</name><value><string></string></value>\n"
"</member>\n"
"<member>\n"
"<name>cseq</name><value><string>3</string></value>\n"
"</member>\n"
"<member>\n"
"<name>expires</name><value><string>1133218054</string></value>\n"
"</member>\n"
"<member>\n"
"<name>instance_id</name><value><string>1111</string></value>\n"
"</member>\n"
"<member>\n"
"<name>callid</name><value><string>6745637808245563@TmVhbC1sYXB0b3Ay</string></value>\n"
"</member>\n"
"</struct></value>\n"
"<value><struct>\n"
"<member>\n"
"<name>gruu</name><value><string>sip:[email protected];gr</string></value>\n"
"</member>\n"
"<member>\n"
"<name>path</name><value><string><sip:visitme.com>,<sip:overhere.com>,<sip:comemyway.com></string></value>\n"
"</member>\n"
"<member>\n"
"<name>uri</name><value><string>sip:[email protected]</string></value>\n"
"</member>\n"
"<member>\n"
"<name>contact</name><value><string>sip:[email protected]:24907</string></value>\n"
"</member>\n"
"<member>\n"
"<name>qvalue</name><value><string>0.8</string></value>\n"
"</member>\n"
"<member>\n"
"<name>cseq</name><value><string>2</string></value>\n"
"</member>\n"
"<member>\n"
"<name>expires</name><value><string>1133221655</string></value>\n"
"</member>\n"
"<member>\n"
"<name>instance_id</name><value><string>2222</string></value>\n"
"</member>\n"
"<member>\n"
"<name>callid</name><value><string>8d2d9c70405f4e66@TmVhbC1sYXB0b3Ay</string></value>\n"
"</member>\n"
"</struct></value>\n"
"<value><struct>\n"
"<member>\n"
"<name>gruu</name><value><string>sip:[email protected];gr</string></value>\n"
"</member>\n"
"<member>\n"
"<name>path</name><value><string><sip:visitme.com>,<sip:overhere.com>,<sip:comemyway.com></string></value>\n"
"</member>\n"
"<member>\n"
"<name>uri</name><value><string>sip:[email protected]</string></value>\n"
"</member>\n"
"<member>\n"
"<name>contact</name><value><string>sip:[email protected]:6000</string></value>\n"
"</member>\n"
"<member>\n"
"<name>qvalue</name><value><string>0.2</string></value>\n"
"</member>\n"
"<member>\n"
"<name>cseq</name><value><string>1</string></value>\n"
"</member>\n"
"<member>\n"
"<name>expires</name><value><string>1133221680</string></value>\n"
"</member>\n"
"<member>\n"
"<name>instance_id</name><value><string>3333</string></value>\n"
"</member>\n"
"<member>\n"
"<name>callid</name><value><string>fa294244984e0c3f@TmVhbC1sYXB0b3Ay</string></value>\n"
"</member>\n"
"</struct></value>\n"
"</data></array></value>\n"
"</param>\n"
;
ASSERT_STR_EQUAL(correctRequestBody, requestBody.data());
CPPUNIT_ASSERT_EQUAL(strlen(correctRequestBody), requestBody.length());
};
void fileExecute(const char* inputFile, bool bSingleStep)
{
FILE *fp;
char szBuffer[128];
char* token;
int line = 0;
if ((fp=fopen(inputFile, "r")) != NULL)
{
do {
rewind(fp);
while (fgets(szBuffer, 128, fp) != NULL)
{
++line;
if (szBuffer[0] != 0)
{
printf("Executing %s", szBuffer);
}
token = strtok(szBuffer, " ");
if (token == NULL)
{
break;
}
if (strcasecmp(token, "version") == 0)
{
token = strtok(NULL, " ");
if (token == NULL)
{
fileError(1, line);
}
else
{
Url url(token);
token = strtok(NULL, " ");
if (token == NULL)
{
fileError(2, line);
}
else
{
DataSet = token;
requestVersion(url);
}
}
}
else if (strcasecmp(token, "get") == 0)
{
token = strtok(NULL, " ");
if (token == NULL)
{
fileError(1, line);
}
else
{
Url url(token);
token = strtok(NULL, " ");
if (token == NULL)
{
fileError(2, line);
}
else
{
DataSet = token;
UtlSList names;
while (token != NULL)
{
token = strtok(NULL, " ");
if (token != NULL)
{
names.append(new UtlString(token));
}
}
requestGet(url, names);
names.destroyAll();
}
}
}
else if (strcasecmp(token, "set") == 0)
{
token = strtok(NULL, " ");
if (token == NULL)
{
fileError(1, line);
}
else
{
Url url(token);
token = strtok(NULL, " ");
if (token == NULL)
{
fileError(2, line);
}
else
{
DataSet = token;
UtlHashMap parameters;
char *key;
char *value;
while (token != NULL)
{
key = strtok(NULL, " ");
if (key == NULL)
{
break;
}
value = strtok(NULL, " ");
if (value == NULL)
{
fileError(3, line);
break;
}
parameters.insertKeyAndValue(new UtlString(key), new UtlString(value));
}
int entries = parameters.entries();
if (entries != 0 || (entries%2) == 0)
{
requestSet(url, parameters);
parameters.destroyAll();
}
}
}
}
else if (strcasecmp(token, "delete") == 0)
{
token = strtok(NULL, " ");
if (token == NULL)
{
fileError(1, line);
}
else
{
Url url(token);
token = strtok(NULL, " ");
if (token == NULL)
{
fileError(2, line);
}
else
{
DataSet = token;
UtlSList names;
while (token != NULL)
{
token = strtok(NULL, " ");
if (token != NULL)
{
names.append(new UtlString(token));
}
}
requestDelete(url, names);
names.destroyAll();
}
}
}
else
{
fprintf(stderr, "Unknown RPC request %s - ignoring line\n", token);
}
if (bSingleStep)
{
getchar();
}
}
}
while ( bRepeatFile );
fclose(fp);
}
else
{
fprintf(stderr, "Can't open %s\n", inputFile);
exit(1);
}
}
bool XmlRpcResponse::parseStruct(TiXmlNode* subNode, UtlHashMap* members)
{
bool result = false;
// struct
UtlString name;
UtlString paramValue;
TiXmlNode* memberValue;
for (TiXmlNode* memberNode = subNode->FirstChild("member");
memberNode;
memberNode = memberNode->NextSibling("member"))
{
TiXmlNode* memberName = memberNode->FirstChild("name");
if (memberName)
{
if (memberName->FirstChild())
{
name = memberName->FirstChild()->Value();
}
else
{
result = false;
break;
}
memberValue = memberNode->FirstChild("value");
if (memberValue)
{
// four-byte signed integer
TiXmlNode* valueElement = memberValue->FirstChild("i4");
if (valueElement)
{
if (valueElement->FirstChild())
{
paramValue = valueElement->FirstChild()->Value();
members->insertKeyAndValue(new UtlString(name), new UtlInt(atoi(paramValue)));
result = true;
}
else
{
result = false;
break;
}
}
else
{
valueElement = memberValue->FirstChild("int");
if (valueElement)
{
if (valueElement->FirstChild())
{
paramValue = valueElement->FirstChild()->Value();
members->insertKeyAndValue(new UtlString(name), new UtlInt(atoi(paramValue)));
result = true;
}
else
{
result = false;
break;
}
}
else
{
valueElement = memberValue->FirstChild("i8");
if (valueElement)
{
if (valueElement->FirstChild())
{
paramValue = valueElement->FirstChild()->Value();
members->insertKeyAndValue(new UtlString(name), new UtlLongLongInt(UtlLongLongInt::stringToLongLong(paramValue)));
result = true;
}
else
{
result = false;
break;
}
}
else
{
valueElement = memberValue->FirstChild("boolean");
if (valueElement)
{
if (valueElement->FirstChild())
{
paramValue = valueElement->FirstChild()->Value();
members->insertKeyAndValue(new UtlString(name), new UtlBool((atoi(paramValue)==1)));
result = true;
}
else
{
result = false;
break;
}
}
else
{
valueElement = memberValue->FirstChild("string");
if (valueElement)
{
if (valueElement->FirstChild())
{
paramValue = valueElement->FirstChild()->Value();
members->insertKeyAndValue(new UtlString(name), new UtlString(paramValue));
}
else
{
members->insertKeyAndValue(new UtlString(name), new UtlString());
}
result = true;
}
else
{
valueElement = memberValue->FirstChild("dateTime.iso8601");
if (valueElement)
{
if (valueElement->FirstChild())
{
paramValue = valueElement->FirstChild()->Value();
members->insertKeyAndValue(new UtlString(name), new UtlString(paramValue));
result = true;
}
else
{
result = false;
break;
}
}
else
{
valueElement = memberValue->FirstChild("struct");
if (valueElement)
{
UtlHashMap* members = new UtlHashMap();
if (parseStruct(valueElement, members))
{
members->insertKeyAndValue(new UtlString(name), members);
result = true;
}
}
else
{
valueElement = memberValue->FirstChild("array");
if (valueElement)
{
UtlSList* subArray = new UtlSList();
if (parseArray(valueElement, subArray))
{
members->insertKeyAndValue(new UtlString(name), subArray);
result = true;
}
}
else
{
// default for string
if (memberValue->FirstChild())
{
paramValue = memberValue->FirstChild()->Value();
members->insertKeyAndValue(new UtlString(name), new UtlString(paramValue));
}
else
{
members->insertKeyAndValue(new UtlString(name), new UtlString());
}
result = true;
}
}
}
}
}
}
}
}
}
}
}
return result;
}
int MpTopologyGraph::linkTopologyResources(MpResourceTopology& resourceTopology,
UtlHashBag& newResources,
UtlBoolean replaceNumInName,
int resourceNum)
{
// Link the resources
int connectionIndex = 0;
UtlString outputResourceName;
UtlString inputResourceName;
int outputResourcePortIndex;
int inputResourcePortIndex;
MpResource* outputResource = NULL;
MpResource* inputResource = NULL;
OsStatus result;
UtlHashMap newConnectionIds;
#ifdef TEST_PRINT
osPrintf("%d new resources in the list\n", newResources.entries());
UtlHashBagIterator iterator(newResources);
MpResource* containerResource = NULL;
while(containerResource = (MpResource*) iterator())
{
osPrintf("found list resource: \"%s\" value: \"%s\"\n",
containerResource->getName().data(), containerResource->data());
}
#endif
while(resourceTopology.getConnection(connectionIndex,
outputResourceName,
outputResourcePortIndex,
inputResourceName,
inputResourcePortIndex) == OS_SUCCESS)
{
if(replaceNumInName)
{
resourceTopology.replaceNumInName(outputResourceName, resourceNum);
resourceTopology.replaceNumInName(inputResourceName, resourceNum);
}
// Look in the container of new resources first as this is more
// efficient and new resources are not added immediately to a running
// flowgraph
outputResource = (MpResource*) newResources.find(&outputResourceName);
if(outputResource == NULL)
{
result = lookupResource(outputResourceName, outputResource);
if(result != OS_SUCCESS)
{
int virtPortIdx = outputResourcePortIndex>=0?outputResourcePortIndex:-1;
int realPortIdx;
result = lookupVirtualOutput(outputResourceName, virtPortIdx,
outputResource, realPortIdx);
if (result == OS_SUCCESS && outputResourcePortIndex>=0)
{
outputResourcePortIndex = realPortIdx;
}
}
assert(result == OS_SUCCESS);
}
inputResource = (MpResource*) newResources.find(&inputResourceName);
if(inputResource == NULL)
{
result = lookupResource(inputResourceName, inputResource);
if(result != OS_SUCCESS)
{
int virtPortIdx = inputResourcePortIndex>=0?inputResourcePortIndex:-1;
int realPortIdx;
result = lookupVirtualInput(inputResourceName, virtPortIdx,
inputResource, realPortIdx);
if (result == OS_SUCCESS && inputResourcePortIndex>=0)
{
inputResourcePortIndex = realPortIdx;
}
}
assert(result == OS_SUCCESS);
}
assert(outputResource);
assert(inputResource);
if(outputResource && inputResource)
{
if(outputResourcePortIndex == MpResourceTopology::MP_TOPOLOGY_NEXT_AVAILABLE_PORT)
{
outputResourcePortIndex = outputResource->reserveFirstUnconnectedOutput();
assert(outputResourcePortIndex >= 0);
}
else if(outputResourcePortIndex < MpResourceTopology::MP_TOPOLOGY_NEXT_AVAILABLE_PORT)
{
// First see if a real port is already in the dictionary
UtlInt searchKey(outputResourcePortIndex);
UtlInt* foundValue = NULL;
if((foundValue = (UtlInt*) newConnectionIds.findValue(&searchKey)))
{
// Use the mapped index
outputResourcePortIndex = foundValue->getValue();
}
else
{
// Find an available port and add it to the map
int realPortNum = outputResource->reserveFirstUnconnectedOutput();
assert(realPortNum >= 0);
UtlInt* portKey = new UtlInt(outputResourcePortIndex);
UtlInt* portValue = new UtlInt(realPortNum);
newConnectionIds.insertKeyAndValue(portKey, portValue);
outputResourcePortIndex = realPortNum;
}
}
if(inputResourcePortIndex == MpResourceTopology::MP_TOPOLOGY_NEXT_AVAILABLE_PORT)
{
inputResourcePortIndex = inputResource->reserveFirstUnconnectedInput();
assert(inputResourcePortIndex >= 0);
}
else if(inputResourcePortIndex < MpResourceTopology::MP_TOPOLOGY_NEXT_AVAILABLE_PORT)
{
// First see if a real port is already in the dictionary
UtlInt searchKey(inputResourcePortIndex);
UtlInt* foundValue = NULL;
if((foundValue = (UtlInt*) newConnectionIds.findValue(&searchKey)))
{
// Use the mapped index
inputResourcePortIndex = foundValue->getValue();
}
else
{
// Find an available port and add it to the map
int realPortNum = inputResource->reserveFirstUnconnectedInput();
assert(realPortNum >= 0);
UtlInt* portKey = new UtlInt(inputResourcePortIndex);
UtlInt* portValue = new UtlInt(realPortNum);
newConnectionIds.insertKeyAndValue(portKey, portValue);
inputResourcePortIndex = realPortNum;
}
}
result = addLink(*outputResource, outputResourcePortIndex, *inputResource, inputResourcePortIndex);
assert(result == OS_SUCCESS);
}
connectionIndex++;
}
newConnectionIds.destroyAll();
return(connectionIndex);
}
virtual bool execute(const HttpRequestContext& requestContext, ///< request context
UtlSList& params, ///< request param list
void* userData, ///< user data
XmlRpcResponse& response, ///< request response
ExecutionStatus& status
)
{
UtlString* dbName = dynamic_cast<UtlString*>(params.at(0));
if (dbName && !dbName->isNull())
{
OsReadLock lock(*ConfigRPC::spDatabaseLock);
// find the dataset registered with this name
ConfigRPC* db = ConfigRPC::find(*dbName);
if (db)
{
// check with the application to see if this request is authorized on this dataset
status = db->mCallback->accessAllowed(requestContext, ConfigRPC_Callback::Get);
if ( XmlRpcMethod::OK == status )
{
// read in the dataset
OsConfigDb dataset;
OsStatus datasetStatus = db->load(dataset);
if ( OS_SUCCESS == datasetStatus )
{
// get the list of names that the request is asking for
UtlContainable* secondParam = params.at(1);
if ( secondParam )
{
UtlSList* nameList = dynamic_cast<UtlSList*>(secondParam);
if (nameList)
{
/*
* Iterate over the requested names
* - All must be present or the request is an error
* - For each name found, add the name and value to the
* selectedParams hash to be returned in a success response.
*/
UtlHashMap selectedParams;
UtlSListIterator requestedNames(*nameList);
UtlString* requestedName = NULL;
bool allNamesFound = true;
while ( allNamesFound
&& (requestedName = dynamic_cast<UtlString*>(requestedNames()))
)
{
UtlString* paramValue = new UtlString();
if ( OS_SUCCESS == dataset.get(*requestedName, *paramValue) )
{
UtlString* paramName = new UtlString(*requestedName);
// put it into the results
selectedParams.insertKeyAndValue(paramName, paramValue);
}
else
{
allNamesFound = false;
delete paramValue;
}
}
if (allNamesFound)
{
// all were found - return the name/value pairs
response.setResponse(&selectedParams);
}
else
{
// at least one name was not found - return an error.
UtlString faultMsg;
faultMsg.append("parameter name '");
faultMsg.append(*requestedName);
faultMsg.append("' not found");
response.setFault(ConfigRPC::nameNotFound, faultMsg.data());
status = XmlRpcMethod::FAILED;
}
selectedParams.destroyAll();
}
else
{
// The second parameter was not a list
response.setFault( ConfigRPC::invalidType
,"namelist parameter is not an array"
);
status = XmlRpcMethod::FAILED;
}
}
else // no parameter names specified
{
// return all names
UtlHashMap allParams;
UtlString lastKey;
OsStatus iterateStatus;
UtlString* paramName;
UtlString* paramValue;
bool notEmpty = false;
for ( ( paramName = new UtlString()
,paramValue = new UtlString()
,iterateStatus = dataset.getNext(lastKey, *paramName, *paramValue)
);
OS_SUCCESS == iterateStatus;
( lastKey = *paramName
,paramName = new UtlString()
,paramValue = new UtlString()
,iterateStatus = dataset.getNext(lastKey, *paramName, *paramValue)
)
)
{
notEmpty = true; // got at least one parameter
// put it into the result array
allParams.insertKeyAndValue(paramName, paramValue);
}
// on the final iteration these were not used
delete paramName;
delete paramValue;
if (notEmpty)
{
response.setResponse(&allParams);
allParams.destroyAll();
}
else
{
// there is no way to send a well-formed but empty response,
// so a 'get all' on an empty dataset returns a fault.
UtlString faultMsg;
faultMsg.append("dataset '");
faultMsg.append(*dbName);
faultMsg.append("' has no parameters");
response.setFault(ConfigRPC::emptyDataset, faultMsg);
status = XmlRpcMethod::FAILED;
}
}
}
else
{
UtlString faultMsg("dataset load failed");
response.setFault(ConfigRPC::loadFailed, faultMsg);
status = XmlRpcMethod::FAILED;
}
}
else
{
UtlString faultMsg("Access Denied");
response.setFault(XmlRpcMethod::FAILED, faultMsg.data());
}
}
else
{
UtlString faultMsg;
faultMsg.append("db lookup failed for '");
faultMsg.append(*dbName);
faultMsg.append("'");
response.setFault( XmlRpcResponse::UnregisteredMethod, faultMsg.data());
status = XmlRpcMethod::FAILED;
}
}
else
{
response.setFault( XmlRpcResponse::EmptyParameterValue
,"'dbname' parameter is missing or invalid type"
);
status = XmlRpcMethod::FAILED;
}
return true;
}
OsStatus
RegistrationDB::load()
{
OsStatus result = OS_SUCCESS;
if ( m_pFastDB != NULL )
{
UtlString fileName = mDatabaseName + ".xml";
UtlString pathName = SipXecsService::Path(SipXecsService::DatabaseDirType,
fileName.data());
OsSysLog::add(FAC_DB, PRI_DEBUG, "RegistrationDB::load loading \"%s\"",
pathName.data());
TiXmlDocument doc ( pathName );
// Verify that we can load the file (i.e it must exist)
if( doc.LoadFile() )
{
TiXmlNode * rootNode = doc.FirstChild ("items");
if (rootNode != NULL)
{
// the folder node contains at least the name/displayname/
// and autodelete elements, it may contain others
for( TiXmlNode *itemNode = rootNode->FirstChild( "item" );
itemNode;
itemNode = itemNode->NextSibling( "item" ) )
{
// Create a hash dictionary for element attributes
UtlHashMap nvPairs;
for( TiXmlNode *elementNode = itemNode->FirstChild();
elementNode;
elementNode = elementNode->NextSibling() )
{
// Bypass comments and other element types only interested
// in parsing element attributes
if ( elementNode->Type() == TiXmlNode::ELEMENT )
{
UtlString elementName = elementNode->Value();
UtlString elementValue;
result = SIPDBManager::getAttributeValue (
*itemNode, elementName, elementValue);
if (result == OS_SUCCESS)
{
UtlString* collectableKey =
new UtlString( elementName );
UtlString* collectableValue =
new UtlString( elementValue );
nvPairs.insertKeyAndValue (
collectableKey, collectableValue );
} else if ( elementNode->FirstChild() == NULL )
{
// Null Element value creaete a special
// char string we have key and value so insert
UtlString* collectableKey =
new UtlString( elementName );
UtlString* collectableValue =
new UtlString( SPECIAL_IMDB_NULL_VALUE );
nvPairs.insertKeyAndValue (
collectableKey, collectableValue );
}
}
}
// Insert the item row into the IMDB
insertRow ( nvPairs );
}
}
} else
{
OsSysLog::add(FAC_DB, PRI_WARNING, "RegistrationDB::load failed to load \"%s\"",
pathName.data());
result = OS_FAILED;
}
} else
{
OsSysLog::add(FAC_DB, PRI_CRIT, "RegistrationDB::load failed - no DB");
result = OS_FAILED;
}
return result;
}
void
CredentialDB::getAllCredentials (
const Url& uri,
ResultSet& rResultSet ) const
{
UtlString identity;
uri.getIdentity(identity);
// This should erase the contents of the existing resultset
rResultSet.clear();
if ( !identity.isNull() && (m_pFastDB != NULL) )
{
// Thread Local Storage
m_pFastDB->attach();
// Search to see if we have a Credential Row
dbCursor< CredentialRow > cursor;
dbQuery query;
query="np_identity=",identity;
if ( cursor.select( query ) > 0 )
{
do {
UtlHashMap record;
UtlString* uriValue =
new UtlString ( cursor->uri );
UtlString* realmValue =
new UtlString ( cursor->realm );
UtlString* useridValue =
new UtlString ( cursor->userid );
UtlString* passtokenValue =
new UtlString ( cursor->passtoken );
UtlString* pintokenValue =
new UtlString ( cursor->pintoken );
UtlString* authtypeValue =
new UtlString ( cursor->authtype );
// Memory Leak fixes, make shallow copies of static keys
UtlString* uriKey = new UtlString( gUriKey );
UtlString* realmKey = new UtlString( gRealmKey );
UtlString* useridKey = new UtlString( gUseridKey );
UtlString* passtokenKey = new UtlString( gPasstokenKey );
UtlString* pintokenKey = new UtlString( gPintokenKey );
UtlString* authtypeKey = new UtlString( gAuthtypeKey );
record.insertKeyAndValue ( uriKey, uriValue );
record.insertKeyAndValue ( realmKey, realmValue );
record.insertKeyAndValue ( useridKey, useridValue );
record.insertKeyAndValue ( passtokenKey, passtokenValue );
record.insertKeyAndValue ( pintokenKey, pintokenValue );
record.insertKeyAndValue ( authtypeKey, authtypeValue );
rResultSet.addValue(record);
} while ( cursor.next() );
}
// Commit the rows to memory - multiprocess workaround
m_pFastDB->detach(0);
}
}
OsStatus
ExtensionDB::load()
{
// Critical Section here
OsLock lock( sLockMutex );
OsStatus result = OS_SUCCESS;
if ( m_pFastDB != NULL )
{
// Clean out the existing DB rows before loading
// a new set from persistent storage
removeAllRows ();
UtlString fileName = OsPath::separator + mDatabaseName + ".xml";
UtlString pathName = SipXecsService::Path(SipXecsService::DatabaseDirType,
fileName.data());
OsSysLog::add(FAC_DB, PRI_DEBUG, "ExtensionDB::load loading \"%s\"",
pathName.data());
TiXmlDocument doc ( pathName );
// Verify that we can load the file (i.e it must exist)
if( doc.LoadFile() )
{
// the checksum is used to determine if the db changed between reloads
int loadChecksum = 0;
TiXmlNode * rootNode = doc.FirstChild ("items");
if (rootNode != NULL)
{
// the folder node contains at least the name/displayname/
// and autodelete elements, it may contain others
for( TiXmlNode *itemNode = rootNode->FirstChild( "item" );
itemNode;
itemNode = itemNode->NextSibling( "item" ) )
{
// Create a hash dictionary for element attributes
UtlHashMap nvPairs;
for( TiXmlNode *elementNode = itemNode->FirstChild();
elementNode;
elementNode = elementNode->NextSibling() )
{
// Bypass comments and other element types only interested
// in parsing element attributes
if ( elementNode->Type() == TiXmlNode::ELEMENT )
{
UtlString elementName = elementNode->Value();
UtlString elementValue;
result = SIPDBManager::getAttributeValue (
*itemNode, elementName, elementValue);
// update the load checksum
loadChecksum += ( elementName.hash() + elementValue.hash() );
if (result == OS_SUCCESS)
{
UtlString* collectableKey =
new UtlString( elementName );
UtlString* collectableValue =
new UtlString( elementValue );
nvPairs.insertKeyAndValue (
collectableKey, collectableValue );
} else if ( elementNode->FirstChild() == NULL )
{
// NULL Element value create a special
// char string we have key and value so insert
UtlString* collectableKey =
new UtlString( elementName );
UtlString* collectableValue =
new UtlString( SPECIAL_IMDB_NULL_VALUE );
nvPairs.insertKeyAndValue (
collectableKey, collectableValue );
}
}
}
// Insert the item row into the IMDB
insertRow ( nvPairs );
}
}
} else
{
OsSysLog::add(FAC_SIP, PRI_WARNING, "ExtensionDB::load failed to load \"%s\"",
pathName.data());
result = OS_FAILED;
}
} else
{
result = OS_FAILED;
}
return result;
}
void
RegistrationDB::getUnexpiredContacts (
const Url& uri,
const int& timeNow,
ResultSet& rResultSet) const
{
// Clear the results
rResultSet.destroyAll();
UtlString identity;
uri.getIdentity( identity );
if ( !identity.isNull() && ( m_pFastDB != NULL) )
{
SMART_DB_ACCESS;
dbCursor< RegistrationRow > cursor;
dbQuery query;
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"RegistrationDB::getUnexpiredContacts "
"identity = '%s'",
identity.data());
if (strncmp(identity.data(), GRUU_PREFIX,
sizeof (GRUU_PREFIX) - 1) == 0)
{
// This is a GRUU, search for it in the gruu column.
query="gruu=",identity," and expires>",timeNow;
OsSysLog::add(FAC_DB, PRI_DEBUG,
"RegistrationDB::getUnexpiredContacts recognized GRUU");
}
else
{
// This is not a GRUU, search for it in the identity column.
query="np_identity=",identity," and expires>",timeNow;
}
if ( cursor.select(query) > 0 )
{
// Copy all the unexpired contacts into the result hash
do
{
UtlHashMap record;
UtlString* uriValue = new UtlString(cursor->uri);
UtlString* callidValue = new UtlString(cursor->callid);
UtlString* contactValue = new UtlString(cursor->contact);
UtlInt* expiresValue = new UtlInt(cursor->expires);
UtlInt* cseqValue = new UtlInt(cursor->cseq);
UtlString* qvalueValue = new UtlString(cursor->qvalue);
UtlString* primaryValue = new UtlString(cursor->primary);
UtlLongLongInt* updateNumberValue = new UtlLongLongInt(cursor->update_number);
UtlString* instanceIdValue = new UtlString(cursor->instance_id);
UtlString* gruuValue = new UtlString(cursor->gruu);
UtlString* pathValue = new UtlString(cursor->path);
OsSysLog::add(FAC_DB, PRI_DEBUG,
"RegistrationDB::getUnexpiredContacts Record found "
"uri = '%s', contact = '%s', instance_id = '%s', "
"gruu = '%s', path = '%s'",
uriValue->data(), contactValue->data(),
instanceIdValue->data(), gruuValue->data(), pathValue->data());
// Memory Leak fixes, make shallow copies of static keys
UtlString* uriKey = new UtlString(gUriKey);
UtlString* callidKey = new UtlString(gCallidKey);
UtlString* contactKey = new UtlString(gContactKey);
UtlString* expiresKey = new UtlString(gExpiresKey);
UtlString* cseqKey = new UtlString(gCseqKey);
UtlString* qvalueKey = new UtlString(gQvalueKey);
UtlString* primaryKey = new UtlString(gPrimaryKey);
UtlString* updateNumberKey = new UtlString(gUpdateNumberKey);
UtlString* instanceIdKey = new UtlString(gInstanceIdKey);
UtlString* gruuKey = new UtlString(gGruuKey);
UtlString* pathKey = new UtlString(gPathKey);
record.insertKeyAndValue(uriKey, uriValue);
record.insertKeyAndValue(callidKey, callidValue);
record.insertKeyAndValue(contactKey, contactValue);
record.insertKeyAndValue(expiresKey, expiresValue);
record.insertKeyAndValue(cseqKey, cseqValue);
record.insertKeyAndValue(qvalueKey, qvalueValue);
record.insertKeyAndValue(primaryKey, primaryValue);
record.insertKeyAndValue(updateNumberKey, updateNumberValue);
record.insertKeyAndValue(instanceIdKey, instanceIdValue);
record.insertKeyAndValue(gruuKey, gruuValue);
record.insertKeyAndValue(pathKey, pathValue);
rResultSet.addValue(record);
} while ( cursor.next() );
}
}
else
{
OsSysLog::add(FAC_DB, PRI_CRIT, "RegistrationDB::getUnexpiredContacts failed - no DB");
}
}
OsStatus
DialByNameDB::load() const
{
// Critical Section here
OsLock lock( sLockMutex );
OsStatus result = OS_SUCCESS;
if ( m_pFastDB != NULL )
{
// Clean out the existing DB rows before loading
// a new set from persistent storage
removeAllRows ();
// Query all Identities with 'AutoAttendant' permission set
PermissionDB * pPermissionDB = PermissionDB::getInstance();
ResultSet permissionsResultSet;
pPermissionDB->getIdentities ( "AutoAttendant", permissionsResultSet );
CredentialDB * pCredentialDB = CredentialDB::getInstance();
ResultSet credentialsResultSet;
UtlString identity, permission;
int numAutoAttendees = permissionsResultSet.getSize();
for (int index = 0; index < numAutoAttendees; index++)
{
// get the next identity
UtlString identityKey("identity");
UtlHashMap record;
permissionsResultSet.getIndex( index, record );
UtlString identity = *((UtlString*)record.findValue(&identityKey));
Url identityUrl (identity);
pCredentialDB->
getAllCredentials (
identityUrl,
credentialsResultSet );
// we should only have one credential! we're
// only interested in the uri column's display name
if ( credentialsResultSet.getSize() == 1)
{
UtlString uriKey("uri");
UtlHashMap record;
credentialsResultSet.getIndex( 0, record );
UtlString uri = *((UtlString*)record.findValue(&uriKey));
// must have a display name present before inserting a row
// @TODO convert to url and get display name
UtlHashMap nvPairs;
if (!uri.isNull())
{
// Null Element value create a special
// char string we have key and value so insert
UtlString* contactValue =
new UtlString( uri );
// Memory Leak fixes, make shallow copies of static keys
UtlString* contactKey =
new UtlString( gNp_contactKey );
nvPairs.insertKeyAndValue (
contactKey, contactValue );
}
// Insert the item row into the IMDB
insertRow ( nvPairs );
}
}
// Reset the changed flags after a successful load
SIPDBManager::getInstance()->
setDatabaseChangedFlag("credential", FALSE);
SIPDBManager::getInstance()->
setDatabaseChangedFlag("permission", FALSE);
} else
{
result = OS_FAILED;
}
return result;
}
OsStatus
MappingRulesUrlMapping::parsePermMatchContainer(const Url& requestUri,
const UtlString& vdigits,
ResultSet& rContactResultSet,
ResultSet& rPermissions,
UtlString& callTag,
const TiXmlNode* pUserMatchNode //parent node
) const
{
OsStatus doTransformStatus = OS_FAILED;
UtlBoolean bPermissionFound = false;
UtlString requestUriStr;
callTag = "UNK";
requestUri.toString(requestUriStr);
const TiXmlNode* pPermMatchNode = NULL;
while ( (pPermMatchNode = pUserMatchNode->IterateChildren( pPermMatchNode ) )
&& (doTransformStatus != OS_SUCCESS) )
{
if(pPermMatchNode && pPermMatchNode->Type() == TiXmlNode::ELEMENT)
{
UtlString tagValue = pPermMatchNode->Value();
if( tagValue.compareTo(XML_TAG_CALLTAG) == 0 )
{
// Found call tag element. Read the text value for it.
textContentShallow(callTag, pPermMatchNode);
}
if( tagValue.compareTo(XML_TAG_PERMISSIONMATCH) == 0 )
{
//practically there should always be only one permission match tag
const TiXmlElement* pPermissionMatchElement = pPermMatchNode->ToElement();
UtlBoolean bPermNodePresent = false;
//get the user text value from it
for( const TiXmlNode* pPermissionNode = pPermissionMatchElement->FirstChild( XML_TAG_PERMISSION );
pPermissionNode;
pPermissionNode = pPermissionNode->NextSibling( XML_TAG_PERMISSION ) )
{
bPermNodePresent = true;
const TiXmlElement* pPermissionElement = pPermissionNode->ToElement();
//get permission Name
const TiXmlNode* pPermissionText = pPermissionElement->FirstChild();
if(pPermissionText)
{
UtlString permission = pPermissionText->Value();
UtlHashMap record;
UtlString* pIdentityKey =
new UtlString ( "identity" );
UtlString* pPermissionKey =
new UtlString ( "permission" );
UtlString* pIdentityValue =
new UtlString ( requestUriStr );
UtlString* pPermissionValue =
new UtlString ( permission );
record.insertKeyAndValue (
pIdentityKey, pIdentityValue );
record.insertKeyAndValue (
pPermissionKey, pPermissionValue );
rPermissions.addValue(record);
bPermissionFound = true;
}
}
//if no permission node - then it means no permission required - allow all
if((!bPermNodePresent || bPermissionFound ) )
{
//if the premission matches in the permissions database
//go ahead and get the transform tag
doTransformStatus = doTransform(requestUri,
vdigits,
rContactResultSet,
pPermMatchNode);
}
}
}
}
return doTransformStatus;
}