pchannel.cxx

基于VXWORKS H323通信技术源代码

              return FALSE;
          } while (!ReceiveCommandString(nextChar,
                                     command, receivePosition, sendPosition));
//          nextChar = GetNextChar(command, receivePosition);
          sendPosition = receivePosition;
        }
    }
  }

  return FALSE;
}


BOOL PChannel::Shutdown(ShutdownValue)
{
  return FALSE;
}


PChannel * PChannel::GetBaseReadChannel() const
{
  return (PChannel *)this;
}


PChannel * PChannel::GetBaseWriteChannel() const
{
  return (PChannel *)this;
}


///////////////////////////////////////////////////////////////////////////////
// PIndirectChannel

PIndirectChannel::PIndirectChannel()
{
  readChannel = writeChannel = NULL;
  writeAutoDelete = readAutoDelete = FALSE;
}


PObject::Comparison PIndirectChannel::Compare(const PObject & obj) const
{
  PAssert(obj.IsDescendant(PIndirectChannel::Class()), PInvalidCast);
  const PIndirectChannel & other = (const PIndirectChannel &)obj;
  return readChannel == other.readChannel &&
         writeChannel == other.writeChannel ? EqualTo : GreaterThan;
}


PString PIndirectChannel::GetName() const
{
  ((PIndirectChannel*)this)->channelPointerMutex.StartRead();

  PString name;
  if (readChannel != NULL && readChannel == writeChannel)
    name = readChannel->GetName();
  else {
    name = "R<";
    if (readChannel != NULL)
      name += readChannel->GetName();
    name += "> T<";
    if (writeChannel != NULL)
      name += writeChannel->GetName();
    name += ">";
  }

  ((PIndirectChannel*)this)->channelPointerMutex.EndRead();

  return name;
}


BOOL PIndirectChannel::Close()
{
  BOOL retval = TRUE;

  flush();

  channelPointerMutex.StartRead();

  if (readChannel != NULL)
    retval = readChannel->Close();

  if (readChannel != writeChannel && writeChannel != NULL)
    retval = writeChannel->Close() && retval;

  channelPointerMutex.EndRead();

  channelPointerMutex.StartWrite();

  PChannel * r = readChannel;
  PChannel * w = writeChannel;

  readChannel = NULL;
  writeChannel = NULL;

  if (readAutoDelete)
    delete r;

  if (r != w && writeAutoDelete)
    delete w;

  channelPointerMutex.EndWrite();

  return retval;
}


BOOL PIndirectChannel::IsOpen() const
{
  ((PIndirectChannel*)this)->channelPointerMutex.StartRead();

  BOOL returnValue;
  if (readChannel != NULL && readChannel == writeChannel)
    returnValue = readChannel->IsOpen();
  else {
    returnValue = readChannel != NULL ? readChannel->IsOpen() : FALSE;
    if (writeChannel != NULL)
      returnValue = writeChannel->IsOpen() || returnValue;
  }

  ((PIndirectChannel*)this)->channelPointerMutex.EndRead();

  return returnValue;
}


BOOL PIndirectChannel::Read(void * buf, PINDEX len)
{
  flush();

  channelPointerMutex.StartRead();

  PAssert(readChannel != NULL, "Indirect read though NULL channel");

  BOOL returnValue;
  if (readChannel == NULL)
    returnValue = FALSE;
  else {
    readChannel->SetReadTimeout(readTimeout);

    returnValue = readChannel->Read(buf, len);

    lastError = readChannel->GetErrorCode();
    osError = readChannel->GetErrorNumber();
    lastReadCount = readChannel->GetLastReadCount();
  }

  channelPointerMutex.EndRead();

  return returnValue;
}


BOOL PIndirectChannel::Write(const void * buf, PINDEX len)
{
  flush();

  channelPointerMutex.StartRead();

  PAssert(writeChannel != NULL, "Indirect write though NULL channel");

  BOOL returnValue;
  if (writeChannel == NULL)
    returnValue = FALSE;
  else {
    writeChannel->SetWriteTimeout(writeTimeout);

    returnValue = writeChannel->Write(buf, len);

    lastError = writeChannel->GetErrorCode();
    osError = writeChannel->GetErrorNumber();
    lastWriteCount = writeChannel->GetLastWriteCount();
  }

  channelPointerMutex.EndRead();

  return returnValue;
}


BOOL PIndirectChannel::Shutdown(ShutdownValue value)
{
  channelPointerMutex.StartRead();

  BOOL returnValue;
  if (readChannel != NULL && readChannel == writeChannel)
    returnValue = readChannel->Shutdown(value);
  else {
    returnValue = readChannel != NULL ? readChannel->Shutdown(value) : FALSE;
    if (writeChannel != NULL)
      returnValue = writeChannel->Shutdown(value) || returnValue;
  }

  channelPointerMutex.EndRead();

  return returnValue;
}


BOOL PIndirectChannel::Open(PChannel & channel)
{
  return Open(&channel, FALSE);
}


BOOL PIndirectChannel::Open(PChannel * channel, BOOL autoDelete)
{
  return Open(channel, channel, autoDelete, autoDelete);
}


BOOL PIndirectChannel::Open(PChannel * readChan,
                            PChannel * writeChan,
                            BOOL autoDeleteRead,
                            BOOL autoDeleteWrite)
{
  Close();

  channelPointerMutex.StartWrite();

  readChannel = readChan;
  readAutoDelete = autoDeleteRead;
  writeChannel = writeChan;
  writeAutoDelete = autoDeleteWrite;

  channelPointerMutex.EndWrite();

  return IsOpen() && OnOpen();
}


BOOL PIndirectChannel::OnOpen()
{
  return TRUE;
}


BOOL PIndirectChannel::SetReadChannel(PChannel * channel, BOOL autoDelete)
{
  if (readChannel != NULL) {
    lastError = Miscellaneous;
    osError = EBADF;
    return FALSE;
  }

  channelPointerMutex.StartWrite();

  readChannel = channel;
  readAutoDelete = autoDelete;

  channelPointerMutex.EndWrite();

  return IsOpen();
}


BOOL PIndirectChannel::SetWriteChannel(PChannel * channel, BOOL autoDelete)
{
  if (writeChannel != NULL) {
    lastError = Miscellaneous;
    osError = EBADF;
    return FALSE;
  }

  channelPointerMutex.StartWrite();

  writeChannel = channel;
  writeAutoDelete = autoDelete;

  channelPointerMutex.EndWrite();

  return IsOpen();
}


PChannel * PIndirectChannel::GetBaseReadChannel() const
{
  ((PIndirectChannel*)this)->channelPointerMutex.StartRead();

  PChannel * returnValue = readChannel != NULL ? readChannel->GetBaseReadChannel() : 0;

  ((PIndirectChannel*)this)->channelPointerMutex.EndRead();

  return returnValue;
}


PChannel * PIndirectChannel::GetBaseWriteChannel() const
{
  ((PIndirectChannel*)this)->channelPointerMutex.StartRead();

  PChannel * returnValue = writeChannel != NULL ? writeChannel->GetBaseWriteChannel() : 0;

  ((PIndirectChannel*)this)->channelPointerMutex.EndRead();

  return returnValue;
}


///////////////////////////////////////////////////////////////////////////////
// PFile

PFile::~PFile()
{
  Close();
}


PObject::Comparison PFile::Compare(const PObject & obj) const
{
  PAssert(obj.IsDescendant(PFile::Class()), PInvalidCast);
  return path.Compare(((const PFile &)obj).path);
}


BOOL PFile::Rename(const PString & newname, BOOL force)
{
  Close();

  if (!ConvertOSError(Rename(path, newname, force) ? 0 : -1))
    return FALSE;

  path = path.GetDirectory() + newname;
  return TRUE;
}


BOOL PFile::Close()
{
  if (os_handle < 0) {
    osError = EBADF;
    lastError = NotOpen;
    return FALSE;
  }

  flush();

  BOOL ok = ConvertOSError(_close(os_handle));

  os_handle = -1;

  if (removeOnClose)
    Remove();

  return ok;
}


BOOL PFile::Read(void * buffer, PINDEX amount)
{
  flush();
  #if defined(P_VXWORKS)
	  lastReadCount = _read(GetHandle(), (char *)buffer, amount); // Jurjan: buffer casted to char *
  #else
  	lastReadCount = _read(GetHandle(), buffer, amount);
  #endif
  return ConvertOSError(lastReadCount) && lastReadCount > 0;
}


BOOL PFile::Write(const void * buffer, PINDEX amount)
{
  flush();
  #if defined(P_VXWORKS)
	  lastWriteCount = _write(GetHandle(), (char *)buffer, amount); // Jurjan: buffer casted to char *
  #else
	  lastWriteCount = _write(GetHandle(), buffer, amount);
  #endif
  return ConvertOSError(lastWriteCount) && lastWriteCount >= amount;
}


BOOL PFile::Open(const PFilePath & name, OpenMode  mode, int opts)
{
  Close();
  SetFilePath(name);
  return Open(mode, opts);
}


off_t PFile::GetLength() const
{
  off_t pos = _lseek(GetHandle(), 0, SEEK_CUR);
  off_t len = _lseek(GetHandle(), 0, SEEK_END);
  PAssertOS(_lseek(GetHandle(), pos, SEEK_SET) == pos);
  return len;
}


BOOL PFile::IsEndOfFile() const
{
  ((PFile *)this)->flush();
  return GetPosition() >= GetLength();
}


BOOL PFile::SetPosition(off_t pos, FilePositionOrigin origin)
{
  return _lseek(GetHandle(), pos, origin) == pos;
}


BOOL PFile::Copy(const PFilePath & oldname, const PFilePath & newname, BOOL force)
{
  PFile oldfile(oldname, ReadOnly);
  if (!oldfile.IsOpen())
    return FALSE;

  PFile newfile(newname,
                   WriteOnly, Create|Truncate|(force ? MustExist : Exclusive));
  if (!newfile.IsOpen())
    return FALSE;

  PCharArray buffer(10000);

  off_t amount = oldfile.GetLength();
  while (amount > 10000) {
    if (!oldfile.Read(buffer.GetPointer(), 10000))
      return FALSE;
    if (!newfile.Write((const char *)buffer, 10000))
      return FALSE;
    amount -= 10000;
  }

  if (!oldfile.Read(buffer.GetPointer(), (int)amount))
    return FALSE;
  if (!newfile.Write((const char *)buffer, (int)amount))
    return FALSE;

  return newfile.Close();
}


// End Of File ///////////////////////////////////////////////////////////////