dep/mysqllite/mysys/my_fstream.c

   1 /* Copyright (C) 2000 MySQL AB
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; version 2 of the License.
   6
   7    This program is distributed in the hope that it will be useful,
   8    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10    GNU General Public License for more details.
  11
  12    You should have received a copy of the GNU General Public License
  13    along with this program; if not, write to the Free Software
  14    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  15
  16 /* USE_MY_STREAM isn't set because we can't thrust my_fclose! */
  17
  18 #include "mysys_priv.h"
  19 #include "mysys_err.h"
  20 #include <errno.h>
  21 #include <stdio.h>
  22
  23 #ifdef HAVE_FSEEKO
  24 #undef ftell
  25 #undef fseek
  26 #define ftell(A) ftello(A)
  27 #define fseek(A,B,C) fseeko((A),(B),(C))
  28 #endif
  29
  30 /*
  31   Read a chunk of bytes from a FILE
  32
  33   SYNOPSIS
  34    my_fread()
  35    stream       File descriptor
  36    Buffer       Buffer to read to
  37    Count        Number of bytes to read
  38    MyFlags      Flags on what to do on error
  39
  40   RETURN
  41     (size_t) -1 Error
  42     #           Number of bytes read
  43  */
  44
  45 size_t my_fread(FILE *stream, uchar *Buffer, size_t Count, myf MyFlags)
  46 {
  47   size_t readbytes;
  48   DBUG_ENTER("my_fread");
  49   DBUG_PRINT("my",("stream: 0x%lx  Buffer: 0x%lx  Count: %u  MyFlags: %d",
  50                    (long) stream, (long) Buffer, (uint) Count, MyFlags));
  51
  52   if ((readbytes= fread(Buffer, sizeof(char), Count, stream)) != Count)
  53   {
  54     DBUG_PRINT("error",("Read only %d bytes", (int) readbytes));
  55     if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
  56     {
  57       if (ferror(stream))
  58         my_error(EE_READ, MYF(ME_BELL+ME_WAITTANG),
  59                  my_filename(fileno(stream)),errno);
  60       else
  61       if (MyFlags & (MY_NABP | MY_FNABP))
  62         my_error(EE_EOFERR, MYF(ME_BELL+ME_WAITTANG),
  63                  my_filename(fileno(stream)),errno);
  64     }
  65     my_errno=errno ? errno : -1;
  66     if (ferror(stream) || MyFlags & (MY_NABP | MY_FNABP))
  67       DBUG_RETURN((size_t) -1);                 /* Return with error */
  68   }
  69   if (MyFlags & (MY_NABP | MY_FNABP))
  70     DBUG_RETURN(0);                             /* Read ok */
  71   DBUG_RETURN(readbytes);
  72 } /* my_fread */
  73
  74
  75 /*
  76   Write a chunk of bytes to a stream
  77
  78    my_fwrite()
  79    stream       File descriptor
  80    Buffer       Buffer to write from
  81    Count        Number of bytes to write
  82    MyFlags      Flags on what to do on error
  83
  84   RETURN
  85     (size_t) -1 Error
  86     #           Number of bytes written
  87 */
  88
  89 size_t my_fwrite(FILE *stream, const uchar *Buffer, size_t Count, myf MyFlags)
  90 {
  91   size_t writtenbytes =0;
  92   my_off_t seekptr;
  93 #if !defined(NO_BACKGROUND) && defined(USE_MY_STREAM)
  94   uint errors;
  95 #endif
  96   DBUG_ENTER("my_fwrite");
  97   DBUG_PRINT("my",("stream: 0x%lx  Buffer: 0x%lx  Count: %u  MyFlags: %d",
  98                    (long) stream, (long) Buffer, (uint) Count, MyFlags));
  99
 100 #if !defined(NO_BACKGROUND) && defined(USE_MY_STREAM)
 101   errors=0;
 102 #endif
 103   seekptr= ftell(stream);
 104   for (;;)
 105   {
 106     size_t written;
 107     if ((written = (size_t) fwrite((char*) Buffer,sizeof(char),
 108                                    Count, stream)) != Count)
 109     {
 110       DBUG_PRINT("error",("Write only %d bytes", (int) writtenbytes));
 111       my_errno=errno;
 112       if (written != (size_t) -1)
 113       {
 114         seekptr+=written;
 115         Buffer+=written;
 116         writtenbytes+=written;
 117         Count-=written;
 118       }
 119 #ifdef EINTR
 120       if (errno == EINTR)
 121       {
 122         VOID(my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0)));
 123         continue;
 124       }
 125 #endif
 126 #if !defined(NO_BACKGROUND) && defined(USE_MY_STREAM)
 127 #ifdef THREAD
 128       if (my_thread_var->abort)
 129         MyFlags&= ~ MY_WAIT_IF_FULL;            /* End if aborted by user */
 130 #endif
 131       if ((errno == ENOSPC || errno == EDQUOT) &&
 132           (MyFlags & MY_WAIT_IF_FULL))
 133       {
 134         wait_for_free_space("[stream]", errors);
 135         errors++;
 136         VOID(my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0)));
 137         continue;
 138       }
 139 #endif
 140       if (ferror(stream) || (MyFlags & (MY_NABP | MY_FNABP)))
 141       {
 142         if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
 143         {
 144           my_error(EE_WRITE, MYF(ME_BELL+ME_WAITTANG),
 145                    my_filename(fileno(stream)),errno);
 146         }
 147         writtenbytes= (size_t) -1;        /* Return that we got error */
 148         break;
 149       }
 150     }
 151     if (MyFlags & (MY_NABP | MY_FNABP))
 152       writtenbytes= 0;                          /* Everything OK */
 153     else
 154       writtenbytes+= written;
 155     break;
 156   }
 157   DBUG_RETURN(writtenbytes);
 158 } /* my_fwrite */
 159
 160
 161 /* Seek to position in file */
 162
 163 my_off_t my_fseek(FILE *stream, my_off_t pos, int whence,
 164                   myf MyFlags __attribute__((unused)))
 165 {
 166   DBUG_ENTER("my_fseek");
 167   DBUG_PRINT("my",("stream: 0x%lx  pos: %lu  whence: %d  MyFlags: %d",
 168                    (long) stream, (long) pos, whence, MyFlags));
 169   DBUG_RETURN(fseek(stream, (off_t) pos, whence) ?
 170               MY_FILEPOS_ERROR : (my_off_t) ftell(stream));
 171 } /* my_seek */
 172
 173
 174 /* Tell current position of file */
 175
 176 my_off_t my_ftell(FILE *stream, myf MyFlags __attribute__((unused)))
 177 {
 178   off_t pos;
 179   DBUG_ENTER("my_ftell");
 180   DBUG_PRINT("my",("stream: 0x%lx  MyFlags: %d", (long) stream, MyFlags));
 181   pos=ftell(stream);
 182   DBUG_PRINT("exit",("ftell: %lu",(ulong) pos));
 183   DBUG_RETURN((my_off_t) pos);
 184 } /* my_ftell */