6ff3ab5d1254d07aaaadb0499649e7d363656402
[samba.git] / source3 / locking / locking.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Locking functions
5    Copyright (C) Andrew Tridgell 1992-1995
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23 #include "loadparm.h"
24 extern int DEBUGLEVEL;
25 extern connection_struct Connections[];
26 extern files_struct Files[];
27
28 pstring share_del_pending="";
29
30
31 /****************************************************************************
32   utility function called to see if a file region is locked
33 ****************************************************************************/
34 BOOL is_locked(int fnum,int cnum,uint32 count,uint32 offset)
35 {
36   int snum = SNUM(cnum);
37
38   if (count == 0)
39     return(False);
40
41   if (!lp_locking(snum) || !lp_strict_locking(snum))
42     return(False);
43
44   return(fcntl_lock(Files[fnum].fd,F_GETLK,offset,count,
45                     (Files[fnum].can_write?F_WRLCK:F_RDLCK)));
46 }
47
48
49 /****************************************************************************
50   utility function called by locking requests
51 ****************************************************************************/
52 BOOL do_lock(int fnum,int cnum,uint32 count,uint32 offset,int *eclass,uint32 *ecode)
53 {
54   BOOL ok = False;
55
56   if (!lp_locking(SNUM(cnum)))
57     return(True);
58
59   if (count == 0) {
60     *eclass = ERRDOS;
61     *ecode = ERRnoaccess;
62     return False;
63   }
64
65   if (Files[fnum].can_lock && OPEN_FNUM(fnum) && (Files[fnum].cnum == cnum))
66     ok = fcntl_lock(Files[fnum].fd,F_SETLK,offset,count,
67                     (Files[fnum].can_write?F_WRLCK:F_RDLCK));
68
69   if (!ok) {
70     *eclass = ERRDOS;
71     *ecode = ERRlock;
72     return False;
73   }
74   return True; /* Got lock */
75 }
76
77
78 /****************************************************************************
79   utility function called by unlocking requests
80 ****************************************************************************/
81 BOOL do_unlock(int fnum,int cnum,uint32 count,uint32 offset,int *eclass,uint32 *ecode)
82 {
83   BOOL ok = False;
84
85   if (!lp_locking(SNUM(cnum)))
86     return(True);
87
88   if (Files[fnum].can_lock && OPEN_FNUM(fnum) && (Files[fnum].cnum == cnum))
89     ok = fcntl_lock(Files[fnum].fd,F_SETLK,offset,count,F_UNLCK);
90    
91   if (!ok) {
92     *eclass = ERRDOS;
93     *ecode = ERRlock;
94     return False;
95   }
96   return True; /* Did unlock */
97 }
98
99 /*******************************************************************
100   name a share file
101   ******************************************************************/
102 static BOOL share_name(int cnum,struct stat *st,char *name)
103 {
104   strcpy(name,lp_lockdir());
105   standard_sub(cnum,name);
106   trim_string(name,"","/");
107   if (!*name) return(False);
108   name += strlen(name);
109   
110   sprintf(name,"/share.%d.%d",(int)st->st_dev,(int)st->st_ino);
111   return(True);
112 }
113
114 /*******************************************************************
115   use the fnum to get the share file name
116   ******************************************************************/
117 static BOOL share_name_fnum(int fnum,char *name)
118 {
119   struct stat st;
120   if (fstat(Files[fnum].fd,&st) != 0) return(False);
121   return(share_name(Files[fnum].cnum,&st,name));
122 }
123
124
125 /*******************************************************************
126   get the share mode of a file using the fnum
127   ******************************************************************/
128 int get_share_mode_by_fnum(int cnum,int fnum,int *pid)
129 {
130   struct stat sbuf;
131   if (fstat(Files[fnum].fd,&sbuf) == -1) return(0);
132   return(get_share_mode(cnum,&sbuf,pid));
133 }
134
135 /*******************************************************************
136   get the share mode of a file using the files name
137   ******************************************************************/
138 int get_share_mode_byname(int cnum,char *fname,int *pid)
139 {
140   struct stat sbuf;
141   if (stat(fname,&sbuf) == -1) return(0);
142   return(get_share_mode(cnum,&sbuf,pid));
143 }  
144
145
146 /*******************************************************************
147 get the share mode of a file
148 ********************************************************************/
149 int get_share_mode(int cnum,struct stat *sbuf,int *pid)
150 {
151   pstring fname;
152   int fd2;
153   char buf[16];
154   int ret;
155   time_t t;
156
157   *pid = 0;
158
159   if (!share_name(cnum,sbuf,fname)) return(0);
160
161   fd2 = open(fname,O_RDONLY,0);
162   if (fd2 < 0) return(0);
163
164   if (read(fd2,buf,16) != 16) {
165     close(fd2);
166     unlink(fname);
167     return(0);
168   }
169   close(fd2);
170
171   t = IVAL(buf,0);
172   ret = IVAL(buf,4);
173   *pid = IVAL(buf,8);
174   
175   if (IVAL(buf,12) != LOCKING_VERSION) {    
176     if (!unlink(fname)) DEBUG(2,("Deleted old locking file %s",fname));
177     *pid = 0;
178     return(0);
179   }
180
181   if (*pid && !process_exists(*pid)) {
182     ret=0;
183     *pid = 0;
184   }
185
186   if (! *pid) unlink(fname); /* XXXXX race, race */
187
188   if (*pid)
189     DEBUG(5,("Read share file %s mode 0x%X pid=%d\n",fname,ret,*pid));
190
191   return(ret);
192 }
193
194
195 /*******************************************************************
196 del the share mode of a file, if we set it last
197 ********************************************************************/
198 void del_share_mode(int fnum)
199 {
200   pstring fname;
201   int fd2;
202   char buf[16];
203   time_t t=0;
204   int pid=0;
205   BOOL del = False;
206
207   if (!share_name_fnum(fnum,fname)) return;
208
209   fd2 = open(fname,O_RDONLY,0);
210   if (fd2 < 0) return;
211   if (read(fd2,buf,16) != 16)
212     del = True;
213   close(fd2);
214
215   if (!del) {
216     t = IVAL(buf,0);
217     pid = IVAL(buf,8);
218   }
219
220   if (!del)
221     if (IVAL(buf,12) != LOCKING_VERSION || !pid || !process_exists(pid))
222       del = True;
223
224   if (!del && t == Files[fnum].open_time && pid==(int)getpid())
225     del = True;
226
227   if (del) {
228     if (!unlink(fname)) 
229       DEBUG(2,("Deleted share file %s\n",fname));
230     else {
231       DEBUG(3,("Pending delete share file %s\n",fname));
232       if (*share_del_pending) DEBUG(0,("Share del clash!\n"));
233       strcpy(share_del_pending,fname);
234     }
235   }
236 }
237   
238
239 /*******************************************************************
240 set the share mode of a file
241 ********************************************************************/
242 BOOL set_share_mode(int fnum,int mode)
243 {
244   pstring fname;
245   int fd2;
246   char buf[16];
247   int pid = (int)getpid();
248
249   if (!share_name_fnum(fnum,fname)) return(False);
250
251   {
252     int old_umask = umask(0);
253     fd2 = open(fname,O_WRONLY|O_CREAT|O_TRUNC,0644);
254     umask(old_umask);
255   }
256   if (fd2 < 0) {
257     DEBUG(2,("Failed to create share file %s\n",fname));
258     return(False);
259   }
260
261   SIVAL(buf,0,Files[fnum].open_time);
262   SIVAL(buf,4,mode);
263   SIVAL(buf,8,pid);
264   SIVAL(buf,12,LOCKING_VERSION);
265
266   if (write(fd2,buf,16) != 16) {
267     close(fd2);
268     unlink(fname);
269     return(False);
270   }
271
272   write(fd2,Files[fnum].name,strlen(Files[fnum].name)+1);
273
274   close(fd2);
275
276   DEBUG(3,("Created share file %s with mode 0x%X pid=%d\n",fname,mode,pid));
277
278   return(True);
279 }
280   
281
282 /*******************************************************************
283 cleanup any stale share files
284 ********************************************************************/
285 void clean_share_files(void)
286 {
287   char *lockdir = lp_lockdir();
288   void *dir;
289   char *s;
290
291   if (!*lockdir) return;
292
293   dir = opendir(lockdir);
294   if (!dir) return;
295
296   while ((s=readdirname(dir))) {
297     char buf[16];
298     int pid;
299     int fd;
300     pstring lname;
301     int dev,inode;
302
303     if (sscanf(s,"share.%d.%d",&dev,&inode)!=2) continue;
304
305     strcpy(lname,lp_lockdir());
306     trim_string(lname,NULL,"/");
307     strcat(lname,"/");
308     strcat(lname,s);
309
310     fd = open(lname,O_RDONLY,0);
311     if (fd < 0) continue;
312
313     if (read(fd,buf,16) != 16) {
314       close(fd);
315       if (!unlink(lname))
316         printf("Deleted corrupt share file %s\n",s);
317       continue;
318     }
319     close(fd);
320
321     pid = IVAL(buf,8);
322
323     if (IVAL(buf,12) != LOCKING_VERSION || !process_exists(pid)) {
324       if (!unlink(lname))
325         printf("Deleted stale share file %s\n",s);
326     }
327   }
328
329   closedir(dir);
330 }