my_fopen.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:6k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include "mysys_priv.h"
  14. #include "my_static.h"
  15. #include <errno.h>
  16. #include "mysys_err.h"
  17. static void make_ftype(my_string to,int flag);
  18. /*
  19.   Open a file as stream
  20.   SYNOPSIS
  21.     my_fopen()
  22.     FileName Path-name of file
  23.     Flags Read | write | append | trunc (like for open())
  24.     MyFlags Flags for handling errors
  25.   RETURN
  26.     0 Error
  27.     # File handler
  28. */
  29. FILE *my_fopen(const char *filename, int flags, myf MyFlags)
  30. {
  31.   FILE *fd;
  32.   char type[5];
  33.   DBUG_ENTER("my_fopen");
  34.   DBUG_PRINT("my",("Name: '%s'  flags: %d  MyFlags: %d",
  35.    filename, flags, MyFlags));
  36.   /* 
  37.     if we are not creating, then we need to use my_access to make sure  
  38.     the file exists since Windows doesn't handle files like "com1.sym" 
  39.     very  well 
  40.   */
  41. #ifdef __WIN__
  42.   if (check_if_legal_filename(filename))
  43.   {
  44.     errno= EACCES;
  45.     fd= 0;
  46.   }
  47.   else
  48. #endif
  49.   {
  50.     make_ftype(type,flags);
  51.     fd = fopen(filename, type);
  52.   }
  53.   
  54.   if (fd != 0)
  55.   {
  56.     /*
  57.       The test works if MY_NFILE < 128. The problem is that fileno() is char
  58.       on some OS (SUNOS). Actually the filename save isn't that important
  59.       so we can ignore if this doesn't work.
  60.     */
  61.     if ((uint) fileno(fd) >= my_file_limit)
  62.     {
  63.       thread_safe_increment(my_stream_opened,&THR_LOCK_open);
  64.       DBUG_RETURN(fd); /* safeguard */
  65.     }
  66.     pthread_mutex_lock(&THR_LOCK_open);
  67.     if ((my_file_info[fileno(fd)].name = (char*)
  68.  my_strdup(filename,MyFlags)))
  69.     {
  70.       my_stream_opened++;
  71.       my_file_info[fileno(fd)].type = STREAM_BY_FOPEN;
  72.       pthread_mutex_unlock(&THR_LOCK_open);
  73.       DBUG_PRINT("exit",("stream: 0x%lx",fd));
  74.       DBUG_RETURN(fd);
  75.     }
  76.     pthread_mutex_unlock(&THR_LOCK_open);
  77.     (void) my_fclose(fd,MyFlags);
  78.     my_errno=ENOMEM;
  79.   }
  80.   else
  81.     my_errno=errno;
  82.   DBUG_PRINT("error",("Got error %d on open",my_errno));
  83.   if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
  84.     my_error((flags & O_RDONLY) || (flags == O_RDONLY ) ? EE_FILENOTFOUND :
  85.      EE_CANTCREATEFILE,
  86.      MYF(ME_BELL+ME_WAITTANG), filename, my_errno);
  87.   DBUG_RETURN((FILE*) 0);
  88. } /* my_fopen */
  89. /* Close a stream */
  90. int my_fclose(FILE *fd, myf MyFlags)
  91. {
  92.   int err,file;
  93.   DBUG_ENTER("my_fclose");
  94.   DBUG_PRINT("my",("stream: 0x%lx  MyFlags: %d",fd, MyFlags));
  95.   pthread_mutex_lock(&THR_LOCK_open);
  96.   file=fileno(fd);
  97.   if ((err = fclose(fd)) < 0)
  98.   {
  99.     my_errno=errno;
  100.     if (MyFlags & (MY_FAE | MY_WME))
  101.       my_error(EE_BADCLOSE, MYF(ME_BELL+ME_WAITTANG),
  102.        my_filename(file),errno);
  103.   }
  104.   else
  105.     my_stream_opened--;
  106.   if ((uint) file < my_file_limit && my_file_info[file].type != UNOPEN)
  107.   {
  108.     my_file_info[file].type = UNOPEN;
  109.     my_free(my_file_info[file].name, MYF(MY_ALLOW_ZERO_PTR));
  110.   }
  111.   pthread_mutex_unlock(&THR_LOCK_open);
  112.   DBUG_RETURN(err);
  113. } /* my_fclose */
  114. /* Make a stream out of a file handle */
  115. /* Name may be 0 */
  116. FILE *my_fdopen(File Filedes, const char *name, int Flags, myf MyFlags)
  117. {
  118.   FILE *fd;
  119.   char type[5];
  120.   DBUG_ENTER("my_fdopen");
  121.   DBUG_PRINT("my",("Fd: %d  Flags: %d  MyFlags: %d",
  122.    Filedes, Flags, MyFlags));
  123.   make_ftype(type,Flags);
  124.   if ((fd = fdopen(Filedes, type)) == 0)
  125.   {
  126.     my_errno=errno;
  127.     if (MyFlags & (MY_FAE | MY_WME))
  128.       my_error(EE_CANT_OPEN_STREAM, MYF(ME_BELL+ME_WAITTANG),errno);
  129.   }
  130.   else
  131.   {
  132.     pthread_mutex_lock(&THR_LOCK_open);
  133.     my_stream_opened++;
  134.     if ((uint) Filedes < (uint) my_file_limit)
  135.     {
  136.       if (my_file_info[Filedes].type != UNOPEN)
  137.       {
  138.         my_file_opened--; /* File is opened with my_open ! */
  139.       }
  140.       else
  141.       {
  142.         my_file_info[Filedes].name=  my_strdup(name,MyFlags);
  143.       }
  144.       my_file_info[Filedes].type = STREAM_BY_FDOPEN;
  145.     }
  146.     pthread_mutex_unlock(&THR_LOCK_open);
  147.   }
  148.   DBUG_PRINT("exit",("stream: 0x%lx",fd));
  149.   DBUG_RETURN(fd);
  150. } /* my_fdopen */
  151. /*   
  152.   Make a fopen() typestring from a open() type bitmap
  153.   SYNOPSIS
  154.     make_ftype()
  155.     to String for fopen() is stored here
  156.     flag Flag used by open()
  157.   IMPLEMENTATION
  158.     This routine attempts to find the best possible match 
  159.     between  a numeric option and a string option that could be 
  160.     fed to fopen.  There is not a 1 to 1 mapping between the two.  
  161.   
  162.   NOTE
  163.     On Unix, O_RDONLY is usually 0
  164.   MAPPING
  165.     r  == O_RDONLY   
  166.     w  == O_WRONLY|O_TRUNC|O_CREAT  
  167.     a  == O_WRONLY|O_APPEND|O_CREAT  
  168.     r+ == O_RDWR  
  169.     w+ == O_RDWR|O_TRUNC|O_CREAT  
  170.     a+ == O_RDWR|O_APPEND|O_CREAT
  171. */
  172. static void make_ftype(register my_string to, register int flag)
  173. {
  174.   /* check some possible invalid combinations */  
  175.   DBUG_ASSERT((flag & (O_TRUNC | O_APPEND)) != (O_TRUNC | O_APPEND));
  176.   DBUG_ASSERT((flag & (O_WRONLY | O_RDWR)) != (O_WRONLY | O_RDWR));
  177.   if ((flag & (O_RDONLY|O_WRONLY)) == O_WRONLY)    
  178.     *to++= (flag & O_APPEND) ? 'a' : 'w';  
  179.   else if (flag & O_RDWR)          
  180.   {
  181.     /* Add '+' after theese */    
  182.     if (flag & (O_TRUNC | O_CREAT))      
  183.       *to++= 'w';    
  184.     else if (flag & O_APPEND)      
  185.       *to++= 'a';    
  186.     else      
  187.       *to++= 'r';
  188.     *to++= '+';  
  189.   }  
  190.   else    
  191.     *to++= 'r';
  192. #if FILE_BINARY            /* If we have binary-files */  
  193.   if (flag & FILE_BINARY)    
  194.     *to++='b';
  195. #endif  
  196.   *to='';
  197. } /* make_ftype */