int _rmdir(const char *sDir)
{
USES_CONVERSION;
PString folderName = sDir;
if (folderName[folderName.GetLength() - 1] == PDIR_SEPARATOR) {
folderName.Delete(folderName.GetLength() - 1, 1);
}
return (RemoveDirectory(A2T(folderName)) ? 0 : -1);
}
PString SIDStil::GetBug(PString relPathToEntry, int32 tuneNo)
{
if (baseDir.IsEmpty())
return ("");
// Older versions of STIL is detected
if (stilVersion < 2.59f)
tuneNo = 0;
// Find out whether we have this bug entry in the buffer.
// If the baseDir was changed, we'll have to read it in again,
// even if it might be in the buffer already
if ((bugBuf.Left(relPathToEntry.GetLength()) != relPathToEntry) || ((bugBuf.Find('\n') != relPathToEntry.GetLength()) && (stilVersion > 2.59f)))
{
// The relative pathnames don't match or they're not the same length:
// We don't have it in the buffer, so pull it in
try
{
PDirectory tempDir;
tempDir.SetDirectory(baseDir);
tempDir.Append("DOCUMENTS");
bugFile->Open(tempDir.GetDirectory() + "BUGlist.txt", PFile::pModeRead | PFile::pModeShareRead);
if (PositionToEntry(relPathToEntry, bugFile, bugDirs) == false)
{
// Copy the entry's name to the buffer
bugBuf = relPathToEntry + "\n";
}
else
{
bugBuf.MakeEmpty();
ReadEntry(bugFile, bugBuf);
}
bugFile->Close();
}
catch(PFileException e)
{
// Failed reading from the STIL.txt file
bugFile->Close();
return ("");
}
}
// Put the requested field into the result string
if (GetField(resultBug, bugBuf, tuneNo) != true)
return ("");
return (resultBug);
}
/** Make a call to the remote endpoint.
*/
int h323_make_call(char *dest, call_details_t *cd, call_options_t *call_options)
{
int res;
PString token;
PString host(dest);
if (!h323_end_point_exist()) {
return 1;
}
res = endPoint->MakeCall(host, token, &cd->call_reference, call_options);
memcpy((char *)(cd->call_token), (const unsigned char *)token, token.GetLength());
return res;
};
/** Make a call to the remote endpoint.
*/
int h323_make_call(char *host, call_details_t *cd, call_options_t call_options)
{
int res;
PString token;
PString dest(host);
if (!h323_end_point_exist()) {
return 1;
}
noFastStart = call_options.noFastStart;
noH245Tunneling = call_options.noH245Tunneling;
res = endPoint->MakeCall(dest, token, &cd->call_reference, call_options.port, call_options.callerid, call_options.callername);
memcpy((char *)(cd->call_token), (const unsigned char *)token, token.GetLength());
return res;
};
void MyProcess::Main() {
PString aor;
PString REGISTRAR_ADDRESS = "ekiga.net";
PString STUN_SERVER_ADDRESS = "stun.ekiga.net";
PString USER_NAME;
PString PASSWORD;
PString SIP_ADDRESS = "sip:[email protected]";
//PString SIP_ADDRESS = "sip:*[email protected]";
if (USER_NAME.GetLength() == 0 || PASSWORD.GetLength() == 0) {
std::cout << "Please set your username and password in the code." << std::endl;
return;
}
PTrace::Initialise(5, "log");
MyManager manager = MyManager();
// [Tom] TODO: Research why the NAT type is important.
PSTUNClient::NatTypes nat = manager.SetSTUNServer(STUN_SERVER_ADDRESS);
std::cout << "NAT type: " << nat << std::endl;
MyPCSSEndPoint * soundEp = new MyPCSSEndPoint(manager);
std::cout << "Sound output:" << std::endl;
std::cout << "===================================================================" << std::endl;
std::cout << soundEp->GetSoundChannelPlayDevice() << std::endl << std::endl;
std::cout << "Media formats:" << std::endl;
std::cout << "===================================================================" << std::endl;
std::cout << soundEp->GetMediaFormats() << std::endl << std::endl;
std::cout << "Registered formats:" << std::endl;
std::cout << "===================================================================" << std::endl;
std::cout << OpalMediaFormat::GetAllRegisteredMediaFormats() << std::endl << std::endl;
MySIPEndPoint * endPoint = new MySIPEndPoint(manager);
endPoint->SetDefaultLocalPartyName(USER_NAME);
endPoint->StartListeners(endPoint->GetDefaultListeners());
SIPRegister::Params params;
params.m_registrarAddress = REGISTRAR_ADDRESS;
params.m_addressOfRecord = USER_NAME;
params.m_password = PASSWORD;
std::cout << "Registering with " << params.m_registrarAddress << "; this may take a while..." << std::endl;
endPoint->Register(params, aor);
OpalMixerEndPoint * mixerEP = new OpalMixerEndPoint(manager, "mcu");
OpalMixerNodeInfo * mcuNodeInfo = new OpalMixerNodeInfo;
mcuNodeInfo->m_name = "Telekarma";
mixerEP->SetAdHocNodeInfo(mcuNodeInfo);
mixerEP->StartListeners(mixerEP->GetDefaultListeners());
int i;
for(i = 20; i > 0; i--) {
if (endPoint->IsRegistered(aor)) {
break;
}
PThread::Sleep(1000);
}
if (i > 0) {
std::cout << "Registration succeeded; aor=" << aor << std::endl;
std::cout << "Calling..." << std::endl;
PSafePtr<OpalCall> call2 = manager.SetUpCall("mcu:*", "pc:*");
PSafePtr<OpalCall> call = manager.SetUpCall("mcu:*", SIP_ADDRESS);
while(!call);
// manager.StartRecording("test.wav");
std::cout << "Connection will automatically terminate after 15 seconds..." << std::endl;
PThread::Sleep(15*1000);
// manager.StopRecording();
std::cout << "Connection automatically terminated by design." << std::endl;
call->Clear();
endPoint->Unregister(aor);
while(endPoint->IsRegistered(aor));
// [MV] maybe more to the exit/cleanup than this...
} else {
std::cout << "Registration attempt timed out." << std::endl;
}
std::cout << "Proof of concept main execution complete." << std::endl;
}
bool Resources::Open(PString & argv0, PString & application) {
if(!PHYSFS_init(argv0.GetPointer())) {
PError << "failure while initialising physfs: " << PHYSFS_getLastError() << endl;
return PFalse;
} else {
PTRACE(5, "successful initialize physfs");
}
const char* basedir = PHYSFS_getBaseDir();
const char* userdir = PHYSFS_getUserDir();
const char* dirsep = PHYSFS_getDirSeparator();
char* writedir = new char[strlen(userdir) + application.GetLength() + 2];
sprintf(writedir, "%s.%s", userdir, application.GetPointer());
PTRACE(5, "physfs base directory: " << basedir);
PTRACE(5, "physfs user directory: " << userdir);
PTRACE(5, "physfs write directory: " << writedir);
if(!PHYSFS_setWriteDir(writedir)) {
// try to create the directory...
char* mkdir = new char[application.GetLength()+2];
sprintf(mkdir, ".%s", application.GetPointer());
if(!PHYSFS_setWriteDir(userdir) || ! PHYSFS_mkdir(mkdir)) {
delete[] writedir;
delete[] mkdir;
PError << "failed creating configuration directory: '" << writedir << "': " << PHYSFS_getLastError() << endl;
return PFalse;
}
delete[] mkdir;
if (!PHYSFS_setWriteDir(writedir)) {
PError << "couldn't set configuration directory to '" << writedir << "': " << PHYSFS_getLastError() << endl;
return PFalse;
}
}
PHYSFS_addToSearchPath(writedir, 0);
PHYSFS_addToSearchPath(basedir, 1);
delete[] writedir;
/* Root out archives, and add them to search path... */
if (resourceExt != NULL) {
char **rc = PHYSFS_enumerateFiles("/");
char **i;
size_t extlen = strlen(resourceExt);
char *ext;
for (i = rc; *i != NULL; i++) {
size_t l = strlen(*i);
if ((l > extlen) && ((*i)[l - extlen - 1] == '.')) {
ext = (*i) + (l - extlen);
if (strcasecmp(ext, resourceExt) == 0) {
PTRACE(5, "Add resource '" << *i << "' to search path");
const char *d = PHYSFS_getRealDir(*i);
char* str = new char[strlen(d) + strlen(dirsep) + l + 1];
sprintf(str, "%s%s%s", d, dirsep, *i);
addToSearchPath(str, 1);
delete[] str;
};
};
};
PHYSFS_freeList(rc);
}
return PTrue;
}
bool SIDStil::GetField(PString &result, PString buffer, int32 tuneNo, STILField field)
{
int32 start, firstTuneNo, temp, temp2 = -1;
// Clean out the result buffer first
result.MakeEmpty();
// Position pointer to the first char beyond the file designation
start = buffer.Find('\n');
start++;
// Check whether this is a NULL entry or not
if (start == 0)
return (false);
// Is this a multitune entry?
firstTuneNo = buffer.Find("(#", start);
// This is a tune designation only if the previous char was
// a newline (ie. if the "(#" is on the beginning of a line).
if ((firstTuneNo >= 1) && (buffer.GetAt(firstTuneNo - 1) != '\n'))
firstTuneNo = -1;
if (firstTuneNo == -1)
{
//-------------------//
// SINGLE TUNE ENTRY //
//-------------------//
//
// Is the first thing in this STIL entry the COMMENT?
temp = buffer.Find(_COMMENT_STR, start);
// Search for other potential fields beyond the COMMENT
if (temp == start)
{
temp2 = buffer.Find(_NAME_STR, start);
if (temp2 == -1)
{
temp2 = buffer.Find(_AUTHOR_STR, start);
if (temp2 == -1)
{
temp2 = buffer.Find(_TITLE_STR, start);
if (temp2 == -1)
temp2 = buffer.Find(_ARTIST_STR, start);
}
}
}
if (temp == start)
{
// Yes. So it's assumed to be a file-global comment
if ((tuneNo == 0) && ((field == all) || ((field == comment) && (temp2 == -1))))
{
// Simply copy the stuff in
result = buffer.Mid(start);
return (true);
}
else if ((tuneNo == 0) && (field == comment))
{
// Just copy the comment
result = buffer.Mid(start, temp2 - start);
return (true);
}
else if ((tuneNo == 1) && (temp2 != -1))
{
// A specific field was asked for
return (GetOneField(result, buffer.Mid(temp2), field));
}
else
{
// Anything else is invalid as of v2.00
return (false);
}
}
else
{
// No. Handle it as a regular entry
if ((field == all) && ((tuneNo == 0) || (tuneNo == 1)))
{
// The complete entry was asked for. Simply copy the stuff in
result = buffer.Mid(start);
return (true);
}
else if (tuneNo == 1)
{
// A specific field was asked for
return (GetOneField(result, buffer.Mid(start), field));
}
else
{
// Anything else is invalid as of v2.00
return (false);
}
}
}
else
{
//-----------------//
// MULTITUNE ENTRY //
//-----------------//
int32 myTuneNo, nextTuneNo;
PString tuneNoStr;
// Was the complete entry asked for?
if (tuneNo == 0)
{
switch (field)
{
case all:
{
// Yes. Simply copy the stuff in
result = buffer.Mid(start);
return (true);
}
case comment:
{
// Only the file-global comment field was asked for
if (firstTuneNo != start)
return (GetOneField(result, buffer.Mid(start, firstTuneNo - start), comment));
else
return (false);
}
default:
{
// If a specific field other than a comment is
// asked for tuneNo=0, this is illegal
return (false);
}
}
}
// Search for the requested tune number
tuneNoStr.Format("(#%d)", tuneNo);
myTuneNo = buffer.Find(tuneNoStr, start);
if (myTuneNo != -1)
{
// We found the requested tune number.
// Set the pointer beyond it
myTuneNo = buffer.Find('\n', myTuneNo) + 1;
// Where is the next one?
nextTuneNo = buffer.Find("\n(#", myTuneNo);
if (nextTuneNo == -1)
{
// There is no next one - set pointer to the end of entry
nextTuneNo = buffer.GetLength();
}
else
{
// The search included the \n - go beyond it
nextTuneNo++;
}
// Put the desired fields into the result (which may be 'all')
PString tempResult;
bool retVal;
retVal = GetOneField(tempResult, buffer.Mid(myTuneNo, nextTuneNo - myTuneNo), field);
result += tempResult;
return (retVal);
}
else
return (false);
}
}
bool SIDStil::PositionToEntry(PString entryStr, PFile *inFile, PList<DirList *> &dirs)
{
DirList *item = NULL;
int32 slashIndex;
int32 startPos;
int32 i, count;
int32 pathLen, entryStrLen;
PString line;
bool foundIt = false;
bool globComm = false;
bool temp;
PCharSet_MS_WIN_1252 charSet;
try
{
// Seek to the start of the file
inFile->SeekToBegin();
// Get the dirpath
slashIndex = entryStr.ReverseFind('/');
// If no slash was found, something is screwed up in the entryStr
if (slashIndex == -1)
return (false);
pathLen = slashIndex + 1;
// Determine whether a section-global comment is asked for
entryStrLen = entryStr.GetLength();
if (pathLen == entryStrLen)
globComm = true;
// Find it in the table
count = dirs.CountItems();
for (i = 0; i < count; i++)
{
item = dirs.GetItem(i);
if (entryStr.Left(pathLen) == item->dirName)
{
foundIt = true;
break;
}
}
if (!foundIt)
{
// The directory was not found
return (false);
}
// Jump to the first entry of this section
inFile->Seek(item->position, PFile::pSeekBegin);
foundIt = false;
// Now find the desired entry
do
{
startPos = inFile->GetPosition();
line = inFile->ReadLine(&charSet);
if (inFile->IsEOF())
break;
// Check if it is the start of an entry
if (!line.IsEmpty() && (line.GetAt(0) == '/'))
{
if (line.Left(pathLen) != item->dirName)
{
// We are outside the section - get out of the loop,
// which will fail the search
break;
}
// Check whether we need to find a section-global comment or
// a specific entry
if (globComm || (stilVersion > 2.59f))
temp = (line == entryStr);
else
{
// To be compatible with older versions of STIL, which may have
// the tune designation on the first line of a STIL entry
// together with the pathname
temp = (line.Left(entryStrLen) == entryStr);
}
if (temp)
{
// Found it!
foundIt = true;
}
}
}
while (!foundIt);
if (foundIt)
{
// Reposition the file pointer back to the start of the entry
inFile->Seek(startPos, PFile::pSeekBegin);
return (true);
}
}
catch(PFileException e)
{
;
}
return (false);
}
PString SIDStil::GetGlobalComment(PString relPathToEntry)
{
PString dir;
int32 lastSlash, pathLen;
int32 temp;
if (baseDir.IsEmpty())
return ("");
// Save the dirpath
lastSlash = relPathToEntry.ReverseFind('/');
if (lastSlash == -1)
return ("");
pathLen = lastSlash + 1;
dir = relPathToEntry.Left(pathLen);
// Find out whether we have this global comment in the buffer.
// If the baseDir was changed, we'll have to read it in again,
// even if it might be in the buffer already
if ((globalBuf.Left(dir.GetLength()) != dir) || ((globalBuf.Find('\n') != pathLen) && (stilVersion > 2.59f)))
{
// The relative pathnames don't match or they're not the same length:
// We don't have it in the buffer, so pull it in
try
{
PDirectory tempDir;
tempDir.SetDirectory(baseDir);
tempDir.Append("DOCUMENTS");
stilFile->Open(tempDir.GetDirectory() + "STIL.txt", PFile::pModeRead | PFile::pModeShareRead);
if (PositionToEntry(dir, stilFile, stilDirs) == false)
{
// Copy the dirname to the buffer
globalBuf = dir + "\n";
}
else
{
globalBuf.MakeEmpty();
ReadEntry(stilFile, globalBuf);
}
stilFile->Close();
}
catch(PFileException e)
{
// Failed reading from the STIL.txt file
stilFile->Close();
return ("");
}
}
// Position the index to the global comment field
temp = globalBuf.Find('\n');
temp++;
// Check whether this is a NULL entry or not
if (temp == globalBuf.GetLength())
return ("");
return (globalBuf.Mid(temp));
}
bool SIDStil::GetOneField(PString &result, PString buffer, STILField field)
{
int32 temp = -1;
// Sanity check
if (buffer.GetAt(buffer.GetLength() - 1) != '\n')
{
result.MakeEmpty();
return (false);
}
switch (field)
{
case all:
result += buffer;
return (true);
case name:
temp = buffer.Find(_NAME_STR);
break;
case author:
temp = buffer.Find(_AUTHOR_STR);
break;
case title:
temp = buffer.Find(_TITLE_STR);
break;
case artist:
temp = buffer.Find(_ARTIST_STR);
break;
case comment:
temp = buffer.Find(_COMMENT_STR);
break;
default:
break;
}
// If the field was not found or it is not in between 'start'
// and 'end', it is declared a failure
if (temp == -1)
{
result.MakeEmpty();
return (false);
}
// Search for the end of this field. This is done by finding
// where the next field starts
int32 nextName, nextAuthor, nextTitle, nextArtist, nextComment, nextField;
nextName = buffer.Find(_NAME_STR, temp + 1);
nextAuthor = buffer.Find(_AUTHOR_STR, temp + 1);
nextTitle = buffer.Find(_TITLE_STR, temp + 1);
nextArtist = buffer.Find(_ARTIST_STR, temp + 1);
nextComment = buffer.Find(_COMMENT_STR, temp + 1);
// Now determine which one is the closest to our field - that one
// will mark the end of the required field
nextField = nextName;
if (nextField == -1)
nextField = nextAuthor;
else if ((nextAuthor != -1) && (nextAuthor < nextField))
nextField = nextAuthor;
if (nextField == -1)
nextField = nextTitle;
else if ((nextTitle != -1) && (nextTitle < nextField))
nextField = nextTitle;
if (nextField == -1)
nextField = nextArtist;
else if ((nextArtist != -1) && (nextArtist < nextField))
nextField = nextArtist;
if (nextField == -1)
nextField = nextComment;
else if ((nextComment != -1) && (nextComment < nextField))
nextField = nextComment;
if (nextField == -1)
nextField = buffer.GetLength();
// Now nextField points to the last+1 char that should be copied to
// result. Do that
result += buffer.Mid(temp, nextField - temp);
return (true);
}
