![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to filewrap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / xpdev|
Return to filewrap.c CVS log | Up to [Synchronet] / sbbs / xpdev |
1.1 ! root 1: /* filewrap.c */ ! 2: ! 3: /* File-related system-call wrappers */ ! 4: ! 5: /* $Id: filewrap.c,v 1.29 2004/07/20 23:26:58 rswindell Exp $ */ ! 6: ! 7: /**************************************************************************** ! 8: * @format.tab-size 4 (Plain Text/Source Code File Header) * ! 9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) * ! 10: * * ! 11: * Copyright 2004 Rob Swindell - http://www.synchro.net/copyright.html * ! 12: * * ! 13: * This library is free software; you can redistribute it and/or * ! 14: * modify it under the terms of the GNU Lesser General Public License * ! 15: * as published by the Free Software Foundation; either version 2 * ! 16: * of the License, or (at your option) any later version. * ! 17: * See the GNU Lesser General Public License for more details: lgpl.txt or * ! 18: * http://www.fsf.org/copyleft/lesser.html * ! 19: * * ! 20: * Anonymous FTP access to the most recent released source is available at * ! 21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net * ! 22: * * ! 23: * Anonymous CVS access to the development source and modification history * ! 24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: * ! 25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login * ! 26: * (just hit return, no password is necessary) * ! 27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src * ! 28: * * ! 29: * For Synchronet coding style and modification guidelines, see * ! 30: * http://www.synchro.net/source.html * ! 31: * * ! 32: * You are encouraged to submit any modifications (preferably in Unix diff * ! 33: * format) via e-mail to [email protected] * ! 34: * * ! 35: * Note: If this box doesn't appear square, then you need to fix your tabs. * ! 36: ****************************************************************************/ ! 37: ! 38: /* OS-specific */ ! 39: #if defined(__unix__) ! 40: ! 41: #include <stdarg.h> /* va_list */ ! 42: #include <string.h> /* strlen() */ ! 43: #include <unistd.h> /* getpid() */ ! 44: #include <fcntl.h> /* fcntl() file/record locking */ ! 45: #include <sys/file.h> /* L_SET for Solaris */ ! 46: #include <errno.h> ! 47: #include <sys/param.h> /* BSD */ ! 48: ! 49: #endif ! 50: ! 51: /* ANSI */ ! 52: #include <sys/types.h> /* _dev_t */ ! 53: #include <sys/stat.h> /* struct stat */ ! 54: ! 55: #include "filewrap.h" /* Verify prototypes */ ! 56: ! 57: /****************************************************************************/ ! 58: /* Returns the modification time of the file in 'fd' */ ! 59: /****************************************************************************/ ! 60: time_t DLLCALL filetime(int fd) ! 61: { ! 62: struct stat st; ! 63: ! 64: if(fstat(fd, &st)!=0) ! 65: return(-1); ! 66: ! 67: return(st.st_mtime); ! 68: } ! 69: ! 70: #if defined(__unix__) && !defined(__BORLANDC__) ! 71: ! 72: /****************************************************************************/ ! 73: /* Returns the length of the file in 'fd' */ ! 74: /****************************************************************************/ ! 75: long DLLCALL filelength(int fd) ! 76: { ! 77: struct stat st; ! 78: ! 79: if(fstat(fd, &st)!=0) ! 80: return(-1L); ! 81: ! 82: return(st.st_size); ! 83: } ! 84: ! 85: /* Sets a lock on a portion of a file */ ! 86: int DLLCALL lock(int fd, long pos, long len) ! 87: { ! 88: #if defined(F_SANERDLCKNO) || !defined(BSD) ! 89: struct flock alock; ! 90: ! 91: #ifndef F_SANEWRLCKNO ! 92: int flags; ! 93: if((flags=fcntl(fd,F_GETFL))==-1) ! 94: return -1; ! 95: ! 96: if(flags==O_RDONLY) ! 97: alock.l_type = F_RDLCK; /* set read lock to prevent writes */ ! 98: else ! 99: alock.l_type = F_WRLCK; /* set write lock to prevent all access */ ! 100: #else ! 101: alock.l_type = F_SANEWRLCKNO; ! 102: #endif ! 103: alock.l_whence = L_SET; /* SEEK_SET */ ! 104: alock.l_start = pos; ! 105: alock.l_len = (int)len; ! 106: ! 107: if(fcntl(fd, F_SETLK, &alock)==-1 && errno != EINVAL) ! 108: return(-1); ! 109: #endif ! 110: ! 111: #if !defined(F_SANEWRLCKNO) && !defined(__QNX__) && !defined(__solaris__) ! 112: /* use flock (doesn't work over NFS) */ ! 113: if(flock(fd,LOCK_EX|LOCK_NB)!=0 && errno != EOPNOTSUPP) ! 114: return(-1); ! 115: #endif ! 116: ! 117: return(0); ! 118: } ! 119: ! 120: /* Removes a lock from a file record */ ! 121: int DLLCALL unlock(int fd, long pos, long len) ! 122: { ! 123: ! 124: #if defined(F_SANEUNLCK) || !defined(BSD) ! 125: struct flock alock; ! 126: #ifdef F_SANEUNLCK ! 127: alock.l_type = F_SANEUNLCK; /* remove the lock */ ! 128: #else ! 129: alock.l_type = F_UNLCK; /* remove the lock */ ! 130: #endif ! 131: alock.l_whence = L_SET; ! 132: alock.l_start = pos; ! 133: alock.l_len = (int)len; ! 134: if(fcntl(fd, F_SETLK, &alock)==-1 && errno != EINVAL) ! 135: return(-1); ! 136: #endif ! 137: ! 138: #if !defined(F_SANEUNLCK) && !defined(__QNX__) && !defined(__solaris__) ! 139: /* use flock (doesn't work over NFS) */ ! 140: if(flock(fd,LOCK_UN|LOCK_NB)!=0 && errno != EOPNOTSUPP) ! 141: return(-1); ! 142: #endif ! 143: ! 144: return(0); ! 145: } ! 146: ! 147: /* Opens a file in specified sharing (file-locking) mode */ ! 148: #if !defined(__QNX__) ! 149: int DLLCALL sopen(const char *fn, int access, int share, ...) ! 150: { ! 151: int fd; ! 152: int pmode=S_IREAD; ! 153: #ifndef F_SANEWRLCKNO ! 154: int flock_op=LOCK_NB; /* non-blocking */ ! 155: #endif ! 156: #if defined(F_SANEWRLCKNO) || !defined(BSD) ! 157: struct flock alock; ! 158: #endif ! 159: va_list ap; ! 160: ! 161: if(access&O_CREAT) { ! 162: va_start(ap,share); ! 163: pmode = va_arg(ap,unsigned int); ! 164: va_end(ap); ! 165: } ! 166: ! 167: if ((fd = open(fn, access, pmode)) < 0) ! 168: return -1; ! 169: ! 170: if (share == SH_DENYNO) /* no lock needed */ ! 171: return fd; ! 172: #if defined(F_SANEWRLCKNO) || !defined(BSD) ! 173: /* use fcntl (doesn't work correctly with threads) */ ! 174: alock.l_type = share; ! 175: alock.l_whence = L_SET; ! 176: alock.l_start = 0; ! 177: alock.l_len = 0; /* lock to EOF */ ! 178: ! 179: if(fcntl(fd, F_SETLK, &alock)==-1 && errno != EINVAL) { /* EINVAL means the file does not support locking */ ! 180: close(fd); ! 181: return -1; ! 182: } ! 183: #endif ! 184: ! 185: #if !defined(F_SANEWRLCKNO) && !defined(__QNX__) && !defined(__solaris__) ! 186: /* use flock (doesn't work over NFS) */ ! 187: if(share==SH_DENYRW) ! 188: flock_op|=LOCK_EX; ! 189: else /* SH_DENYWR */ ! 190: flock_op|=LOCK_SH; ! 191: if(flock(fd,flock_op)!=0 && errno != EOPNOTSUPP) { /* That object doesn't do locks */ ! 192: if(errno==EWOULDBLOCK) ! 193: errno=EAGAIN; ! 194: close(fd); ! 195: return(-1); ! 196: } ! 197: #endif ! 198: ! 199: return fd; ! 200: } ! 201: #endif /* !QNX */ ! 202: ! 203: #elif defined(_MSC_VER) || defined(__MINGW32__) || defined(__DMC__) ! 204: ! 205: #include <io.h> /* tell */ ! 206: #include <stdio.h> /* SEEK_SET */ ! 207: #include <sys/locking.h> /* _locking */ ! 208: ! 209: /* Fix MinGW locking.h typo */ ! 210: #if defined LK_UNLOCK && !defined LK_UNLCK ! 211: #define LK_UNLCK LK_UNLOCK ! 212: #endif ! 213: ! 214: int DLLCALL lock(int file, long offset, long size) ! 215: { ! 216: int i; ! 217: long pos; ! 218: ! 219: pos=tell(file); ! 220: if(offset!=pos) ! 221: lseek(file, offset, SEEK_SET); ! 222: i=_locking(file,LK_NBLCK,size); ! 223: if(offset!=pos) ! 224: lseek(file, pos, SEEK_SET); ! 225: return(i); ! 226: } ! 227: ! 228: int DLLCALL unlock(int file, long offset, long size) ! 229: { ! 230: int i; ! 231: long pos; ! 232: ! 233: pos=tell(file); ! 234: if(offset!=pos) ! 235: lseek(file, offset, SEEK_SET); ! 236: i=_locking(file,LK_UNLCK,size); ! 237: if(offset!=pos) ! 238: lseek(file, pos, SEEK_SET); ! 239: return(i); ! 240: } ! 241: ! 242: #endif /* !Unix && (MSVC || MinGW) */ ! 243: ! 244: #ifdef __unix__ ! 245: FILE *_fsopen(char *pszFilename, char *pszMode, int shmode) ! 246: { ! 247: int file; ! 248: int Mode=0; ! 249: char *p; ! 250: ! 251: for(p=pszMode;*p;p++) { ! 252: switch (*p) { ! 253: case 'r': ! 254: Mode |= 1; ! 255: break; ! 256: case 'w': ! 257: Mode |= 2; ! 258: break; ! 259: case 'a': ! 260: Mode |= 4; ! 261: break; ! 262: case '+': ! 263: Mode |= 8; ! 264: break; ! 265: case 'b': ! 266: case 't': ! 267: break; ! 268: default: ! 269: errno=EINVAL; ! 270: return(NULL); ! 271: } ! 272: } ! 273: switch(Mode) { ! 274: case 1: ! 275: Mode=O_RDONLY; ! 276: break; ! 277: case 2: ! 278: Mode=O_WRONLY|O_CREAT|O_TRUNC; ! 279: break; ! 280: case 4: ! 281: Mode=O_APPEND|O_WRONLY|O_CREAT; ! 282: break; ! 283: case 9: ! 284: Mode=O_RDWR|O_CREAT; ! 285: break; ! 286: case 10: ! 287: Mode=O_RDWR|O_CREAT|O_TRUNC; ! 288: break; ! 289: case 12: ! 290: Mode=O_RDWR|O_APPEND|O_CREAT; ! 291: break; ! 292: default: ! 293: errno=EINVAL; ! 294: return(NULL); ! 295: } ! 296: if(Mode&O_CREAT) ! 297: file=sopen(pszFilename,Mode,shmode,S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); ! 298: else ! 299: file=sopen(pszFilename,Mode,shmode); ! 300: if(file==-1) ! 301: return(NULL); ! 302: return(fdopen(file,pszMode)); ! 303: } ! 304: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.