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

Symbian

开发平台:

Visual C++

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