home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / mint / mntlib24 / lockf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-08-03  |  1.5 KB  |  93 lines
  1. /*
  2.  * lockf(3) and flock(2) emulation for MiNT by Dave Gymer
  3.  * Placed in the public domain; do with me as you will!
  4.  * BUGS: doesn't block, unlike BSD or SysV
  5.  */
  6.  
  7. #include <compiler.h>
  8. #include "lib.h"
  9. #include <errno.h>
  10. #include <fcntl.h>
  11. #include <unistd.h>
  12. #include <mintbind.h>
  13. #ifdef __TURBOC__
  14. #include <sys\file.h>
  15. #else
  16. #include <sys/file.h>
  17. #endif
  18.  
  19. static int do_lock __PROTO((int fd, int cmd, long size, int whence));
  20.  
  21. static int
  22. do_lock(fd, cmd, size, whence)
  23.     int fd;
  24.     int cmd;
  25.     long size;
  26.     int whence;
  27. {
  28.     struct flock lock;
  29.     int fcmd;
  30.     long r;
  31.     extern int __mint;
  32.  
  33.     if (!__mint) {
  34.         errno = -EINVAL;
  35.         return -1;
  36.     }
  37.     lock.l_whence = whence;
  38.     lock.l_start = 0;
  39.     lock.l_len = size;
  40.     switch (cmd) {
  41.         case F_ULOCK:
  42.             lock.l_type = F_UNLCK;
  43.             fcmd = F_SETLK;
  44.             break;
  45.         case F_TEST:
  46.             lock.l_type = F_WRLCK;
  47.             fcmd = F_GETLK;
  48.             break;
  49.         case F_TLOCK:
  50.             lock.l_type = F_WRLCK;
  51.             fcmd = F_SETLK;
  52.             break;
  53.         case F_LOCK:
  54.             lock.l_type = F_WRLCK;
  55.             fcmd = F_SETLK;
  56.             break;
  57.         default:
  58.             errno = -EINVAL;
  59.             return -1;
  60.     }
  61.     if ((r = Fcntl(fd, &lock, fcmd)) < 0) {
  62.         errno = (int) -r;
  63.         return -1;
  64.     }
  65.     return 0;
  66. }
  67.  
  68. int
  69. lockf(fd, cmd, size)
  70.     int fd;
  71.     int cmd;
  72.     long size;
  73. {
  74.     return do_lock(fd, cmd, size, 1);
  75. }
  76.  
  77. int
  78. flock(fd, op)
  79.     int fd, op;
  80. {
  81.     int cmd;
  82.  
  83.     if (op & (LOCK_SH | LOCK_EX))
  84.         cmd = (op & LOCK_NB) ? F_TLOCK : F_LOCK;
  85.     else if (op & LOCK_UN)
  86.         cmd = F_ULOCK;
  87.     else {
  88.         errno = -EINVAL;
  89.         return -1;
  90.     }
  91.     return do_lock(fd, cmd, 0L, 0);
  92. }
  93.