home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / mysys / my_fopen.c < prev    next >
C/C++ Source or Header  |  2000-10-03  |  5KB  |  175 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public
  5.    License as published by the Free Software Foundation; either
  6.    version 2 of the License, or (at your option) any later version.
  7.    
  8.    This library is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.    Library General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  17.  
  18. #include "mysys_priv.h"
  19. #include "my_static.h"
  20. #include <errno.h>
  21. #include "mysys_err.h"
  22.  
  23. static void    make_ftype(my_string to,int flag);
  24.  
  25.     /* Open a file as stream */
  26.  
  27. FILE *my_fopen(const char *FileName, int Flags, myf MyFlags)
  28.                     /* Path-name of file */
  29.                     /* Read | write .. */
  30.                     /* Special flags */
  31. {
  32.   FILE *fd;
  33.   char type[5];
  34.   DBUG_ENTER("my_fopen");
  35.   DBUG_PRINT("my",("Name: '%s'  Flags: %d  MyFlags: %d",
  36.            FileName, Flags, MyFlags));
  37.  
  38.   make_ftype(type,Flags);
  39.   if ((fd = fopen(FileName, type)) != 0)
  40.   {
  41.     /*
  42.       The test works if MY_NFILE < 128. The problem is that fileno() is char
  43.       on some OS (SUNOS). Actually the filename save isn't that important
  44.       so we can ignore if this doesn't work.
  45.     */
  46.     if ((uint) fileno(fd) >= MY_NFILE)
  47.     {
  48.       thread_safe_increment(my_stream_opened,&THR_LOCK_open);
  49.       DBUG_RETURN(fd);                /* safeguard */
  50.     }
  51.     pthread_mutex_lock(&THR_LOCK_open);
  52.     if ((my_file_info[fileno(fd)].name = (char*)
  53.      my_strdup(FileName,MyFlags)))
  54.     {
  55.       my_stream_opened++;
  56.       my_file_info[fileno(fd)].type = STREAM_BY_FOPEN;
  57.       pthread_mutex_unlock(&THR_LOCK_open);
  58.       DBUG_PRINT("exit",("stream: %lx",fd));
  59.       DBUG_RETURN(fd);
  60.     }
  61.     pthread_mutex_unlock(&THR_LOCK_open);
  62.     (void) my_fclose(fd,MyFlags);
  63.     my_errno=ENOMEM;
  64.   }
  65.   else
  66.     my_errno=errno;
  67.   DBUG_PRINT("error",("Got error %d on open",my_errno));
  68.   if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
  69.     my_error((Flags & O_RDONLY) || (Flags == O_RDONLY ) ? EE_FILENOTFOUND :
  70.          EE_CANTCREATEFILE,
  71.          MYF(ME_BELL+ME_WAITTANG), FileName,my_errno);
  72.   DBUG_RETURN((FILE*) 0);
  73. } /* my_fopen */
  74.  
  75.  
  76.     /* Close a stream */
  77.  
  78. int my_fclose(FILE *fd, myf MyFlags)
  79. {
  80.   int err,file;
  81.   DBUG_ENTER("my_fclose");
  82.   DBUG_PRINT("my",("stream: %lx  MyFlags: %d",fd, MyFlags));
  83.  
  84.   pthread_mutex_lock(&THR_LOCK_open);
  85.   file=fileno(fd);
  86.   if ((err = fclose(fd)) < 0)
  87.   {
  88.     my_errno=errno;
  89.     if (MyFlags & (MY_FAE | MY_WME))
  90.       my_error(EE_BADCLOSE, MYF(ME_BELL+ME_WAITTANG),
  91.            my_filename(file),errno);
  92.   }
  93.   else
  94.     my_stream_opened--;
  95.   if ((uint) file < MY_NFILE && my_file_info[file].type != UNOPEN)
  96.   {
  97.     my_file_info[file].type = UNOPEN;
  98.     my_free(my_file_info[file].name, MYF(MY_ALLOW_ZERO_PTR));
  99.   }
  100.   pthread_mutex_unlock(&THR_LOCK_open);
  101.   DBUG_RETURN(err);
  102. } /* my_fclose */
  103.  
  104.  
  105.     /* Make a stream out of a file handle */
  106.     /* Name may be 0 */
  107.  
  108. FILE *my_fdopen(File Filedes, const char *name, int Flags, myf MyFlags)
  109. {
  110.   FILE *fd;
  111.   char type[5];
  112.   DBUG_ENTER("my_fdopen");
  113.   DBUG_PRINT("my",("Fd: %d  Flags: %d  MyFlags: %d",
  114.            Filedes, Flags, MyFlags));
  115.  
  116.   make_ftype(type,Flags);
  117.   if ((fd = fdopen(Filedes, type)) == 0)
  118.   {
  119.     my_errno=errno;
  120.     if (MyFlags & (MY_FAE | MY_WME))
  121.       my_error(EE_CANT_OPEN_STREAM, MYF(ME_BELL+ME_WAITTANG),errno);
  122.   }
  123.   else
  124.   {
  125.     pthread_mutex_lock(&THR_LOCK_open);
  126.     my_stream_opened++;
  127.     if (Filedes < MY_NFILE)
  128.     {
  129.       if (my_file_info[Filedes].type != UNOPEN)
  130.       {
  131.         my_file_opened--;            /* File is opened with my_open ! */
  132.       }
  133.       else
  134.       {
  135.         my_file_info[Filedes].name=  my_strdup(name,MyFlags);
  136.       }
  137.       my_file_info[Filedes].type = STREAM_BY_FDOPEN;
  138.     }
  139.     pthread_mutex_unlock(&THR_LOCK_open);
  140.   }
  141.  
  142.   DBUG_PRINT("exit",("stream: %lx",fd));
  143.   DBUG_RETURN(fd);
  144. } /* my_fdopen */
  145.  
  146.  
  147.     /* Make a filehandler-open-typestring from ordinary inputflags */
  148.  
  149. static void make_ftype(register my_string to, register int flag)
  150. {
  151. #if FILE_BINARY                    /* If we have binary-files */
  152.   reg3 int org_flag=flag;
  153. #endif
  154.   flag&= ~FILE_BINARY;                /* remove binary bit */
  155.   if (flag == O_RDONLY)
  156.     *to++= 'r';
  157.   else if (flag == O_WRONLY)
  158.     *to++= 'w';
  159.   else
  160.   {                        /* Add '+' after theese */
  161.     if (flag == O_RDWR)
  162.       *to++= 'r';
  163.     else if (flag & O_APPEND)
  164.       *to++= 'a';
  165.     else
  166.       *to++= 'w';                /* Create file */
  167.     *to++= '+';
  168.   }
  169. #if FILE_BINARY                    /* If we have binary-files */
  170.   if (org_flag & FILE_BINARY)
  171.     *to++='b';
  172. #endif
  173.   *to='\0';
  174. } /* make_ftype */
  175.