maint/gnulib/lib/ftruncate.c

/* */
This source file includes following definitions.
SetFileSize
ftruncate
chsize_nothrow
ftruncate
   1 /* ftruncate emulations for native Windows.
   2    Copyright (C) 1992-2021 Free Software Foundation, Inc.
   3 
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3, or (at your option)
   7    any later version.
   8 
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13 
  14    You should have received a copy of the GNU General Public License along
  15    with this program; if not, see <https://www.gnu.org/licenses/>.  */
  16 
  17 #include <config.h>
  18 
  19 /* Specification.  */
  20 #include <unistd.h>
  21 
  22 #if HAVE__CHSIZE
  23 /* A native Windows platform.  */
  24 
  25 # include <errno.h>
  26 
  27 # if _GL_WINDOWS_64_BIT_OFF_T
  28 
  29 /* Large File Support: off_t is 64-bit, but _chsize() takes only a 32-bit
  30    argument.  So, define a 64-bit safe SetFileSize function ourselves.  */
  31 
  32 /* Ensure that <windows.h> declares GetFileSizeEx.  */
  33 #  if !defined _WIN32_WINNT || (_WIN32_WINNT < _WIN32_WINNT_WIN2K)
  34 #   undef _WIN32_WINNT
  35 #   define _WIN32_WINNT _WIN32_WINNT_WIN2K
  36 #  endif
  37 
  38 /* Get declarations of the native Windows API functions.  */
  39 #  define WIN32_LEAN_AND_MEAN
  40 #  include <windows.h>
  41 
  42 /* Get _get_osfhandle.  */
  43 #  if GNULIB_MSVC_NOTHROW
  44 #   include "msvc-nothrow.h"
  45 #  else
  46 #   include <io.h>
  47 #  endif
  48 
  49 static BOOL
  50 SetFileSize (HANDLE h, LONGLONG size)
     /*  */
  51 {
  52   LARGE_INTEGER old_size;
  53 
  54   if (!GetFileSizeEx (h, &old_size))
  55     return FALSE;
  56 
  57   if (size != old_size.QuadPart)
  58     {
  59       /* Duplicate the handle, so we are free to modify its file position.  */
  60       HANDLE curr_process = GetCurrentProcess ();
  61       HANDLE tmph;
  62 
  63       if (!DuplicateHandle (curr_process,           /* SourceProcessHandle */
  64                             h,                      /* SourceHandle */
  65                             curr_process,           /* TargetProcessHandle */
  66                             (PHANDLE) &tmph,        /* TargetHandle */
  67                             (DWORD) 0,              /* DesiredAccess */
  68                             FALSE,                  /* InheritHandle */
  69                             DUPLICATE_SAME_ACCESS)) /* Options */
  70         return FALSE;
  71 
  72       if (size < old_size.QuadPart)
  73         {
  74           /* Reduce the size.  */
  75           LONG size_hi = (LONG) (size >> 32);
  76           if (SetFilePointer (tmph, (LONG) size, &size_hi, FILE_BEGIN)
  77               == INVALID_SET_FILE_POINTER
  78               && GetLastError() != NO_ERROR)
  79             {
  80               CloseHandle (tmph);
  81               return FALSE;
  82             }
  83           if (!SetEndOfFile (tmph))
  84             {
  85               CloseHandle (tmph);
  86               return FALSE;
  87             }
  88         }
  89       else
  90         {
  91           /* Increase the size by adding zero bytes at the end.  */
  92           static char zero_bytes[1024];
  93           LONG pos_hi = 0;
  94           LONG pos_lo = SetFilePointer (tmph, (LONG) 0, &pos_hi, FILE_END);
  95           LONGLONG pos;
  96           if (pos_lo == INVALID_SET_FILE_POINTER
  97               && GetLastError() != NO_ERROR)
  98             {
  99               CloseHandle (tmph);
 100               return FALSE;
 101             }
 102           pos = ((LONGLONG) pos_hi << 32) | (ULONGLONG) (ULONG) pos_lo;
 103           while (pos < size)
 104             {
 105               DWORD written;
 106               LONGLONG count = size - pos;
 107               if (count > sizeof (zero_bytes))
 108                 count = sizeof (zero_bytes);
 109               if (!WriteFile (tmph, zero_bytes, (DWORD) count, &written, NULL)
 110                   || written == 0)
 111                 {
 112                   CloseHandle (tmph);
 113                   return FALSE;
 114                 }
 115               pos += (ULONGLONG) (ULONG) written;
 116             }
 117         }
 118       /* Close the handle.  */
 119       CloseHandle (tmph);
 120     }
 121   return TRUE;
 122 }
 123 
 124 int
 125 ftruncate (int fd, off_t length)
     /*  */
 126 {
 127   HANDLE handle = (HANDLE) _get_osfhandle (fd);
 128 
 129   if (handle == INVALID_HANDLE_VALUE)
 130     {
 131       errno = EBADF;
 132       return -1;
 133     }
 134   if (length < 0)
 135     {
 136       errno = EINVAL;
 137       return -1;
 138     }
 139   if (!SetFileSize (handle, length))
 140     {
 141       switch (GetLastError ())
 142         {
 143         case ERROR_ACCESS_DENIED:
 144           errno = EACCES;
 145           break;
 146         case ERROR_HANDLE_DISK_FULL:
 147         case ERROR_DISK_FULL:
 148         case ERROR_DISK_TOO_FRAGMENTED:
 149           errno = ENOSPC;
 150           break;
 151         default:
 152           errno = EIO;
 153           break;
 154         }
 155       return -1;
 156     }
 157   return 0;
 158 }
 159 
 160 # else
 161 
 162 #  include <io.h>
 163 
 164 #  if HAVE_MSVC_INVALID_PARAMETER_HANDLER
 165 #   include "msvc-inval.h"
 166 static int
 167 chsize_nothrow (int fd, long length)
     /*  */
 168 {
 169   int result;
 170 
 171   TRY_MSVC_INVAL
 172     {
 173       result = _chsize (fd, length);
 174     }
 175   CATCH_MSVC_INVAL
 176     {
 177       result = -1;
 178       errno = EBADF;
 179     }
 180   DONE_MSVC_INVAL;
 181 
 182   return result;
 183 }
 184 #  else
 185 #   define chsize_nothrow _chsize
 186 #  endif
 187 
 188 int
 189 ftruncate (int fd, off_t length)
     /*  */
 190 {
 191   return chsize_nothrow (fd, length);
 192 }
 193 
 194 # endif
 195 #endif
/* */
root/maint/gnulib/lib/ftruncate.c

DEFINITIONS
