OsStatus OsFileBase::getPosition(size_t &pos)
{
OsLock lock(fileMutex);
pos = (size_t) UTL_NOT_FOUND;
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::getPosition ENTER threadid=%ld\n", nTaskId);
#endif
OsStatus stat = OS_INVALID;
if (mOsFileHandle)
{
pos = ftell(mOsFileHandle);
if (pos != (size_t)UTL_NOT_FOUND)
{
stat = OS_SUCCESS;
}
}
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::getPosition EXIT threadid=%ld\n", nTaskId);
#endif
return stat;
}
OsStatus OsFileBase::readLine(UtlString &str)
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::readLine ENTER threadid=%ld\n", nTaskId);
#endif
char buf[2];
size_t bytesRead;
OsStatus retstat = OS_INVALID;
buf[1] = '\0';
str.remove(0);
do
{
retstat = read(buf, 1, bytesRead);
if (retstat == OS_SUCCESS && (*buf != '\n' && *buf != '\r'))
{
str.append(buf, 1);
}
} while (retstat == OS_SUCCESS && bytesRead == 1 && *buf != '\n');
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::readLine EXIT threadid=%ld\n", nTaskId);
#endif
return retstat;
}
OsStatus OsFileBase::getLength(size_t& flength)
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::getLength ENTER threadid=%ld\n", (long)nTaskId);
#endif
OsStatus ret = OS_INVALID;
size_t saved_pos;
if (getPosition(saved_pos) == OS_SUCCESS)
{
if (setPosition(0,END) == OS_SUCCESS)
{
if (getPosition(flength) == OS_SUCCESS)
{
if (setPosition(saved_pos,START) == OS_SUCCESS)
{
ret = OS_SUCCESS;
}
}
}
}
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::getLength EXIT threadid=%ld\n", (long)nTaskId);
#endif
return ret;
}
OsStatus OsFileBase::setPosition(ssize_t pos, FilePositionOrigin origin)
{
OsLock lock(fileMutex);
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::setPosition ENTER threadid=%ld\n", nTaskId);
#endif
OsStatus stat = OS_INVALID;
if (mOsFileHandle)
{
int startloc = -1;
if (origin == START)
startloc = SEEK_SET;
else
if (origin == CURRENT)
startloc = SEEK_CUR;
else
if (origin == END)
startloc = SEEK_END;
if (startloc != -1 && fseek(mOsFileHandle,pos,startloc) != -1)
stat = OS_SUCCESS;
}
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::setPosition EXIT threadid=%ld\n", nTaskId);
#endif
return stat;
}
OsStatus OsFileBase::read(void* buf, size_t buflen, size_t& bytesRead)
{
OsLock lock(fileMutex);
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::read ENTER threadid=%ld\n", nTaskId);
#endif
OsStatus stat = OS_INVALID;
if (mOsFileHandle)
{
bytesRead = ::fread(buf,1,buflen,mOsFileHandle);
if (bytesRead == 0 && feof(mOsFileHandle))
stat = OS_FILE_EOF;
else
stat = OS_SUCCESS;
if (ferror(mOsFileHandle))
stat = OS_FILE_INVALID_HANDLE;
}
else
stat = OS_FILE_INVALID_HANDLE;
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::read EXIT threadid=%ld\n", nTaskId);
#endif
return stat;
}
UtlBoolean SipProtocolServerBase::send(SipMessage* message,
const char* hostAddress,
int hostPort)
{
UtlBoolean sendOk = FALSE;
UtlString localIp(message->getLocalIp());
if (localIp.length() < 1)
{
localIp = mDefaultIp;
}
SipClient* client = createClient(hostAddress, hostPort, localIp);
if(client)
{
int isBusy = client->isInUseForWrite();
UtlString clientNames;
client->getClientNames(clientNames);
OsSysLog::add(FAC_SIP, PRI_DEBUG, "Sip%sServerBase::send %p isInUseForWrite %d, client info\n %s",
mProtocolString.data(), client, isBusy, clientNames.data());
sendOk = client->sendTo(*message, hostAddress, hostPort);
if(!sendOk)
{
OsTask* pCallingTask = OsTask::getCurrentTask();
OsTaskId_t callingTaskId = -1;
OsTaskId_t clientTaskId = -1;
if ( pCallingTask )
{
pCallingTask->id(callingTaskId);
}
client->id(clientTaskId);
if (clientTaskId != callingTaskId)
{
// Do not need to clientLock.acquireWrite();
// as deleteClient uses the locking list lock
// which is all that is needed as the client is
// already marked as busy when we called
// createClient above.
deleteClient(client);
client = NULL;
}
}
}
if(client)
{
releaseClient(client);
}
return(sendOk);
}
// Destructor
OsFileBase::~OsFileBase()
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::~OsFileBase ENTER threadid=%ld\n", (long)nTaskId);
#endif
if (mOsFileHandle)
close(); //call our close
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::~OsFileBase EXIT threadid=%ld\n", (long)nTaskId);
#endif
}
OsStatus OsFileBase::fileunlock()
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::fileunlock ENTER threadid=%ld\n", (long)nTaskId);
#endif
OsStatus retval = OS_SUCCESS;
//no file locking on the base class (yet) (I'm doing linux and windows first)
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::fileunlock EXIT threadid=%ld\n", (long)nTaskId);
#endif
return retval;
}
OsStatus OsFileBase::setLength(unsigned long newLength)
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::setLength ENTER threadid=%ld\n", nTaskId);
#endif
OsStatus stat = OS_SUCCESS;
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::setLength EXIT threadid=%ld\n", nTaskId);
#endif
return stat;
}
void OsFileBase::getFileName(OsPathBase& rOsPath) const
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::getFileName ENTER threadid=%ld\n", nTaskId);
#endif
rOsPath = mFilename;
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::getFileName EXIT threadid=%ld\n", nTaskId);
#endif
}
OsStatus OsFileBase::setReadOnly(UtlBoolean isReadOnly)
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::setReadOnly ENTER threadid=%ld\n", (long)nTaskId);
#endif
OsStatus status = OsFileSystem::setReadOnly(mFilename,isReadOnly);
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::setReadOnly EXIT threadid=%ld\n", (long)nTaskId);
#endif
return status;
}
// Print semaphore information to the console
void OsBSemWnt::OsBSemShow(void)
{
char* pOptionStr;
char* pSemState;
char* pTaskName;
#ifdef OS_SYNC_DEBUG
UtlString taskName;
OsTask* pTask;
#endif
switch (mOptions)
{
case Q_FIFO:
pOptionStr = "Q_FIFO";
break;
case Q_PRIORITY:
pOptionStr = "Q_PRIORITY";
break;
default:
pOptionStr = "UNKNOWN";
break;
}
#ifdef OS_SYNC_DEBUG
pSemState = (mTaskId == 0) ? "AVAILABLE" : "TAKEN";
if (mTaskId != 0)
{
pTask = OsTask::getTaskById(mTaskId);
taskName = pTask->getName();
pTaskName = (char*) taskName.data();
}
else
{
pTaskName = "N/A";
}
#else
pSemState = "UNKNOWN";
pTaskName = "UNKNOWN";
#endif
osPrintf("OsBSem object 0x%08x, semOptions=%s, state=%s, heldBy=%s\n",
(void *) this, pOptionStr, pSemState, pTaskName);
#ifdef OS_SYNC_DEBUG
taskName.remove(0);
#endif
}
UtlBoolean OsFileBase::close()
{
OsLock lock(fileMutex);
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
int fd = -1;
if (mOsFileHandle) fd = fileno(mOsFileHandle);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::close ENTER mOsFileHandle=0x%08x, fd=%d, threadid=%ld, filename=%s\n", mOsFileHandle, fd, (long)nTaskId, mFilename.data());
#endif
UtlBoolean retval = TRUE;
if (mOsFileHandle)
{
#ifndef _VXWORKS // 6/27/03 - Bob - Disabling locking under vxworks - crashes
// get the thread ID for local locking
char* pLockName = new char[mFilename.length() + PID_STR_LEN];
sprintf(pLockName, "%s%ld", mFilename.data(), (long)mLocalLockThreadId);
// remove any local process locks
getFileLocks()->remove(pLockName);
mLocalLockThreadId = INVALID_PID;
delete[] pLockName;
#endif
if (::fclose(mOsFileHandle) != 0)
{
retval = FALSE;
Os::Logger::instance().log(FAC_KERNEL, PRI_WARNING,
"OsFileBase::close failed, mOsFileHandle=%p, errno=%d '%s'",
mOsFileHandle, errno, strerror(errno));
}
mOsFileHandle = 0;
}
//remove any process locks
fileunlock();
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::close EXIT threadid=%ld\n", (long)nTaskId);
#endif
return retval;
}
UtlBoolean OsFileBase::isReadonly() const
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::isReadonly ENTER threadid=%ld\n", (long)nTaskId);
#endif
OsFileInfoBase info;
getFileInfo(info);
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::isReadonly EXIT threadid=%ld\n", (long)nTaskId);
#endif
return info.mbIsReadOnly;
}
// Copy constructor
OsFileBase::OsFileBase(const OsFileBase& rOsFileBase)
: fileMutex(OsMutex::Q_FIFO),
mFilename("")
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::OsFileBase ENTER threadid=%ld\n", (long)nTaskId);
#endif
OsPathBase path;
rOsFileBase.getFileName(path);
mFilename = path;
mOsFileHandle = rOsFileBase.mOsFileHandle;
mLocalLockThreadId = rOsFileBase.mLocalLockThreadId;
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::OsFileBase EXIT threadid=%ld\n", (long)nTaskId);
#endif
}
OsStatus OsFileBase::rename(const OsPathBase& rNewFilename)
{
OsLock lock(fileMutex);
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::rename ENTER threadid=%ld\n", nTaskId);
#endif
OsStatus ret = OS_INVALID;
//if it's open then close it
close();
int err = ::rename(mFilename.data(),rNewFilename.data());
if (err != -1)
{
ret = OS_SUCCESS;
}
else
{
// Rename failed, if there is a file that already exists having
// the new name, try removing it first
OsFile fileInPlace(rNewFilename);
if(fileInPlace.exists())
{
fileInPlace.remove(TRUE);
// Try the move again
int err2 = ::rename(mFilename.data(),rNewFilename.data());
if (err2 != -1)
{
ret = OS_SUCCESS;
}
}
}
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::rename EXIT threadid=%ld\n", nTaskId);
#endif
return ret;
}
OsStatus OsFileBase::remove(UtlBoolean bForce)
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::remove ENTER threadid=%ld\n", nTaskId);
#endif
OsStatus ret = OS_INVALID;
//if it's open then close it
close();
ret = OsFileSystem::remove(mFilename.data(),FALSE,bForce);
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::remove EXIT threadid=%ld\n", nTaskId);
#endif
return ret;
}
UtlBoolean OsFileBase::exists()
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::exists ENTER threadid=%ld\n", (long)nTaskId);
#endif
UtlBoolean stat = FALSE;
OsFileInfo info;
OsStatus retval = getFileInfo(info);
if (retval == OS_SUCCESS)
stat = TRUE;
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::exists EXIT threadid=%ld\n", (long)nTaskId);
#endif
return stat;
}
// Fires events to interested parties
void MpStreamFeeder::fireEvent(FeederEvent eventType)
{
OsLock lock(m_eventGuard) ;
#ifdef MP_STREAM_DEBUG /* [ */
osPrintf("MpStreamFeeder(%d): %s\n", m_iInstanceId, getEventString(eventType)) ;
#endif /* MP_STREAM_DEBUG ] */
if (m_pEventHandler != NULL)
{
m_pEventHandler->signal(eventType) ;
// Safe guard: once the destroyed event is signalled, the
// m_pEventHandler can be deleted.
if (eventType == FeederStreamDestroyedEvent)
{
m_pEventHandler = NULL ;
}
#ifdef MP_STREAM_DEBUG /* [ */
pthread_t taskId = -1 ;
OsTask *pTask = OsTask::getCurrentTask() ;
if (pTask != NULL)
{
pTask->id(taskId) ;
}
osPrintf("MpStreamFeeder(%d-%08X): signaled event: %s\n",
m_iInstanceId, taskId, getEventString(eventType)) ;
#endif /* MP_STREAM_DEBUG ] */
}
#ifdef MP_STREAM_DEBUG /* [ */
else
{
osPrintf("** WARNING: Null handler for event: %s\n", getEventString(eventType)) ;
}
#endif /* MP_STREAM_DEBUG ] */
}
OsStatus OsFileBase::flush()
{
OsLock lock(fileMutex);
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::flush EXIT threadid=%ld\n", nTaskId);
#endif
OsStatus stat = OS_INVALID;
if (mOsFileHandle)
{
if (fflush(mOsFileHandle) == 0)
stat = OS_SUCCESS;
}
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::flush EXIT threadid=%ld\n", nTaskId);
#endif
return stat;
}
OsStatus OsFileBase::write(const void* buf, size_t buflen, size_t& bytesWritten)
{
OsLock lock(fileMutex);
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::write ENTER threadid=%ld\n", nTaskId);
#endif
OsStatus stat = OS_INVALID;
if (mOsFileHandle)
bytesWritten = ::fwrite(buf,1,buflen,mOsFileHandle);
if (bytesWritten == buflen)
stat = OS_SUCCESS;
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::write EXIT threadid=%ld\n", nTaskId);
#endif
return stat;
}
OsStatus OsFileBase::touch()
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::touch ENTER threadid=%ld\n", nTaskId);
#endif
OsStatus stat = OS_INVALID;
char buf[5];
size_t BytesRead;
size_t BytesWritten;
//open read one byte, write it back, then close
//hope this is what we need to do for touch
if (exists() && open() == OS_SUCCESS)
{
if (read(buf,1,BytesRead) == OS_SUCCESS)
{
setPosition(0);
if (write(buf,BytesRead,BytesWritten) == OS_SUCCESS)
stat = OS_SUCCESS;
}
close();
}
else
{
open(CREATE);
close();
stat = OS_SUCCESS;
}
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::touch EXIT threadid=%ld\n", nTaskId);
#endif
return stat;
}
/* ============================ INQUIRY =================================== */
UtlBoolean OsFileBase::isEOF()
{
OsLock lock(fileMutex);
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::isEOF ENTER threadid=%ld\n", (long)nTaskId);
#endif
UtlBoolean retval = FALSE;
if (mOsFileHandle)
{
if (feof(mOsFileHandle))
retval = TRUE;
}
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::isEOF EXIT threadid=%ld\n", (long)nTaskId);
#endif
return retval;
}
UtlBoolean SipTransactionList::waitUntilAvailable(SipTransaction* transaction,
const UtlString& hash)
{
UtlBoolean exists;
UtlBoolean busy = FALSE;
int numTries = 0;
do
{
numTries++;
lock();
exists = transactionExists(transaction, hash);
if(exists)
{
busy = transaction->isBusy();
if(!busy)
{
transaction->markBusy();
unlock();
//#ifdef TEST_PRINT
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipTransactionList::waitUntilAvailable %p locked after %d tries\n",
transaction, numTries);
//#endif
}
else
{
// We set an event to be signaled when a
// transaction is released.
OsEvent* waitEvent = new OsEvent;
transaction->notifyWhenAvailable(waitEvent);
// Must unlock while we wait or there is a dead lock
unlock();
//#ifdef TEST_PRINT
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipTransactionList::waitUntilAvailable %p waiting on: %p after %d tries\n",
transaction, waitEvent, numTries);
//#endif
OsStatus waitStatus;
OsTime transBusyTimeout(1, 0);
int waitTime = 0;
do
{
if(waitTime > 0)
OsSysLog::add(FAC_SIP, PRI_WARNING, "SipTransactionList::waitUntilAvailable %p still waiting: %d",
transaction, waitTime);
waitStatus = waitEvent->wait(transBusyTimeout);
waitTime+=1;
}
while(waitStatus != OS_SUCCESS && waitTime < 30);
// If we were never signaled, then we signal the
// event so the other side knows that it has to
// free up the event
if(waitEvent->signal(-1) == OS_ALREADY_SIGNALED)
{
delete waitEvent;
waitEvent = NULL;
}
// If we bailed out before the event was signaled
// pretend the transaction does not exist.
if(waitStatus != OS_SUCCESS)
{
exists = FALSE;
}
if(waitTime > 1)
{
if (OsSysLog::willLog(FAC_SIP, PRI_WARNING))
{
UtlString transTree;
UtlString waitingTaskName;
OsTask* waitingTask = OsTask::getCurrentTask();
if(waitingTask) waitingTaskName = waitingTask->getName();
transaction->dumpTransactionTree(transTree, FALSE);
OsSysLog::add(FAC_SIP, PRI_WARNING, "SipTransactionList::waitUntilAvailable status: %d wait time: %d transaction: %p task: %s transaction tree: %s",
waitStatus, waitTime, transaction, waitingTaskName.data(), transTree.data());
}
}
//#ifdef TEST_PRINT
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipTransactionList::waitUntilAvailable %p done waiting after %d tries\n",
transaction, numTries);
//#endif
}
}
else
{
unlock();
//#ifdef TEST_PRINT
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipTransactionList::waitUntilAvailable %p gone after %d tries\n",
transaction, numTries);
//#endif
}
}
while(exists && busy);
return(exists && !busy);
}
OsStatus OsFileBase::open(const int mode)
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::open ENTER threadid=%ld, filename=%s\n", (long)nTaskId, mFilename.data());
#endif
//get a lock for the open call
sOpenLock.acquire();
OsStatus stat = OS_INVALID;
const char* fmode = "";
if (mode & CREATE)
{
fmode = "wb+";
}
if (mode & READ_ONLY)
fmode = "rb";
if (mode & WRITE_ONLY)
fmode = "wb";
if (mode & READ_WRITE)
fmode = "rb+";
if (mode & APPEND)
fmode = "ab+";
if (mode & TRUNCATE)
fmode = "wb";
mOsFileHandle = fopen(mFilename.data(),fmode);
#ifndef _VXWORKS // 6/27/03 - Bob - Disabling locking under vxworks - crashes
//success
if (mOsFileHandle)
{
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::open fopen returned mOsFileHandle=0x%08x, fd=%d, threadid=%d, filename=%s\n", mOsFileHandle, fileno(mOsFileHandle), nTaskId, mFilename.data());
#endif
//first test to see if we have a local file lock on that file
//get the thread id for local locking
mLocalLockThreadId = OsProcess::getCurrentPID();
char* pLockName = new char[mFilename.length() + PID_STR_LEN];
sprintf(pLockName, "%s%ld", mFilename.data(), (long)mLocalLockThreadId);
UtlString rValue;
if (getFileLocks()->get(pLockName,rValue) == OS_SUCCESS)
{
//if we want read and someone else is already reading then it's ok
if (rValue == "RL" && (mode & READ_ONLY))
stat = OS_SUCCESS;
else
if (rValue == "WL" && (mode & FSLOCK_WAIT))
{
//we need to wait until the lock is freed
UtlBoolean lockFree = FALSE;
do
{
OsTask::delay(OsFileLockTimeout);
if (getFileLocks()->get(pLockName,rValue) != OS_SUCCESS)
{
lockFree = TRUE;
stat = OS_SUCCESS;
}
} while (lockFree == FALSE);
}
else
{
fclose(mOsFileHandle);
mOsFileHandle = NULL;
mLocalLockThreadId = INVALID_PID;
stat = OS_FILE_ACCESS_DENIED;
}
}
else
{
rValue = "RL";
if (mode & FSLOCK_WRITE)
rValue = "WL";
getFileLocks()->set(pLockName,rValue);
stat = OS_SUCCESS;
}
//if the lock is ok at this point, we need to get a cross process lock
if (stat == OS_SUCCESS)
{
stat = filelock(mode); //returns success if no file sharing specified
if (stat != OS_SUCCESS)
{
::fclose(mOsFileHandle);
mOsFileHandle = NULL;
mLocalLockThreadId = INVALID_PID;
stat = OS_FILE_ACCESS_DENIED;
//remove local process locks
getFileLocks()->remove(pLockName);
}
}
delete[] pLockName;
}
else
{
switch(errno)
{
case EACCES:
case EMFILE:
stat = OS_FILE_ACCESS_DENIED;
break;
case ENOENT:
stat = OS_FILE_NOT_FOUND;
break;
default:
break;
}
}
#else
if (mOsFileHandle)
{
stat = OS_SUCCESS;
}
#endif
sOpenLock.release();
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::open EXIT threadid=%ld\n", nTaskId);
#endif
return stat;
}
OsStatus OsFileBase::copy(const OsPathBase& newFilename)
{
#ifdef DEBUG_FS
pthread_t nTaskId = 0;
OsTask* pTask = OsTask::getCurrentTask();
if (pTask) pTask->id(nTaskId);
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::copy ENTER threadid=%ld\n", nTaskId);
#endif
OsStatus ret = OS_FILE_WRITE_FAILED;
size_t copySize = 0;
size_t totalBytesRead = 0;
size_t totalBytesWritten = 0;
size_t BytesRead = 0;
size_t BytesWritten = 0;
UtlBoolean bError = FALSE;
OsFile newFile(newFilename);
char *buf = new char[CopyBufLen];
if (buf)
{
//open existsing file
if (open() == OS_SUCCESS)
{
if (getLength(copySize) == OS_SUCCESS)
{
//open new file
newFile.open(CREATE);
while ((totalBytesRead < copySize) && !bError)
{
//read in one block
if (read(buf,CopyBufLen,BytesRead) == OS_SUCCESS)
{
totalBytesRead += BytesRead;
if (newFile.write(buf,BytesRead,BytesWritten) == OS_SUCCESS)
{
if (BytesWritten != BytesRead)
{
bError = TRUE;
}
else
totalBytesWritten += BytesWritten;
}
else
{
bError = TRUE;
}
}
else
bError = TRUE;
}
if (!bError)
ret = OS_SUCCESS;
newFile.close();
}
close();
}
delete [] buf;
}
#ifdef DEBUG_FS
Os::Logger::instance().log(FAC_KERNEL, PRI_DEBUG, "OsFileBase::copy EXIT threadid=%ld\n", nTaskId);
#endif
return ret;
}
