devspec.en_US/project/recutils/lib/flock.c

   1 /* Emulate flock on platforms that lack it, primarily Windows and MinGW.
   2
   3    This is derived from sqlite3 sources.
   4    https://www.sqlite.org/src/finfo?name=src/os_win.c
   5    https://www.sqlite.org/copyright.html
   6
   7    Written by Richard W.M. Jones <rjones.at.redhat.com>
   8
   9    Copyright (C) 2008-2019 Free Software Foundation, Inc.
  10
  11    This library is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU General Public
  13    License as published by the Free Software Foundation; either
  14    version 3 of the License, or (at your option) any later version.
  15
  16    This library is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19    General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  23
  24 #include <config.h>
  25 #include <sys/file.h>
  26
  27 #if defined _WIN32 && ! defined __CYGWIN__
  28
  29 /* LockFileEx */
  30 # define WIN32_LEAN_AND_MEAN
  31 # include <windows.h>
  32
  33 # include <errno.h>
  34
  35 /* _get_osfhandle */
  36 # if GNULIB_MSVC_NOTHROW
  37 #  include "msvc-nothrow.h"
  38 # else
  39 #  include <io.h>
  40 # endif
  41
  42 /* Determine the current size of a file.  Because the other braindead
  43  * APIs we'll call need lower/upper 32 bit pairs, keep the file size
  44  * like that too.
  45  */
  46 static BOOL
  47 file_size (HANDLE h, DWORD * lower, DWORD * upper)
  48 {
  49   *lower = GetFileSize (h, upper);
  50   return 1;
  51 }
  52
  53 /* LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems. */
  54 # ifndef LOCKFILE_FAIL_IMMEDIATELY
  55 #  define LOCKFILE_FAIL_IMMEDIATELY 1
  56 # endif
  57
  58 /* Acquire a lock. */
  59 static BOOL
  60 do_lock (HANDLE h, int non_blocking, int exclusive)
  61 {
  62   BOOL res;
  63   DWORD size_lower, size_upper;
  64   OVERLAPPED ovlp;
  65   int flags = 0;
  66
  67   /* We're going to lock the whole file, so get the file size. */
  68   res = file_size (h, &size_lower, &size_upper);
  69   if (!res)
  70     return 0;
  71
  72   /* Start offset is 0, and also zero the remaining members of this struct. */
  73   memset (&ovlp, 0, sizeof ovlp);
  74
  75   if (non_blocking)
  76     flags |= LOCKFILE_FAIL_IMMEDIATELY;
  77   if (exclusive)
  78     flags |= LOCKFILE_EXCLUSIVE_LOCK;
  79
  80   return LockFileEx (h, flags, 0, size_lower, size_upper, &ovlp);
  81 }
  82
  83 /* Unlock reader or exclusive lock. */
  84 static BOOL
  85 do_unlock (HANDLE h)
  86 {
  87   int res;
  88   DWORD size_lower, size_upper;
  89
  90   res = file_size (h, &size_lower, &size_upper);
  91   if (!res)
  92     return 0;
  93
  94   return UnlockFile (h, 0, 0, size_lower, size_upper);
  95 }
  96
  97 /* Now our BSD-like flock operation. */
  98 int
  99 flock (int fd, int operation)
 100 {
 101   HANDLE h = (HANDLE) _get_osfhandle (fd);
 102   DWORD res;
 103   int non_blocking;
 104
 105   if (h == INVALID_HANDLE_VALUE)
 106     {
 107       errno = EBADF;
 108       return -1;
 109     }
 110
 111   non_blocking = operation & LOCK_NB;
 112   operation &= ~LOCK_NB;
 113
 114   switch (operation)
 115     {
 116     case LOCK_SH:
 117       res = do_lock (h, non_blocking, 0);
 118       break;
 119     case LOCK_EX:
 120       res = do_lock (h, non_blocking, 1);
 121       break;
 122     case LOCK_UN:
 123       res = do_unlock (h);
 124       break;
 125     default:
 126       errno = EINVAL;
 127       return -1;
 128     }
 129
 130   /* Map Windows errors into Unix errnos.  As usual MSDN fails to
 131    * document the permissible error codes.
 132    */
 133   if (!res)
 134     {
 135       DWORD err = GetLastError ();
 136       switch (err)
 137         {
 138           /* This means someone else is holding a lock. */
 139         case ERROR_LOCK_VIOLATION:
 140           errno = EAGAIN;
 141           break;
 142
 143           /* Out of memory. */
 144         case ERROR_NOT_ENOUGH_MEMORY:
 145           errno = ENOMEM;
 146           break;
 147
 148         case ERROR_BAD_COMMAND:
 149           errno = EINVAL;
 150           break;
 151
 152           /* Unlikely to be other errors, but at least don't lose the
 153            * error code.
 154            */
 155         default:
 156           errno = err;
 157         }
 158
 159       return -1;
 160     }
 161
 162   return 0;
 163 }
 164
 165 #else /* !Windows */
 166
 167 # ifdef HAVE_STRUCT_FLOCK_L_TYPE
 168 /* We know how to implement flock in terms of fcntl. */
 169
 170 #  include <fcntl.h>
 171
 172 #  ifdef HAVE_UNISTD_H
 173 #   include <unistd.h>
 174 #  endif
 175
 176 #  include <errno.h>
 177 #  include <string.h>
 178
 179 int
 180 flock (int fd, int operation)
 181 {
 182   int cmd, r;
 183   struct flock fl;
 184
 185   if (operation & LOCK_NB)
 186     cmd = F_SETLK;
 187   else
 188     cmd = F_SETLKW;
 189   operation &= ~LOCK_NB;
 190
 191   memset (&fl, 0, sizeof fl);
 192   fl.l_whence = SEEK_SET;
 193   /* l_start & l_len are 0, which as a special case means "whole file". */
 194
 195   switch (operation)
 196     {
 197     case LOCK_SH:
 198       fl.l_type = F_RDLCK;
 199       break;
 200     case LOCK_EX:
 201       fl.l_type = F_WRLCK;
 202       break;
 203     case LOCK_UN:
 204       fl.l_type = F_UNLCK;
 205       break;
 206     default:
 207       errno = EINVAL;
 208       return -1;
 209     }
 210
 211   r = fcntl (fd, cmd, &fl);
 212   if (r == -1 && errno == EACCES)
 213     errno = EAGAIN;
 214
 215   return r;
 216 }
 217
 218 # else /* !HAVE_STRUCT_FLOCK_L_TYPE */
 219
 220 #  error "This platform lacks flock function, and Gnulib doesn't provide a replacement. This is a bug in Gnulib."
 221
 222 # endif /* !HAVE_STRUCT_FLOCK_L_TYPE */
 223
 224 #endif /* !Windows */