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

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. #define USES_TYPES
  14. #include "mysys_priv.h"
  15. #include "mysys_err.h"
  16. #include <my_dir.h>
  17. #include <errno.h>
  18. #if defined(MSDOS) || defined(__WIN__) || defined(__EMX__) || defined(OS2)
  19. #include <share.h>
  20. #endif
  21. /*
  22.   Open a file
  23.   SYNOPSIS
  24.     my_open()
  25.       FileName Fully qualified file name
  26.       Flags Read | write 
  27.       MyFlags Special flags
  28.   RETURN VALUE
  29.     File descriptor
  30. */
  31. File my_open(const char *FileName, int Flags, myf MyFlags)
  32. /* Path-name of file */
  33. /* Read | write .. */
  34. /* Special flags */
  35. {
  36.   File fd;
  37.   DBUG_ENTER("my_open");
  38.   DBUG_PRINT("my",("Name: '%s'  Flags: %d  MyFlags: %d",
  39.    FileName, Flags, MyFlags));
  40. #if defined(MSDOS) || defined(__WIN__) || defined(__EMX__) || defined(OS2)
  41.   /* 
  42.     Check that we don't try to open or create a file name that may
  43.     cause problems for us in the future (like PRN)
  44.   */  
  45.   if (check_if_legal_filename(FileName))
  46.   {
  47.     errno= EACCES;
  48.     DBUG_RETURN(my_register_filename(-1, FileName, FILE_BY_OPEN,
  49.                                      EE_FILENOTFOUND, MyFlags));
  50.   }
  51.   if (Flags & O_SHARE)
  52.     fd = sopen((my_string) FileName, (Flags & ~O_SHARE) | O_BINARY, SH_DENYNO,
  53.        MY_S_IREAD | MY_S_IWRITE);
  54.   else
  55.     fd = open((my_string) FileName, Flags | O_BINARY,
  56.       MY_S_IREAD | MY_S_IWRITE);
  57. #elif !defined(NO_OPEN_3)
  58.   fd = open(FileName, Flags, my_umask); /* Normal unix */
  59. #else
  60.   fd = open((my_string) FileName, Flags);
  61. #endif
  62.   DBUG_RETURN(my_register_filename(fd, FileName, FILE_BY_OPEN,
  63.    EE_FILENOTFOUND, MyFlags));
  64. } /* my_open */
  65. /*
  66.   Close a file
  67.   SYNOPSIS
  68.     my_close()
  69.       fd File sescriptor
  70.       myf Special Flags
  71.       
  72. */
  73. int my_close(File fd, myf MyFlags)
  74. {
  75.   int err;
  76.   DBUG_ENTER("my_close");
  77.   DBUG_PRINT("my",("fd: %d  MyFlags: %d",fd, MyFlags));
  78.   pthread_mutex_lock(&THR_LOCK_open);
  79.   if ((err = close(fd)))
  80.   {
  81.     DBUG_PRINT("error",("Got error %d on close",err));
  82.     my_errno=errno;
  83.     if (MyFlags & (MY_FAE | MY_WME))
  84.       my_error(EE_BADCLOSE, MYF(ME_BELL+ME_WAITTANG),my_filename(fd),errno);
  85.   }
  86.   if ((uint) fd < my_file_limit && my_file_info[fd].type != UNOPEN)
  87.   {
  88.     my_free(my_file_info[fd].name, MYF(0));
  89. #if defined(THREAD) && !defined(HAVE_PREAD)
  90.     pthread_mutex_destroy(&my_file_info[fd].mutex);
  91. #endif
  92.     my_file_info[fd].type = UNOPEN;
  93.   }
  94.   my_file_opened--;
  95.   pthread_mutex_unlock(&THR_LOCK_open);
  96.   DBUG_RETURN(err);
  97. } /* my_close */
  98. /*
  99.   Register file in my_file_info[]
  100.    
  101.   SYNOPSIS
  102.     my_register_filename()
  103.       fd
  104.       FileName
  105.       type_file_type
  106. */
  107. File my_register_filename(File fd, const char *FileName, enum file_type
  108.   type_of_file, uint error_message_number, myf MyFlags)
  109. {
  110.   if ((int) fd >= 0)
  111.   {
  112.     if ((uint) fd >= my_file_limit)
  113.     {
  114. #if defined(THREAD) && !defined(HAVE_PREAD)
  115.       (void) my_close(fd,MyFlags);
  116.       my_errno=EMFILE;
  117.       if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
  118. my_error(EE_OUT_OF_FILERESOURCES, MYF(ME_BELL+ME_WAITTANG),
  119.  FileName, my_errno);
  120.       return(-1);
  121. #endif
  122.       thread_safe_increment(my_file_opened,&THR_LOCK_open);
  123.       return(fd); /* safeguard */
  124.     }
  125.     pthread_mutex_lock(&THR_LOCK_open);
  126.     if ((my_file_info[fd].name = (char*) my_strdup(FileName,MyFlags)))
  127.     {
  128.       my_file_opened++;
  129.       my_file_info[fd].type = type_of_file;
  130. #if defined(THREAD) && !defined(HAVE_PREAD)
  131.       pthread_mutex_init(&my_file_info[fd].mutex,MY_MUTEX_INIT_FAST);
  132. #endif
  133.       pthread_mutex_unlock(&THR_LOCK_open);
  134.       DBUG_PRINT("exit",("fd: %d",fd));
  135.       return(fd);
  136.     }
  137.     pthread_mutex_unlock(&THR_LOCK_open);
  138.     (void) my_close(fd, MyFlags);
  139.     my_errno=ENOMEM;
  140.   }
  141.   else
  142.     my_errno=errno;
  143.   DBUG_PRINT("error",("Got error %d on open",my_errno));
  144.   if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
  145.     my_error(error_message_number, MYF(ME_BELL+ME_WAITTANG),
  146.      FileName, my_errno);
  147.   return(fd);
  148. }