开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
pchannel.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：19k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

pchannel.cxx：源码内容
  1. /*
  2.  * pchannel.cxx
  3.  *
  4.  * Operating System utilities.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: pchannel.cxx,v $
  30.  * Revision 1.7  2000/06/26 11:17:20  robertj
  31.  * Nucleus++ port (incomplete).
  32.  *
  33.  * Revision 1.6  1999/07/06 08:55:05  robertj
  34.  * Fixed bug in PFile::Copy, does not write last chunk of data to new file.
  35.  *
  36.  * Revision 1.5  1999/06/17 14:44:42  robertj
  37.  * Fixed incorrect comparison of open write channel
  38.  *
  39.  * Revision 1.4  1999/06/17 13:38:11  robertj
  40.  * Fixed race condition on indirect channel close, mutex needed in PIndirectChannel.
  41.  *
  42.  * Revision 1.3  1999/02/22 10:10:12  robertj
  43.  * Changed channel output flush to remove double Write() call.
  44.  *
  45.  * Revision 1.2  1999/01/31 00:57:18  robertj
  46.  * Fixed bug when opening an already open file, should close it!
  47.  *
  48.  * Revision 1.1  1998/11/30 12:46:19  robertj
  49.  * Initial revision
  50.  *
  51.  */
  53. #include <ptlib.h>
  55. #include <ctype.h>
  58. ///////////////////////////////////////////////////////////////////////////////
  59. // PChannel
  61. PChannelStreamBuffer::PChannelStreamBuffer(PChannel * chan)
  62.   : channel(PAssertNULL(chan))
  63. {
  64. }
  67. int PChannelStreamBuffer::overflow(int c)
  68. {
  69.   if (pbase() == NULL) {
  70.     if (eback() == 0)
  71.       setp(buffer, &buffer[sizeof(buffer)]);
  72.     else {
  73.       char * halfway = &buffer[sizeof(buffer)/2];
  74.       setp(buffer, halfway);
  75.       setg(halfway, &buffer[sizeof(buffer)], &buffer[sizeof(buffer)]);
  76.     }
  77.   }
  79.   int bufSize = pptr() - pbase();
  80.   if (bufSize > 0) {
  81.     setp(pbase(), epptr());
  82.     if (!channel->Write(pbase(), bufSize))
  83.       return EOF;
  84.   }
  86.   if (c != EOF) {
  87.     *pptr() = (char)c;
  88.     pbump(1);
  89.   }
  91.   return 0;
  92. }
  95. int PChannelStreamBuffer::underflow()
  96. {
  97.   if (eback() == NULL) {
  98.     if (pbase() == 0)
  99.       setg(buffer, &buffer[sizeof(buffer)], &buffer[sizeof(buffer)]);
  100.     else {
  101.       char * halfway = &buffer[sizeof(buffer)/2];
  102.       setp(buffer, halfway);
  103.       setg(halfway, &buffer[sizeof(buffer)], &buffer[sizeof(buffer)]);
  104.     }
  105.   }
  107.   if (gptr() != egptr())
  108.     return (BYTE)*gptr();
  110.   if (!channel->Read(eback(), egptr() - eback()) ||
  111.                                   channel->GetErrorCode() != PChannel::NoError)
  112.     return EOF;
  114.   PINDEX count = channel->GetLastReadCount();
  115.   char * p = egptr() - count;
  116.   memmove(p, eback(), count);
  117.   setg(eback(), p, egptr());
  118.   return (BYTE)*p;
  119. }
  122. int PChannelStreamBuffer::sync()
  123. {
  124.   int inAvail = egptr() - gptr();
  125.   if (inAvail > 0) {
  126.     setg(eback(), egptr(), egptr());
  127.     if (channel->IsDescendant(PFile::Class()))
  128.       ((PFile *)channel)->SetPosition(-inAvail, PFile::Current);
  129.   }
  131.   if (pptr() > pbase())
  132.     return overflow();
  134.   return 0;
  135. }
  138. streampos PChannelStreamBuffer::seekoff(streamoff off,
  139. #ifdef __MWERKS__
  140.                                         ios::seekdir dir, ios::openmode)
  141. #else
  142.                                         ios::seek_dir dir, int)
  143. #endif
  144. {
  145.   sync();
  146.   if (!channel->IsDescendant(PFile::Class()))
  147.     return -1;
  148.   ((PFile *)channel)->SetPosition(off, (PFile::FilePositionOrigin)dir);
  149.   return ((PFile *)channel)->GetPosition();
  150. }
  153. PChannel::PChannel()
  154.   : readTimeout(PMaxTimeInterval), writeTimeout(PMaxTimeInterval)
  155. {
  156.   os_handle = -1;
  157.   osError = 0;
  158.   lastError = NoError;
  159.   lastReadCount = lastWriteCount = 0;
  160.   init(new PChannelStreamBuffer(this));
  161.   Construct();
  162. }
  165. PChannel::~PChannel()
  166. {
  167.   flush();
  168.   Close();
  169.   delete (PChannelStreamBuffer *)rdbuf();
  170.   init(NULL);
  171. }
  174. BOOL PChannel::IsOpen() const
  175. {
  176.   return os_handle >= 0;
  177. }
  180. int PChannel::ReadChar()
  181. {
  182.   BYTE c;
  183.   BOOL retVal = Read(&c, 1);
  184.   return (retVal && lastReadCount == 1) ? c : -1;
  185. }
  188. int PChannel::ReadCharWithTimeout(PTimeInterval & timeout)
  189. {
  190.   SetReadTimeout(timeout);
  191.   PTimeInterval startTick = PTimer::Tick();
  192.   int c;
  193.   if ((c = ReadChar()) < 0) // Timeout or aborted
  194.     return -1;
  195.   timeout -= PTimer::Tick() - startTick;
  196.   return c;
  197. }
  200. BOOL PChannel::ReadBlock(void * buf, PINDEX len)
  201. {
  202.   char * ptr = (char *)buf;
  203.   PINDEX numRead = 0;
  205.   while (numRead < len && Read(ptr+numRead, len - numRead))
  206.     numRead += lastReadCount;
  208.   lastReadCount = numRead;
  210.   return lastReadCount == len;
  211. }
  214. PString PChannel::ReadString(PINDEX len)
  215. {
  216.   PString str;
  217.   ReadBlock(str.GetPointer(len+1), len);
  218.   str.SetSize(lastReadCount+1);
  219.   return str;
  220. }
  223. BOOL PChannel::WriteString(const PString & str)
  224. {
  225.   const char * ptr = str;
  226.   PINDEX len = 0, slen = str.GetLength();
  228.   while (len < slen && Write(ptr+len, slen - len))
  229.     len += lastWriteCount;
  231.   return len == slen;
  232. }
  235. BOOL PChannel::ReadAsync(void * buf, PINDEX len)
  236. {
  237.   BOOL retVal = Read(buf, len);
  238.   OnReadComplete(buf, lastReadCount);
  239.   return retVal;
  240. }
  243. void PChannel::OnReadComplete(void *, PINDEX)
  244. {
  245. }
  248. BOOL PChannel::WriteChar(int c)
  249. {
  250.   PAssert(c >= 0 && c < 256, PInvalidParameter);
  251.   char buf = (char)c;
  252.   return Write(&buf, 1);
  253. }
  256. BOOL PChannel::WriteAsync(const void * buf, PINDEX len)
  257. {
  258.   BOOL retVal = Write(buf, len);
  259.   OnWriteComplete(buf, lastWriteCount);
  260.   return retVal;
  261. }
  264. void PChannel::OnWriteComplete(const void *, PINDEX)
  265. {
  266. }
  269. enum {
  270.   NextCharEndOfString = -1,
  271.   NextCharDelay = -2,
  272.   NextCharSend = -3,
  273.   NextCharWait = -4
  274. };
  277. static int HexDigit(char c)
  278. {
  279.   if (!isxdigit(c))
  280.     return 0;
  282.   int hex = c - '0';
  283.   if (hex < 10)
  284.     return hex;
  286.   hex -= 'A' - '9' - 1;
  287.   if (hex < 16)
  288.     return hex;
  290.   return hex - ('a' - 'A');
  291. }
  294. static int GetNextChar(const PString & command,
  295.                                     PINDEX & pos, PTimeInterval * time = NULL)
  296. {
  297.   int temp;
  299.   if (command[pos] == '')
  300.     return NextCharEndOfString;
  302.   if (command[pos] != '\')
  303.     return command[pos++];
  305.   switch (command[++pos]) {
  306.     case '' :
  307.       return NextCharEndOfString;
  309.     case 'a' : // alert (ascii value 7)
  310.       pos++;
  311.       return 7;
  313.     case 'b' : // backspace (ascii value 8)
  314.       pos++;
  315.       return 8;
  317.     case 'f' : // formfeed (ascii value 12)
  318.       pos++;
  319.       return 12;
  321.     case 'n' : // newline (ascii value 10)
  322.       pos++;
  323.       return 10;
  325.     case 'r' : // return (ascii value 13)
  326.       pos++;
  327.       return 13;
  329.     case 't' : // horizontal tab (ascii value 9)
  330.       pos++;
  331.       return 9;
  333.     case 'v' : // vertical tab (ascii value 11)
  334.       pos++;
  335.       return 11;
  337.     case 'x' : // followed by hh  where nn is hex number (ascii value 0xhh)
  338.       if (isxdigit(command[++pos])) {
  339.         temp = HexDigit(command[pos++]);
  340.         if (isxdigit(command[pos]))
  341.           temp += HexDigit(command[pos++]);
  342.         return temp;
  343.       }
  344.       return command[pos];
  346.     case 's' :
  347.       pos++;
  348.       return NextCharSend;
  350.     case 'd' : // ns  delay for n seconds/milliseconds
  351.     case 'w' :
  352.       temp = command[pos] == 'd' ? NextCharDelay : NextCharWait;
  353.       long milliseconds = 0;
  354.       while (isdigit(command[++pos]))
  355.         milliseconds = milliseconds*10 + command[pos] - '0';
  356.       if (milliseconds <= 0)
  357.         milliseconds = 1;
  358.       if (command[pos] == 'm')
  359.         pos++;
  360.       else {
  361.         milliseconds *= 1000;
  362.         if (command[pos] == 's')
  363.           pos++;
  364.       }
  365.       if (time != NULL)
  366.         *time = milliseconds;
  367.       return temp;
  368.   }
  370.   if (command[pos] < '0' || command[pos] > '7')
  371.     return command[pos++];
  373.   // octal number
  374.   temp = command[pos++] - '0';
  375.   if (command[pos] < '0' || command[pos] > '7')
  376.     return temp;
  378.   temp += command[pos++] - '0';
  379.   if (command[pos] < '0' || command[pos] > '7')
  380.     return temp;
  382.   temp += command[pos++] - '0';
  383.   return temp;
  384. }
  387. BOOL PChannel::ReceiveCommandString(int nextChar,
  388.                             const PString & reply, PINDEX & pos, PINDEX start)
  389. {
  390.   if (nextChar != GetNextChar(reply, pos)) {
  391.     pos = start;
  392.     return FALSE;
  393.   }
  395.   PINDEX dummyPos = pos;
  396.   return GetNextChar(reply, dummyPos) < 0;
  397. }
  400. BOOL PChannel::SendCommandString(const PString & command)
  401. {
  402.   abortCommandString = FALSE;
  404.   int nextChar;
  405.   PINDEX sendPosition = 0;
  406.   PTimeInterval timeout;
  407.   SetWriteTimeout(10000);
  409.   while (!abortCommandString) { // not aborted
  410.     nextChar = GetNextChar(command, sendPosition, &timeout);
  411.     switch (nextChar) {
  412.       default :
  413.         if (!WriteChar(nextChar))
  414.           return FALSE;
  415.         break;
  417.       case NextCharEndOfString :
  418.         return TRUE;  // Success!!
  420.       case NextCharSend :
  421.         break;
  423.       case NextCharDelay : // Delay in send
  424.         PThread::Current()->Sleep(timeout);
  425.         break;
  427.       case NextCharWait : // Wait for reply
  428.         PINDEX receivePosition = sendPosition;
  429.         if (GetNextChar(command, receivePosition) < 0) {
  430.           SetReadTimeout(timeout);
  431.           while (ReadChar() >= 0)
  432.             if (abortCommandString) // aborted
  433.               return FALSE;
  434.         }
  435.         else {
  436.           receivePosition = sendPosition;
  437.           do {
  438.             if (abortCommandString) // aborted
  439.               return FALSE;
  440.             if ((nextChar = ReadCharWithTimeout(timeout)) < 0)
  441.               return FALSE;
  442.           } while (!ReceiveCommandString(nextChar,
  443.                                      command, receivePosition, sendPosition));
  444. //          nextChar = GetNextChar(command, receivePosition);
  445.           sendPosition = receivePosition;
  446.         }
  447.     }
  448.   }
  450.   return FALSE;
  451. }
  454. BOOL PChannel::Shutdown(ShutdownValue)
  455. {
  456.   return FALSE;
  457. }
  460. PChannel * PChannel::GetBaseReadChannel() const
  461. {
  462.   return (PChannel *)this;
  463. }
  466. PChannel * PChannel::GetBaseWriteChannel() const
  467. {
  468.   return (PChannel *)this;
  469. }
  472. ///////////////////////////////////////////////////////////////////////////////
  473. // PIndirectChannel
  475. PIndirectChannel::PIndirectChannel()
  476. {
  477.   readChannel = writeChannel = NULL;
  478.   writeAutoDelete = readAutoDelete = FALSE;
  479. }
  482. PObject::Comparison PIndirectChannel::Compare(const PObject & obj) const
  483. {
  484.   PAssert(obj.IsDescendant(PIndirectChannel::Class()), PInvalidCast);
  485.   const PIndirectChannel & other = (const PIndirectChannel &)obj;
  486.   return readChannel == other.readChannel &&
  487.          writeChannel == other.writeChannel ? EqualTo : GreaterThan;
  488. }
  491. PString PIndirectChannel::GetName() const
  492. {
  493.   ((PIndirectChannel*)this)->channelPointerMutex.StartRead();
  495.   PString name;
  496.   if (readChannel != NULL && readChannel == writeChannel)
  497.     name = readChannel->GetName();
  498.   else {
  499.     name = "R<";
  500.     if (readChannel != NULL)
  501.       name += readChannel->GetName();
  502.     name += "> T<";
  503.     if (writeChannel != NULL)
  504.       name += writeChannel->GetName();
  505.     name += ">";
  506.   }
  508.   ((PIndirectChannel*)this)->channelPointerMutex.EndRead();
  510.   return name;
  511. }
  514. BOOL PIndirectChannel::Close()
  515. {
  516.   BOOL retval = TRUE;
  518.   flush();
  520.   channelPointerMutex.StartRead();
  522.   if (readChannel != NULL)
  523.     retval = readChannel->Close();
  525.   if (readChannel != writeChannel && writeChannel != NULL)
  526.     retval = writeChannel->Close() && retval;
  528.   channelPointerMutex.EndRead();
  530.   channelPointerMutex.StartWrite();
  532.   PChannel * r = readChannel;
  533.   PChannel * w = writeChannel;
  535.   readChannel = NULL;
  536.   writeChannel = NULL;
  538.   if (readAutoDelete)
  539.     delete r;
  541.   if (r != w && writeAutoDelete)
  542.     delete w;
  544.   channelPointerMutex.EndWrite();
  546.   return retval;
  547. }
  550. BOOL PIndirectChannel::IsOpen() const
  551. {
  552.   ((PIndirectChannel*)this)->channelPointerMutex.StartRead();
  554.   BOOL returnValue;
  555.   if (readChannel != NULL && readChannel == writeChannel)
  556.     returnValue = readChannel->IsOpen();
  557.   else {
  558.     returnValue = readChannel != NULL ? readChannel->IsOpen() : FALSE;
  559.     if (writeChannel != NULL)
  560.       returnValue = writeChannel->IsOpen() || returnValue;
  561.   }
  563.   ((PIndirectChannel*)this)->channelPointerMutex.EndRead();
  565.   return returnValue;
  566. }
  569. BOOL PIndirectChannel::Read(void * buf, PINDEX len)
  570. {
  571.   flush();
  573.   channelPointerMutex.StartRead();
  575.   PAssert(readChannel != NULL, "Indirect read though NULL channel");
  577.   BOOL returnValue;
  578.   if (readChannel == NULL)
  579.     returnValue = FALSE;
  580.   else {
  581.     readChannel->SetReadTimeout(readTimeout);
  583.     returnValue = readChannel->Read(buf, len);
  585.     lastError = readChannel->GetErrorCode();
  586.     osError = readChannel->GetErrorNumber();
  587.     lastReadCount = readChannel->GetLastReadCount();
  588.   }
  590.   channelPointerMutex.EndRead();
  592.   return returnValue;
  593. }
  596. BOOL PIndirectChannel::Write(const void * buf, PINDEX len)
  597. {
  598.   flush();
  600.   channelPointerMutex.StartRead();
  602.   PAssert(writeChannel != NULL, "Indirect write though NULL channel");
  604.   BOOL returnValue;
  605.   if (writeChannel == NULL)
  606.     returnValue = FALSE;
  607.   else {
  608.     writeChannel->SetWriteTimeout(writeTimeout);
  610.     returnValue = writeChannel->Write(buf, len);
  612.     lastError = writeChannel->GetErrorCode();
  613.     osError = writeChannel->GetErrorNumber();
  614.     lastWriteCount = writeChannel->GetLastWriteCount();
  615.   }
  617.   channelPointerMutex.EndRead();
  619.   return returnValue;
  620. }
  623. BOOL PIndirectChannel::Shutdown(ShutdownValue value)
  624. {
  625.   channelPointerMutex.StartRead();
  627.   BOOL returnValue;
  628.   if (readChannel != NULL && readChannel == writeChannel)
  629.     returnValue = readChannel->Shutdown(value);
  630.   else {
  631.     returnValue = readChannel != NULL ? readChannel->Shutdown(value) : FALSE;
  632.     if (writeChannel != NULL)
  633.       returnValue = writeChannel->Shutdown(value) || returnValue;
  634.   }
  636.   channelPointerMutex.EndRead();
  638.   return returnValue;
  639. }
  642. BOOL PIndirectChannel::Open(PChannel & channel)
  643. {
  644.   return Open(&channel, FALSE);
  645. }
  648. BOOL PIndirectChannel::Open(PChannel * channel, BOOL autoDelete)
  649. {
  650.   return Open(channel, channel, autoDelete, autoDelete);
  651. }
  654. BOOL PIndirectChannel::Open(PChannel * readChan,
  655.                             PChannel * writeChan,
  656.                             BOOL autoDeleteRead,
  657.                             BOOL autoDeleteWrite)
  658. {
  659.   Close();
  661.   channelPointerMutex.StartWrite();
  663.   readChannel = readChan;
  664.   readAutoDelete = autoDeleteRead;
  665.   writeChannel = writeChan;
  666.   writeAutoDelete = autoDeleteWrite;
  668.   channelPointerMutex.EndWrite();
  670.   return IsOpen() && OnOpen();
  671. }
  674. BOOL PIndirectChannel::OnOpen()
  675. {
  676.   return TRUE;
  677. }
  680. BOOL PIndirectChannel::SetReadChannel(PChannel * channel, BOOL autoDelete)
  681. {
  682.   if (readChannel != NULL) {
  683.     lastError = Miscellaneous;
  684.     osError = EBADF;
  685.     return FALSE;
  686.   }
  688.   channelPointerMutex.StartWrite();
  690.   readChannel = channel;
  691.   readAutoDelete = autoDelete;
  693.   channelPointerMutex.EndWrite();
  695.   return IsOpen();
  696. }
  699. BOOL PIndirectChannel::SetWriteChannel(PChannel * channel, BOOL autoDelete)
  700. {
  701.   if (writeChannel != NULL) {
  702.     lastError = Miscellaneous;
  703.     osError = EBADF;
  704.     return FALSE;
  705.   }
  707.   channelPointerMutex.StartWrite();
  709.   writeChannel = channel;
  710.   writeAutoDelete = autoDelete;
  712.   channelPointerMutex.EndWrite();
  714.   return IsOpen();
  715. }
  718. PChannel * PIndirectChannel::GetBaseReadChannel() const
  719. {
  720.   ((PIndirectChannel*)this)->channelPointerMutex.StartRead();
  722.   PChannel * returnValue = readChannel != NULL ? readChannel->GetBaseReadChannel() : 0;
  724.   ((PIndirectChannel*)this)->channelPointerMutex.EndRead();
  726.   return returnValue;
  727. }
  730. PChannel * PIndirectChannel::GetBaseWriteChannel() const
  731. {
  732.   ((PIndirectChannel*)this)->channelPointerMutex.StartRead();
  734.   PChannel * returnValue = writeChannel != NULL ? writeChannel->GetBaseWriteChannel() : 0;
  736.   ((PIndirectChannel*)this)->channelPointerMutex.EndRead();
  738.   return returnValue;
  739. }
  742. ///////////////////////////////////////////////////////////////////////////////
  743. // PFile
  745. PFile::~PFile()
  746. {
  747.   Close();
  748. }
  751. PObject::Comparison PFile::Compare(const PObject & obj) const
  752. {
  753.   PAssert(obj.IsDescendant(PFile::Class()), PInvalidCast);
  754.   return path.Compare(((const PFile &)obj).path);
  755. }
  758. BOOL PFile::Rename(const PString & newname, BOOL force)
  759. {
  760.   Close();
  762.   if (!ConvertOSError(Rename(path, newname, force) ? 0 : -1))
  763.     return FALSE;
  765.   path = path.GetDirectory() + newname;
  766.   return TRUE;
  767. }
  770. BOOL PFile::Close()
  771. {
  772.   if (os_handle < 0) {
  773.     osError = EBADF;
  774.     lastError = NotOpen;
  775.     return FALSE;
  776.   }
  778.   flush();
  780. #ifdef WOT_NO_FILESYSTEM
  781.   BOOL ok = TRUE;
  782. #else
  783.   BOOL ok = ConvertOSError(_close(os_handle));
  784. #endif
  786.   os_handle = -1;
  788.   if (removeOnClose)
  789.     Remove();
  791.   return ok;
  792. }
  795. BOOL PFile::Read(void * buffer, PINDEX amount)
  796. {
  797.   flush();
  798. #ifdef WOT_NO_FILESYSTEM
  799.   lastReadCount = 0;
  800. #else
  801.   lastReadCount = _read(GetHandle(), buffer, amount);
  802. #endif
  803.   return ConvertOSError(lastReadCount) && lastReadCount > 0;
  804. }
  807. BOOL PFile::Write(const void * buffer, PINDEX amount)
  808. {
  809.   flush();
  810. #ifdef WOT_NO_FILESYSTEM
  811.   lastWriteCount = amount;
  812. #else
  813.   lastWriteCount = _write(GetHandle(), buffer, amount);
  814. #endif
  815.   return ConvertOSError(lastWriteCount) && lastWriteCount >= amount;
  816. }
  819. BOOL PFile::Open(const PFilePath & name, OpenMode  mode, int opts)
  820. {
  821.   Close();
  822.   SetFilePath(name);
  823.   return Open(mode, opts);
  824. }
  827. off_t PFile::GetLength() const
  828. {
  829. #ifdef WOT_NO_FILESYSTEM
  830.   return 0;
  831. #else
  832.   off_t pos = _lseek(GetHandle(), 0, SEEK_CUR);
  833.   off_t len = _lseek(GetHandle(), 0, SEEK_END);
  834.   PAssertOS(_lseek(GetHandle(), pos, SEEK_SET) == pos);
  835.   return len;
  836. #endif
  837. }
  840. BOOL PFile::IsEndOfFile() const
  841. {
  842.   ((PFile *)this)->flush();
  843.   return GetPosition() >= GetLength();
  844. }
  847. BOOL PFile::SetPosition(off_t pos, FilePositionOrigin origin)
  848. {
  849. #ifdef WOT_NO_FILESYSTEM
  850.   return TRUE;
  851. #else
  852.   return _lseek(GetHandle(), pos, origin) == pos;
  853. #endif
  854. }
  857. BOOL PFile::Copy(const PFilePath & oldname, const PFilePath & newname, BOOL force)
  858. {
  859.   PFile oldfile(oldname, ReadOnly);
  860.   if (!oldfile.IsOpen())
  861.     return FALSE;
  863.   PFile newfile(newname,
  864.                    WriteOnly, Create|Truncate|(force ? MustExist : Exclusive));
  865.   if (!newfile.IsOpen())
  866.     return FALSE;
  868.   PCharArray buffer(10000);
  870.   off_t amount = oldfile.GetLength();
  871.   while (amount > 10000) {
  872.     if (!oldfile.Read(buffer.GetPointer(), 10000))
  873.       return FALSE;
  874.     if (!newfile.Write((const char *)buffer, 10000))
  875.       return FALSE;
  876.     amount -= 10000;
  877.   }
  879.   if (!oldfile.Read(buffer.GetPointer(), (int)amount))
  880.     return FALSE;
  881.   if (!newfile.Write((const char *)buffer, (int)amount))
  882.     return FALSE;
  884.   return newfile.Close();
  885. }
  888. // End Of File ///////////////////////////////////////////////////////////////