![[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 / src / xpdev|
Return to filewrap.c CVS log | Up to [Synchronet] / sbbs / src / xpdev |
1.1 root 1: /* filewrap.c */
2:
3: /* File-related system-call wrappers */
4:
5: /* $Id: filewrap.c,v 1.33 2006/05/18 04:09:35 deuce 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: if(flags==O_RDONLY)
96: alock.l_type = F_RDLCK; /* set read lock to prevent writes */
97: else
98: alock.l_type = F_WRLCK; /* set write lock to prevent all access */
99: #else
100: alock.l_type = F_SANEWRLCKNO;
101: #endif
102: alock.l_whence = L_SET; /* SEEK_SET */
103: alock.l_start = pos;
104: alock.l_len = (int)len;
105:
106: if(fcntl(fd, F_SETLK, &alock)==-1 && errno != EINVAL)
107: return(-1);
108: #endif
109:
110: #if !defined(F_SANEWRLCKNO) && !defined(__QNX__) && !defined(__solaris__)
111: /* use flock (doesn't work over NFS) */
112: if(flock(fd,LOCK_EX|LOCK_NB)!=0 && errno != EOPNOTSUPP)
113: return(-1);
114: #endif
115:
116: return(0);
117: }
118:
119: /* Removes a lock from a file record */
120: int DLLCALL unlock(int fd, long pos, long len)
121: {
122:
123: #if defined(F_SANEUNLCK) || !defined(BSD)
124: struct flock alock;
125: #ifdef F_SANEUNLCK
126: alock.l_type = F_SANEUNLCK; /* remove the lock */
127: #else
128: alock.l_type = F_UNLCK; /* remove the lock */
129: #endif
130: alock.l_whence = L_SET;
131: alock.l_start = pos;
132: alock.l_len = (int)len;
133: if(fcntl(fd, F_SETLK, &alock)==-1 && errno != EINVAL)
134: return(-1);
135: #endif
136:
137: #if !defined(F_SANEUNLCK) && !defined(__QNX__) && !defined(__solaris__)
138: /* use flock (doesn't work over NFS) */
139: if(flock(fd,LOCK_UN|LOCK_NB)!=0 && errno != EOPNOTSUPP)
140: return(-1);
141: #endif
142:
143: return(0);
144: }
145:
146: /* Opens a file in specified sharing (file-locking) mode */
147: /*
148: * This is how it *SHOULD* work:
149: * Values of DOS 2-6.22 file sharing behavior:
150: * | Second and subsequent Opens
151: * First |Compat Deny Deny Deny Deny
152: * Open | All Write Read None
153: * |R W RW R W RW R W RW R W RW R W RW
154: * - - - - -| - - - - - - - - - - - - - - - - -
155: * Compat R |Y Y Y N N N 1 N N N N N 1 N N
156: * W |Y Y Y N N N N N N N N N N N N
157: * RW|Y Y Y N N N N N N N N N N N N
158: * - - - - -|
159: * Deny R |C C C N N N N N N N N N N N N
160: * All W |C C C N N N N N N N N N N N N
161: * RW|C C C N N N N N N N N N N N N
162: * - - - - -|
163: * Deny R |2 C C N N N Y N N N N N Y N N
164: * Write W |C C C N N N N N N Y N N Y N N
165: * RW|C C C N N N N N N N N N Y N N
166: * - - - - -|
167: * Deny R |C C C N N N N Y N N N N N Y N
168: * Read W |C C C N N N N N N N Y N N Y N
169: * RW|C C C N N N N N N N N N N Y N
170: * - - - - -|
171: * Deny R |2 C C N N N Y Y Y N N N Y Y Y
172: * None W |C C C N N N N N N Y Y Y Y Y Y
173: * RW|C C C N N N N N N N N N Y Y Y
174: *
175: * Legend:
176: * Y = open succeeds,
177: * N = open fails with error code 05h.
178: * C = open fails, INT 24 generated.
179: * 1 = open succeeds if file read-only, else fails with error code.
180: * 2 = open succeeds if file read-only, else fails with INT 24
181: */
182: #if !defined(__QNX__)
183: int DLLCALL sopen(const char *fn, int sh_access, int share, ...)
184: {
185: int fd;
186: int pmode=S_IREAD;
187: #ifndef F_SANEWRLCKNO
188: int flock_op=LOCK_NB; /* non-blocking */
189: #endif
190: #if defined(F_SANEWRLCKNO) || !defined(BSD)
191: struct flock alock;
192: #endif
193: va_list ap;
194:
195: if(sh_access&O_CREAT) {
196: va_start(ap,share);
197: pmode = va_arg(ap,unsigned int);
198: va_end(ap);
199: }
200:
201: if ((fd = open(fn, sh_access, pmode)) < 0)
202: return -1;
203:
204: if (share == SH_DENYNO || share == SH_COMPAT) /* no lock needed */
205: return fd;
206: #if defined(F_SANEWRLCKNO) || !defined(BSD)
207: /* use fcntl (doesn't work correctly with threads) */
208: alock.l_type = share;
209: alock.l_whence = L_SET;
210: alock.l_start = 0;
211: alock.l_len = 0; /* lock to EOF */
212:
213: if(fcntl(fd, F_SETLK, &alock)==-1 && errno != EINVAL) { /* EINVAL means the file does not support locking */
214: close(fd);
215: return -1;
216: }
217: #endif
218:
219: #if !defined(F_SANEWRLCKNO) && !defined(__QNX__) && !defined(__solaris__)
220: /* use flock (doesn't work over NFS) */
221: if(share==SH_DENYRW)
222: flock_op|=LOCK_EX;
223: else /* SH_DENYWR */
224: flock_op|=LOCK_SH;
225: if(flock(fd,flock_op)!=0 && errno != EOPNOTSUPP) { /* That object doesn't do locks */
226: if(errno==EWOULDBLOCK)
227: errno=EAGAIN;
228: close(fd);
229: return(-1);
230: }
231: #endif
232:
233: return fd;
234: }
235: #endif /* !QNX */
236:
237: #elif defined(_MSC_VER) || defined(__MINGW32__) || defined(__DMC__)
238:
239: #include <io.h> /* tell */
240: #include <stdio.h> /* SEEK_SET */
241: #include <sys/locking.h> /* _locking */
242:
243: /* Fix MinGW locking.h typo */
244: #if defined LK_UNLOCK && !defined LK_UNLCK
245: #define LK_UNLCK LK_UNLOCK
246: #endif
247:
248: int DLLCALL lock(int file, long offset, long size)
249: {
250: int i;
251: long pos;
252:
253: pos=tell(file);
254: if(offset!=pos)
255: lseek(file, offset, SEEK_SET);
256: i=_locking(file,LK_NBLCK,size);
257: if(offset!=pos)
258: lseek(file, pos, SEEK_SET);
259: return(i);
260: }
261:
262: int DLLCALL unlock(int file, long offset, long size)
263: {
264: int i;
265: long pos;
266:
267: pos=tell(file);
268: if(offset!=pos)
269: lseek(file, offset, SEEK_SET);
270: i=_locking(file,LK_UNLCK,size);
271: if(offset!=pos)
272: lseek(file, pos, SEEK_SET);
273: return(i);
274: }
275:
276: #endif /* !Unix && (MSVC || MinGW) */
277:
278: #ifdef __unix__
279: FILE *_fsopen(char *pszFilename, char *pszMode, int shmode)
280: {
281: int file;
282: int Mode=0;
283: char *p;
284:
285: for(p=pszMode;*p;p++) {
286: switch (*p) {
287: case 'r':
288: Mode |= 1;
289: break;
290: case 'w':
291: Mode |= 2;
292: break;
293: case 'a':
294: Mode |= 4;
295: break;
296: case '+':
297: Mode |= 8;
298: break;
299: case 'b':
300: case 't':
301: break;
302: default:
303: errno=EINVAL;
304: return(NULL);
305: }
306: }
307: switch(Mode) {
308: case 1:
309: Mode=O_RDONLY;
310: break;
311: case 2:
312: Mode=O_WRONLY|O_CREAT|O_TRUNC;
313: break;
314: case 4:
315: Mode=O_APPEND|O_WRONLY|O_CREAT;
316: break;
317: case 9:
318: Mode=O_RDWR|O_CREAT;
319: break;
320: case 10:
321: Mode=O_RDWR|O_CREAT|O_TRUNC;
322: break;
323: case 12:
324: Mode=O_RDWR|O_APPEND|O_CREAT;
325: break;
326: default:
327: errno=EINVAL;
328: return(NULL);
329: }
330: if(Mode&O_CREAT)
331: file=sopen(pszFilename,Mode,shmode,S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
332: else
333: file=sopen(pszFilename,Mode,shmode);
334: if(file==-1)
335: return(NULL);
336: return(fdopen(file,pszMode));
337: }
338: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.