fio.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:8k
源码类别:

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. #ifndef _MACFIO_H_
  36. #define _MACFIO_H_
  37. #include <stdlib.h>
  38. #include "bio.h"
  39. #include "macFD.h"
  40. #include "CMacFile.h"
  41. #include "assert.h"
  42. #ifdef _MAC_MACHO
  43. #include <sys/stat.h>
  44. #else
  45. #include "stat.h"
  46. #include "errno.h"
  47. #include "oterrs.h"
  48. //#define OTUNIXERRORS 1
  49. //#include "OpenTransport.h" 
  50. #include "MacTCP.h"
  51. #endif
  52. extern Boolean gFDInitialized;
  53. class FileIO : public IO
  54. {
  55. public:
  56.         FileIO(const char* file, LONG32 flags, 
  57.        mode_t mode = 0666);
  58. ~FileIO();
  59.     virtual LONG32 close();
  60.     virtual LONG32 read(void* buf, LONG32 size);
  61.     virtual LONG32 write(const void* buf, LONG32 size);
  62.     virtual off_t seek(off_t off, LONG32 whence);
  63.     virtual LONG32 error();
  64.     virtual LONG32 flags();
  65.     virtual off_t file_size();
  66.     int status(struct stat *st); //mac
  67.     static void local_path(char* path);
  68. #ifdef _MAC_MACHO
  69.     #define MAXPATH 1024
  70. #else
  71.     static const enum { MAXPATH = 1024 };
  72. #endif
  73.     static const char  PATH_SEP;
  74.     static int is_directory(char* path);
  75.     static const char*  NEWLINE;
  76.     static int UNIXError(OSErr theErr);
  77. protected:
  78.     int  fd;
  79.     LONG32 err;
  80.     LONG32 _flags;
  81. private:
  82.     void *mFile; // pointer to the actual Mac file object
  83. };
  84. #ifndef _CARBON
  85. #define ENFILE 23 /* Too many open files in system */
  86. #define ENOSPC 28 /* No space left on device */
  87. #endif
  88. #define EROFS 30 /* Read-only file system */
  89. inline int 
  90. FileIO::UNIXError(OSErr theErr)
  91. {
  92. int err;
  93. switch(theErr)
  94. {
  95. case noErr:
  96. case eofErr:
  97. err = 0;
  98. break;
  99. case permErr:
  100. err = EACCES;
  101. break;
  102. case fBsyErr:
  103. err = EBUSY;
  104. break;
  105. case dupFNErr:
  106. err = EEXIST;
  107. break;
  108. case ioErr:
  109. err = EIO;
  110. break;
  111. case tmfoErr:
  112. err = ENFILE;
  113. break;
  114. case fnfErr:
  115. err = ENOENT;
  116. break;
  117. case dskFulErr:
  118. err = ENOSPC;
  119. break;
  120. case wPrErr:
  121. err = EROFS;
  122. break;
  123. #ifndef _MAC_MACHO
  124. case ipBadLapErr:
  125. case ipBadCnfgErr:
  126. case ipNoCnfgErr:
  127. case ipLoadErr:
  128. case ipBadAddr:
  129. err = ENXIO; /* device not configured */ /* a cheap cop out */
  130. break;
  131. case connectionClosing:
  132. err = ESHUTDOWN; /* Can't send after socket shutdown */
  133. break;
  134. case connectionExists:
  135. err = EISCONN; /* Socket is already connected */
  136. break;
  137. case connectionTerminated:
  138. err = ENOTCONN; /* Connection reset by peer */  /* one of many possible */
  139. break;
  140. case openFailed:
  141. err = ECONNREFUSED; /* Connection refused */
  142. break;
  143. case duplicateSocket: /* technically, duplicate port */
  144. err = EADDRINUSE; /* Address already in use */
  145. break;
  146. case ipDestDeadErr:
  147. err = EHOSTDOWN; /* Host is down */
  148. break;
  149. case ipRouteErr:
  150. err = EHOSTUNREACH; /* No route to host */
  151. break;
  152. #endif
  153. default:
  154. err = EINVAL; /* cop out; an internal err, unix err, or no err */
  155. break;
  156. }
  157. return err;
  158. }
  159. inline
  160. FileIO::FileIO(const char* file, LONG32 flags, mode_t mode) 
  161. {
  162. if (gFDInitialized == FALSE)
  163. {
  164. init_fds();
  165. }
  166. mFile = NULL;
  167. fd = -1;
  168. // create a new CMacFile object
  169. CMacFile *theFile = new CMacFile;
  170. OSErr theErr = noErr;
  171.   // get a file descriptor and register the CMacFile object as its owner
  172.   if(theFile)
  173. {
  174. fd = get_free_fd();
  175. assert(fd != -1);
  176. if(fd != -1)
  177. {
  178. fd_register(fd, (void *)theFile,FD_FILE);
  179. }
  180. }
  181. if(theFile && fd != -1)
  182. theErr = theFile->Open(file, flags);
  183. if(!theErr && theFile && fd != -1 && flags & O_RDONLY)
  184. {
  185. theFile->set_buffered_read(TRUE);
  186. }
  187. if(!theErr && theFile && fd != -1)
  188. {
  189. _flags = flags;
  190. mFile = theFile;
  191. }
  192. if(theErr)
  193. {
  194. free_fd(fd);
  195. if(mFile)
  196. delete mFile;
  197. mFile = NULL;
  198. fd = -1;
  199. }
  200. err = UNIXError(theErr);
  201. }
  202. inline LONG32
  203. FileIO::close() 
  204. {
  205. if(fd >= 0)
  206. {
  207. free_fd(fd);
  208. fd = -1;
  209. }
  210. return 0;
  211. }
  212. inline
  213. FileIO::~FileIO() 
  214. {
  215. if(mFile)
  216. {
  217. CMacFile *temp = (CMacFile *)mFile;
  218. delete temp;
  219. }
  220. if (fd >= 0) 
  221. close();
  222. fd = -1;
  223. }
  224. inline off_t
  225. FileIO::seek(off_t off, LONG32 whence) 
  226. {
  227. CMacFile *temp = (CMacFile *)mFile;
  228. if(fd == -1 || temp == NULL)
  229. {
  230. err = EINVAL;
  231. return -1;
  232. }
  233. OSErr theErr = temp->Seek(off,whence);
  234. err = UNIXError(theErr);
  235. return (theErr != 0 ? (off_t) -1 : off);
  236. }
  237. inline LONG32
  238. FileIO::read(void * buf, LONG32 len) 
  239. {
  240. CMacFile *temp = (CMacFile *)mFile;
  241. if(fd == -1 || temp == NULL)
  242. {
  243. err = EINVAL;
  244. return -1;
  245. }
  246. INT32 actualLen = 0;
  247. OSErr theErr = temp->Read((char *)buf,len,&actualLen);
  248. err = UNIXError(theErr);
  249. return actualLen;
  250. }
  251. inline LONG32
  252. FileIO::write(const void * buf, LONG32 len) 
  253. {
  254. CMacFile *temp = (CMacFile *)mFile;
  255. if(fd == -1 || temp == NULL)
  256. {
  257. err = EINVAL;
  258. return -1;
  259. }
  260. INT32 actualLen = 0;
  261. OSErr theErr = temp->Write((char *)buf,len,&actualLen);
  262. err = UNIXError(theErr);
  263. return actualLen;
  264. }
  265. // Note: status only implements file size (st_size)
  266. inline int
  267. FileIO::status(struct stat* st) {
  268. CMacFile *temp = (CMacFile *)mFile;
  269. if(fd == -1 || temp == NULL)
  270. {
  271. err = EINVAL;
  272. return -1;
  273. }
  274. long theSize;
  275.         OSErr theErr = temp->FileSize(&theSize);
  276.         st->st_size = theSize;
  277. err = UNIXError(theErr);
  278. return err; 
  279. }
  280. inline off_t
  281. FileIO::file_size()
  282. {
  283.     struct stat st;
  284.     if (status(&st) < 0)
  285.     {
  286. return (off_t)-1;
  287.     }
  288.     return st.st_size;
  289. }
  290. inline LONG32
  291. FileIO::error()
  292. {
  293.     return err;
  294. }
  295. inline LONG32
  296. FileIO::flags()
  297. {
  298.     return _flags;
  299. }
  300. inline void
  301. FileIO::local_path(char* path)
  302. {
  303. }
  304. inline int
  305. FileIO::is_directory(char* path)
  306. {
  307. #ifdef UNIMPLEMENTED
  308.     struct _stat st;
  309.     if (_stat(path, &st) < 0)
  310.     {
  311. return 0;
  312.     }
  313.     return st.st_mode & S_IFDIR;
  314. #endif
  315. return 0;
  316. }
  317. #endif /* _MACFIO_H_ */