bufdataf.cpp
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:11k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: bufdataf.cpp,v 1.4.42.3 2004/07/09 01:44:13 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. #include <stdio.h>
  50. #include <stat.h>
  51. #include <types.h>
  52. #include <fcntl.h>
  53. #include <errno.h>
  54. #include <unix.mac.h>  // Anyone using this file MUST #undef _UNIX
  55. #undef _UNIX
  56. #include "hxtypes.h"
  57. #include "hxcom.h"
  58. #include "hxresult.h"
  59. #include "ihxpckts.h"
  60. #include "hxbuffer.h"
  61. #include "debug.h"
  62. #include "hxdataf.h"
  63. #include "datffact.h"
  64. #include "bufdataf.h"
  65. /////////////////////////////////////////////////////////////////////////
  66. //  Method:
  67. //      BufferedDataFile::QueryInterface
  68. //  Purpose:
  69. //      Implement this to export the interfaces supported by your
  70. //      object.
  71. //
  72. STDMETHODIMP
  73. BufferedDataFile::QueryInterface(REFIID riid, void** ppvObj)
  74. {
  75.     if (IsEqualIID(riid, IID_IHXDataFile))
  76.     {
  77.         AddRef();
  78.         *ppvObj = (IHXDataFile*)this;
  79.         return HXR_OK;
  80.     }
  81.     
  82.     *ppvObj = NULL;
  83.     return HXR_NOINTERFACE;
  84. }   
  85. /////////////////////////////////////////////////////////////////////////
  86. //  Method:
  87. //      BufferedDataFile::AddRef
  88. //  Purpose:
  89. //      Everyone usually implements this the same... feel free to use
  90. //      this implementation.
  91. //
  92. STDMETHODIMP_(ULONG32)
  93. BufferedDataFile::AddRef()
  94. {
  95.     DPRINTF(0x5d000000, ("UBDF::AddRef() = %ldn", m_lRefCount+1));
  96.     return InterlockedIncrement(&m_lRefCount);
  97. }   
  98. /////////////////////////////////////////////////////////////////////////
  99. //  Method:
  100. //      BufferedDataFile::Release
  101. //  Purpose:
  102. //      Everyone usually implements this the same... feel free to use
  103. //      this implementation.
  104. //
  105. STDMETHODIMP_(ULONG32)
  106. BufferedDataFile::Release()
  107. {
  108.     DPRINTF(0x5d000000, ("UBDF::Release() = %ldn", m_lRefCount-1));
  109.     if (InterlockedDecrement(&m_lRefCount) > 0)
  110.     {
  111.         return m_lRefCount;
  112.     }
  113.     
  114.     delete this;
  115.     return 0;
  116. }   
  117. BufferedDataFile::BufferedDataFile()
  118.   : m_lRefCount(0)
  119.   , m_ulLastError(HXR_OK)
  120.   , m_pFilename(new CHXBuffer)
  121.   , m_pFile(0)
  122. {
  123.     m_pFilename->AddRef();
  124.     DPRINTF(0x5d000000, ("BufferedDataFile::BufferedDataFile()n"));
  125. }
  126. // ~CHXFile should close the file if it is open
  127. BufferedDataFile::~BufferedDataFile()
  128.     // close the file if it is open
  129.     if (m_pFile)
  130.     {
  131.        fclose(m_pFile);
  132.        m_pFile = 0;
  133.     }
  134.     HX_RELEASE(m_pFilename);
  135.     DPRINTF(0x5d000000, ("BufferedDataFile::~BufferedDataFile()n"));
  136. }
  137. /*
  138.  *  IHXDataFile methods
  139.  */
  140. /* Bind DataFile Object with FileName */
  141. STDMETHODIMP_(void)
  142. BufferedDataFile::Bind(const char* pFilename)
  143. {
  144.     m_pFilename->Set((BYTE *)pFilename, strlen(pFilename)+1);
  145.     DPRINTF(0x5d000000, ("BufferedDataFile::Bind(%s)n", 
  146.     (const char *)m_pFilename->GetBuffer()));
  147. }
  148. /* Creates a datafile using the specified mode
  149.  * uOpenMode --- File Open mode - HX_FILEFLAG_READ/HX_FILEFLAG_WRITE/HX_FILEFLAG_BINARY
  150.  */
  151. STDMETHODIMP
  152. BufferedDataFile::Create(UINT16 uOpenMode)
  153. {
  154.     return HXR_NOTIMPL;
  155. }
  156. /* Open will open a file with the specified mode
  157.  */
  158. STDMETHODIMP
  159. BufferedDataFile::Open(UINT16 uOpenMode)
  160. {
  161.     DPRINTF(0x5d000000, ("BufferedDataFile::Open()n"));
  162.     char modeflags[4]; /* Flawfinder: ignore */
  163.  
  164.     if(uOpenMode & HX_FILEFLAG_READ)
  165.     {
  166.         modeflags[0] = 'r';
  167.         modeflags[1] = 0;
  168.         if(uOpenMode & HX_FILEFLAG_WRITE)
  169.         {
  170.             modeflags[1] = '+';
  171.             modeflags[2] = 0;
  172.         }
  173.         if(uOpenMode & HX_FILEFLAG_BINARY)
  174.             strcat(modeflags, "b"); /* Flawfinder: ignore */
  175.     }
  176.     else if(uOpenMode & HX_FILEFLAG_WRITE)
  177.     {
  178.         modeflags[0] = 'w';
  179.         modeflags[1] = 0;
  180.         if(uOpenMode & HX_FILEFLAG_BINARY)
  181.             strcat(modeflags, "b"); /* Flawfinder: ignore */
  182.     }
  183.     else if(!uOpenMode)
  184.     {
  185.         uOpenMode = HX_FILEFLAG_READ | HX_FILEFLAG_BINARY;
  186.         modeflags[0] = 'r';
  187.         modeflags[1] = 'b';
  188.         modeflags[2] = 0;
  189.     }
  190.     else
  191.     {
  192.         return HXR_INVALID_PARAMETER;
  193.     }
  194.     // close previous file if necessary
  195.     if (m_pFile)
  196. fclose(m_pFile);
  197.     DPRINTF(0x5d000000, ("BDF::Open() -- %sn", modeflags));
  198.     // open file
  199.     m_ulLastError = HXR_OK;
  200.     if ((m_pFile = fopen((const char *)m_pFilename->GetBuffer(), modeflags)) == NULL)
  201.     {
  202. m_ulLastError = errno;
  203. return HXR_DOC_MISSING;
  204.     }
  205.     return HXR_OK;
  206. }
  207. /* Close closes a file 
  208.  * If the reference count on the IHXDataFile object is greater than 1, 
  209.  * then the underlying file cannot be safely closed, so Close() becomes 
  210.  * a noop in that case. Close it only when the object is destroyed. 
  211.  * This would be safe, but could lead to a file descriptor leak.
  212.  */
  213. STDMETHODIMP
  214. BufferedDataFile::Close()
  215. {
  216.     if (m_pFile)
  217.     {
  218. fclose(m_pFile);
  219. m_pFile = 0;
  220.     }
  221.     return HXR_OK;
  222. }
  223. /* Name returns the currently bound file name in FileName.
  224.  * and returns TRUE, if the a name has been bound.  Otherwise
  225.  * FALSE is returned.
  226.  */
  227. STDMETHODIMP_(BOOL)
  228. BufferedDataFile::Name(REF(IHXBuffer*) pFileName)
  229. {
  230.     return HXR_NOTIMPL;
  231. }
  232. /*
  233.  * IsOpen returns TRUE if file is open.  Otherwise FALSE.
  234.  */
  235. inline BOOL
  236. BufferedDataFile::IsOpen()
  237. {
  238.     return (m_pFile ? TRUE : FALSE);
  239. }
  240. /* Seek moves the current file position to the offset from the
  241.  * fromWhere specifier returns current position of file or -1 on
  242.  * error.
  243.  */
  244. STDMETHODIMP
  245. BufferedDataFile::Seek(ULONG32 offset, UINT16 fromWhere)
  246. {
  247.     if (m_pFile)
  248.     {
  249. m_ulLastError = HXR_OK;       
  250. if (fseek(m_pFile, offset, fromWhere) < 0)
  251. {
  252.     m_ulLastError = errno;
  253.     return HXR_INVALID_FILE;
  254. }
  255. return HXR_OK;
  256.     }
  257.     return HXR_INVALID_FILE;
  258. }
  259. /* Tell returns the current file position in the file */
  260. STDMETHODIMP_(ULONG32)
  261. BufferedDataFile::Tell()
  262. {
  263.     INT32 offset = -1;
  264.     if (m_pFile)
  265.     {
  266. m_ulLastError = HXR_OK;       
  267. // so we do this instead....
  268. if ((offset = fseek(m_pFile, 0, SEEK_CUR)) < 0)
  269. {
  270.     m_ulLastError = errno;
  271. }
  272.     }
  273.     return (ULONG32)offset;
  274. }
  275. /* Read reads up to count bytes of data into buf.
  276.  * returns the number of bytes read, EOF, or -1 if the read failed 
  277.  */
  278. STDMETHODIMP_(ULONG32)
  279. BufferedDataFile::Read(REF(IHXBuffer *) pBuf, ULONG32 count)
  280. {
  281.     HX_ASSERT(pBuf);
  282.     pBuf->AddRef();
  283.     int ncnt = 0;           // number of bytes read
  284.     if (m_pFile)
  285.     { 
  286. m_ulLastError = HXR_OK;
  287. ULONG32 tmpCheck = Tell();
  288. if ((ncnt = fread((void *)pBuf->GetBuffer(), sizeof(char), 
  289.     count, m_pFile)) < count)
  290. {
  291.     m_ulLastError = errno;
  292. }
  293.     }
  294.     pBuf->Release();
  295.     return (ULONG32)ncnt;
  296. }
  297. /* Write writes up to count bytes of data from buf.
  298.  * returns the number of bytes written, or -1 if the write failed 
  299.  */
  300. STDMETHODIMP_(ULONG32)
  301. BufferedDataFile::Write(REF(IHXBuffer *) pBuf)
  302. {
  303.     HX_ASSERT(pBuf);
  304.     pBuf->AddRef();
  305.     int ncnt = -1;           // number of bytes written
  306.     int count = pBuf->GetSize();
  307.     if (m_pFile)
  308.     {
  309. m_ulLastError = HXR_OK;
  310. if ((ncnt = fwrite((const char *)pBuf->GetBuffer(), sizeof(char),
  311.     count, m_pFile)) < count)
  312. {
  313.     m_ulLastError = errno;
  314. }
  315.     }
  316.     pBuf->Release();
  317.     return (ULONG32)ncnt;
  318. }
  319. /* Flush out the data in case of Buffered I/O
  320.  */
  321. STDMETHODIMP
  322. BufferedDataFile::Flush()
  323. {
  324.     if (m_pFile)
  325.     {
  326. m_ulLastError = HXR_OK;       
  327. if (!fflush(m_pFile))
  328. {
  329.     m_ulLastError = errno;
  330.     return HXR_INVALID_FILE;
  331. }
  332. return HXR_OK;
  333.     }
  334.     return HXR_INVALID_FILE;
  335. }
  336. /*
  337.  * Return info about the data file such as permissions, time of creation
  338.  * size in bytes, etc.
  339.  */
  340. STDMETHODIMP
  341. BufferedDataFile::Stat(struct stat* statbuf)
  342. {
  343.     if (m_pFile)
  344.     {
  345. if (!fstat(fileno(m_pFile), statbuf))
  346.     return HXR_OK;
  347.     }
  348.     else if (m_pFilename->GetSize())
  349.     {
  350. if (!stat((const char *)m_pFilename->GetBuffer(), statbuf))
  351.     return HXR_OK;
  352.     }
  353.     return HXR_FAIL;
  354. }
  355. /* Return the file descriptor */
  356. inline INT16
  357. BufferedDataFile::GetFd()
  358. {
  359.     return m_pFile ? fileno(m_pFile) : -1;
  360. }
  361. /* GetLastError returns the platform specific file error */
  362. STDMETHODIMP
  363. BufferedDataFile::GetLastError()
  364. {
  365.     return HXR_NOTIMPL;
  366. }
  367. /* GetLastError returns the platform specific file error in
  368.  * string form.
  369.  */
  370. STDMETHODIMP_(void)
  371. BufferedDataFile::GetLastError(REF(IHXBuffer*) err)
  372. {
  373. }