cwin32file.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:11k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "platform/win/cwin32file.h"
  36. #include "hlxclib/fcntl.h"
  37. #include "hlxclib/windows.h"
  38. #include "hxassert.h"
  39. #define  HX_FILE_NOT_OPEN    -1000
  40. // CHXFile should set the file reference to a value
  41. // indicating the file is not open
  42. CWin32File::CWin32File (void) :
  43.     mFD(INVALID_HANDLE_VALUE)
  44. {
  45.     mLastError = HXR_OK;
  46. }
  47. // ~CHXFile should close the file if it is open
  48. CWin32File::~CWin32File(void)
  49.     // close the file if it is open
  50.     if ( mFD != INVALID_HANDLE_VALUE )
  51. Close();
  52. }
  53. // Create a file with the specified mode
  54. // Closes the previous file if it was open
  55. // returns HXR_OK or HXR_INVALID_FILE if an error occurred
  56. HX_RESULT CWin32File::Create(const char *filename, UINT16 mode, BOOL textflag)
  57. {
  58.     // close previous file if necessary
  59.     if ( mFD != INVALID_HANDLE_VALUE )
  60. Close();
  61.     DWORD acc = GENERIC_WRITE, shared = 0, disp = 0;
  62.     
  63.     if (mode & O_CREAT) 
  64.     {
  65. acc |= GENERIC_WRITE;
  66. if (mode & O_EXCL) 
  67.     disp |= CREATE_NEW;
  68. else
  69.     disp |= OPEN_ALWAYS;
  70.     }
  71.     if (mode & O_TRUNC) 
  72.     {
  73. acc |= GENERIC_WRITE;
  74. disp = TRUNCATE_EXISTING | CREATE_ALWAYS;
  75.     }
  76.     if (mode & O_RDONLY)
  77. acc = GENERIC_READ;
  78.     if (mode & O_RDWR)
  79. acc = GENERIC_READ | GENERIC_WRITE;
  80.     if (mode & O_WRONLY)
  81. acc = GENERIC_WRITE;
  82.     // create file
  83.     mLastError = HXR_OK;
  84.     if ( ( mFD = CreateFile( OS_STRING(filename), 
  85.      acc, shared, NULL, 
  86.      disp, NULL, NULL)) == INVALID_HANDLE_VALUE )
  87.     {
  88. mLastError = HXR_DOC_MISSING;
  89. return HXR_DOC_MISSING;
  90.     }
  91.     if (mode & O_APPEND) 
  92. Seek(0, SEEK_END);
  93.     return HXR_OK;
  94. }
  95. // Open a file with the specified mode
  96. // Closes the previous file if it was open
  97. // returns HXR_OK or HXR_INVALID_FILE if an error occurred
  98. HX_RESULT CWin32File::Open(const char *filename, UINT16 mode, BOOL textflag)
  99. {
  100.     // close previous file if necessary
  101.     if ( mFD != INVALID_HANDLE_VALUE )
  102. Close();
  103.     // open file
  104.     mLastError = HXR_OK;
  105.     DWORD acc = GENERIC_WRITE, disp = OPEN_ALWAYS;
  106.     if (mode & O_CREAT) 
  107.     {
  108. acc |= GENERIC_WRITE;
  109. if (mode & O_EXCL) 
  110.     disp = CREATE_NEW;
  111. else
  112.     disp = OPEN_ALWAYS;
  113.     }
  114.     if (mode & O_TRUNC) 
  115.     {
  116. acc |= GENERIC_WRITE;
  117. disp = TRUNCATE_EXISTING | CREATE_ALWAYS;
  118.     }
  119.     if (mode & O_RDONLY)
  120. acc = GENERIC_READ;
  121.     if (mode & O_RDWR)
  122. acc = GENERIC_READ | GENERIC_WRITE;
  123.     if (mode & O_WRONLY)
  124. acc = GENERIC_WRITE;
  125.     if(mode & O_TRUNC)
  126.     {
  127. acc |= GENERIC_WRITE;
  128. mFD = CreateFile(OS_STRING(filename), acc, 0, 
  129.  NULL, 0, NULL, NULL) ;
  130. if ( mFD == INVALID_HANDLE_VALUE)
  131. {
  132.     mLastError = HXR_DOC_MISSING;
  133.     return HXR_DOC_MISSING;
  134. }
  135. Close();
  136.     }
  137.     // Actually open the file
  138.     mFD = CreateFile(OS_STRING(filename), acc, 0, NULL, disp, NULL, NULL) ;
  139.     if ( mFD == INVALID_HANDLE_VALUE )
  140.     {
  141. mLastError = HXR_DOC_MISSING;
  142. return HXR_DOC_MISSING;
  143.     }
  144.     if (mode & O_APPEND)
  145. Seek(0, SEEK_END);
  146.     return HXR_OK;
  147. }
  148. // Open a file for sharing with the specified mode
  149. // Closes the previous file if it was open
  150. // returns HXR_OK or HXR_INVALID_FILE if an error occurred
  151. HX_RESULT CWin32File::OpenShared(const char *filename, UINT16 mode, UINT16 sharedmode, BOOL textflag)
  152. {
  153.     // close previous file if necessary
  154.     if ( mFD != INVALID_HANDLE_VALUE )
  155. Close();
  156.     // open file
  157.     mLastError = HXR_OK;
  158.     DWORD acc = GENERIC_WRITE, disp = 0, shared = FILE_SHARE_READ | FILE_SHARE_WRITE;
  159.     if (mode & O_CREAT) 
  160.     {
  161. acc |= GENERIC_WRITE;
  162. if (mode & O_EXCL) 
  163.     disp |= CREATE_NEW;
  164. else
  165.     disp |= OPEN_ALWAYS;
  166.     }
  167.     if (mode & O_TRUNC) 
  168.     {
  169. acc |= GENERIC_WRITE;
  170. disp = TRUNCATE_EXISTING | CREATE_ALWAYS;
  171.     }
  172.     if (mode & O_RDONLY)
  173. acc = GENERIC_READ;
  174.     if (mode & O_RDWR)
  175. acc = GENERIC_READ | GENERIC_WRITE;
  176.     if (mode & O_WRONLY)
  177. acc = GENERIC_WRITE;
  178.     if (sharedmode & SH_DENYRW)
  179. shared = 0;
  180.     if (sharedmode & SH_DENYWR)
  181. shared = FILE_SHARE_READ;
  182.     if (sharedmode & SH_DENYRD)
  183. shared = FILE_SHARE_WRITE;
  184.     if(mode & O_TRUNC)
  185.     {
  186. mFD = CreateFile(OS_STRING(filename), acc, 0, 
  187.  NULL, 0, NULL, NULL) ;
  188. // Check acces rights to this file first
  189. if ( mFD == INVALID_HANDLE_VALUE)
  190. {
  191.     mLastError = HXR_DOC_MISSING;
  192.     return HXR_DOC_MISSING;
  193. }
  194. Close();
  195.     }
  196.     // Actually open the file - use sharing mode
  197.     mFD = CreateFile(OS_STRING(filename), acc, shared, 
  198.      NULL, 0, NULL, NULL) ;
  199.     if ( mFD == INVALID_HANDLE_VALUE )
  200.     {
  201. mLastError = HXR_DOC_MISSING;
  202. return HXR_DOC_MISSING;
  203.     }
  204.     return HXR_OK;
  205. }
  206. // Close the previous file if it was open
  207. // returns HXR_OK or HXR_INVALID_FILE if an error occurred
  208. HX_RESULT CWin32File::Close(void)
  209. {
  210.     // close previous file if necessary
  211.     if ( mFD != INVALID_HANDLE_VALUE)
  212.     {
  213. mLastError = HXR_OK;   
  214. if ( CloseHandle( mFD ) == 0 )
  215. {
  216.     mLastError = HXR_INVALID_FILE;
  217.     return HXR_INVALID_FILE;
  218. }
  219. return HXR_OK;
  220.     }
  221.     return HXR_INVALID_FILE;
  222. }
  223. // Simply uses stat to get the size of the file in bytes.  If the file
  224. // is closed, it will still work.
  225. ULONG32 CWin32File::GetSize(void)
  226. {
  227.     ULONG32 ret = 0;
  228.     if (mFD != INVALID_HANDLE_VALUE) 
  229.     {
  230. ret = GetFileSize(mFD, NULL);
  231.     }
  232.     return ret;
  233. }
  234. // Seek moves the current file position to the offset from the fromWhere
  235. // specifier returns HXR_OK or HXR_INVALID_FILE if an error occurred
  236. HX_RESULT CWin32File::Seek(ULONG32 offset, UINT16 fromWhere)
  237. {
  238.     mLastError = HXR_INVALID_FILE;
  239.     if (( mFD != INVALID_HANDLE_VALUE ) &&
  240. ( SetFilePointer( mFD, offset, NULL, fromWhere ) != 0xffffffff ))
  241. mLastError = HXR_OK;
  242.     return mLastError;
  243. }
  244. // Rewind sets the file position to the start of file
  245. // returns HXR_OK or HXR_INVALID_FILE if an error occurred
  246. HX_RESULT CWin32File::Rewind(void)
  247. {
  248.     mLastError = HXR_INVALID_FILE;
  249.     if (( mFD != INVALID_HANDLE_VALUE ) &&
  250. ( SetFilePointer( mFD, 0, NULL, FILE_BEGIN ) != 0xffffffff ))
  251. mLastError = HXR_OK;
  252.     return mLastError;
  253. }
  254. // Tell returns the current file position
  255. // returns HXR_OK or -1 if an error occurred
  256. ULONG32 CWin32File::Tell(void)
  257. {   
  258.     long offset = -1;
  259.     mLastError = HXR_INVALID_FILE;
  260.     if (( mFD != INVALID_HANDLE_VALUE ) &&
  261. ((offset = SetFilePointer( mFD, 0, NULL, 
  262.    FILE_CURRENT )) != 0xffffffff ))
  263.     mLastError = HXR_OK;
  264.     return (ULONG32)offset;
  265. }
  266. /*      Read reads up to count bytes of data into buf.
  267.         returns the number of bytes read, EOF, or -1 if the read failed */
  268. ULONG32 CWin32File::Read (char *buf, ULONG32 count)
  269. {
  270.     DWORD ncnt = (DWORD)-1;           // number of bytes read
  271.     if ( mFD != INVALID_HANDLE_VALUE )
  272.     { 
  273. mLastError = HXR_OK;
  274. ULONG32 tmpCheck = Tell();
  275. HX_ASSERT(count < UINT_MAX);
  276. if ( ( ReadFile( mFD, (LPVOID)buf, (DWORD) count, &ncnt, NULL ) ) == 0 )
  277. {
  278.     mLastError = HXR_INVALID_FILE;
  279.  
  280. }
  281.     }
  282.     return (ULONG32)ncnt;
  283. }
  284. /*      Write writes up to count bytes of data from buf.
  285.         returns the number of bytes written, or -1 if the write failed */
  286. ULONG32 CWin32File::Write(const char *buf, ULONG32 count)
  287. {
  288.     DWORD ncnt = (DWORD)-1;           // number of bytes written
  289.     if ( mFD != INVALID_HANDLE_VALUE )
  290.     { 
  291. mLastError = HXR_OK;
  292. HX_ASSERT(count < UINT_MAX);
  293. if ( ( WriteFile( mFD, (LPVOID)buf, (DWORD) count, &ncnt, NULL ) ) == -1 )
  294. {
  295.     mLastError = HXR_INVALID_FILE;
  296. }
  297.     }
  298.     return (ULONG32)ncnt;
  299. }
  300. BOOL CWin32File::GetTemporaryFileName(const char *tag, char* name, UINT32 ulBufLen)
  301. {
  302.     BOOL bOk = TRUE;
  303.     char szTempPathName[_MAX_PATH] = "."; /* Flawfinder: ignore */
  304. #if !defined(WIN32_PLATFORM_PSPC)
  305.     if (!GetTempPath(_MAX_PATH,szTempPathName))
  306.     {
  307. bOk = FALSE;
  308.     }
  309. #endif /* !defined(WIN32_PLATFORM_PSPC) */
  310.     if (bOk && !GetTempFileName(OS_STRING(szTempPathName),
  311. OS_STRING(tag),0, OS_STRING2(name,_MAX_PATH)))
  312.     {
  313. bOk = FALSE;
  314.     }
  315.     return bOk;
  316. }
  317. // Delete a file 
  318. HX_RESULT CWin32File::Delete(const char *filename)
  319. {
  320.     // close previous file if necessary
  321.     if ( mFD != INVALID_HANDLE_VALUE )
  322.     {
  323. Close();
  324.     }
  325.     // delete file
  326.     mLastError = HXR_OK;
  327.     if(!DeleteFile(OS_STRING(filename)))
  328.     {
  329. if(GetLastError() == ERROR_ACCESS_DENIED)
  330.     mLastError = HXR_ACCESSDENIED;
  331. else
  332.     mLastError = HXR_DOC_MISSING;
  333. return mLastError;
  334.     }
  335.     return HXR_OK;
  336. }
  337. HX_RESULT CWin32File::ChangeSize (ULONG32 newSize)
  338. {
  339.     HX_RESULT res = HXR_FAIL;
  340.     if (mFD != INVALID_HANDLE_VALUE)
  341.     {
  342.         ULONG32 pos = Tell();
  343. if (SetFilePointer(mFD, newSize, 0, SEEK_SET) != 0xFFFFFFFF)
  344. {
  345.     if (SetEndOfFile(mFD) != 0)
  346. res = HXR_OK;
  347.             // reposition pointer at orignal position
  348.             Seek(pos, SEEK_SET);       
  349. }
  350.     }
  351.     return res;
  352. }