bc2d46bb95ccf277b92221888c3b1f9ef47aca3c
[samba.git] / source / smbd / oplock.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    oplock processing
5    Copyright (C) Andrew Tridgell 1992-1998
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
24 extern int DEBUGLEVEL;
25
26 /* Oplock ipc UDP socket. */
27 static int oplock_sock = -1;
28 uint16 global_oplock_port = 0;
29 #if defined(HAVE_KERNEL_OPLOCKS)
30 static int oplock_pipe_read = -1;
31 static int oplock_pipe_write = -1;
32 #endif /* HAVE_KERNEL_OPLOCKS */
33
34 /* Current number of oplocks we have outstanding. */
35 int32 global_oplocks_open = 0;
36 BOOL global_oplock_break = False;
37
38 extern int smb_read_error;
39
40 static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval);
41
42 /****************************************************************************
43   open the oplock IPC socket communication
44 ****************************************************************************/
45 BOOL open_oplock_ipc(void)
46 {
47   struct sockaddr_in sock_name;
48   int len = sizeof(sock_name);
49
50   DEBUG(3,("open_oplock_ipc: opening loopback UDP socket.\n"));
51
52   /* Open a lookback UDP socket on a random port. */
53   oplock_sock = open_socket_in(SOCK_DGRAM, 0, 0, htonl(INADDR_LOOPBACK));
54   if (oplock_sock == -1)
55   {
56     DEBUG(0,("open_oplock_ipc: Failed to get local UDP socket for \
57 address %lx. Error was %s\n", (long)htonl(INADDR_LOOPBACK), strerror(errno)));
58     global_oplock_port = 0;
59     return(False);
60   }
61
62   /* Find out the transient UDP port we have been allocated. */
63   if(getsockname(oplock_sock, (struct sockaddr *)&sock_name, &len)<0)
64   {
65     DEBUG(0,("open_oplock_ipc: Failed to get local UDP port. Error was %s\n",
66             strerror(errno)));
67     close(oplock_sock);
68     oplock_sock = -1;
69     global_oplock_port = 0;
70     return False;
71   }
72   global_oplock_port = ntohs(sock_name.sin_port);
73
74   DEBUG(3,("open_oplock ipc: pid = %d, global_oplock_port = %u\n", 
75             (int)getpid(), global_oplock_port));
76
77   return True;
78 }
79
80 /****************************************************************************
81  Read an oplock break message from the either the oplock UDP fd
82  or the kernel oplock pipe fd (if kernel oplocks are supported).
83
84  If timeout is zero then *fds contains the file descriptors that
85  are ready to be read and acted upon. If timeout is non-zero then
86  *fds contains the file descriptors to be selected on for read.
87  The timeout is in milliseconds
88
89 ****************************************************************************/
90
91 BOOL receive_local_message(fd_set *fds, char *buffer, int buffer_len, int timeout)
92 {
93   struct sockaddr_in from;
94   int fromlen = sizeof(from);
95   int32 msg_len = 0;
96
97   smb_read_error = 0;
98
99   if(timeout != 0) {
100     struct timeval to;
101     int selrtn;
102     int maxfd = oplock_sock;
103
104 #if defined(HAVE_KERNEL_OPLOCKS)
105     if(lp_kernel_oplocks())
106       maxfd = MAX(maxfd, oplock_pipe_read);
107 #endif /* HAVE_KERNEL_OPLOCKS */
108
109     to.tv_sec = timeout / 1000;
110     to.tv_usec = (timeout % 1000) * 1000;
111
112     selrtn = sys_select(maxfd+1,fds,&to);
113
114     /* Check if error */
115     if(selrtn == -1) {
116       /* something is wrong. Maybe the socket is dead? */
117       smb_read_error = READ_ERROR;
118       return False;
119     }
120
121     /* Did we timeout ? */
122     if (selrtn == 0) {
123       smb_read_error = READ_TIMEOUT;
124       return False;
125     }
126   }
127
128 #if defined(HAVE_KERNEL_OPLOCKS)
129   if(FD_ISSET(oplock_pipe_read,fds)) {
130     /*
131      * Deal with the kernel <--> smbd
132      * oplock break protocol.
133      */
134
135     oplock_stat_t os;
136     SMB_DEV_T dev;
137     SMB_INO_T inode;
138     char dummy;
139
140     /*
141      * Read one byte of zero to clear the
142      * kernel break notify message.
143      */
144
145     if(read(oplock_pipe_read, &dummy, 1) != 1) {
146       DEBUG(0,("receive_local_message: read of kernel notification failed. \
147 Error was %s.\n", strerror(errno) ));
148       smb_read_error = READ_ERROR;
149       return False;
150     }
151
152     /*
153      * Do a query to get the
154      * device and inode of the file that has the break
155      * request outstanding.
156      */
157
158     if(fcntl(oplock_pipe_read, F_OPLKSTAT, &os) < 0) {
159       DEBUG(0,("receive_local_message: fcntl of kernel notification failed. \
160 Error was %s.\n", strerror(errno) ));
161       smb_read_error = READ_ERROR;
162       return False;
163     }
164
165     dev = (SMB_DEV_T)os.os_dev;
166     inode = (SMB_DEV_T)os.os_ino;
167
168     DEBUG(5,("receive_local_message: kernel oplock break request received for \
169 dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode ));
170
171     /*
172      * Create a kernel oplock break message.
173      */
174
175     /* Setup the message header */
176     SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,KERNEL_OPLOCK_BREAK_MSG_LEN);
177     SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,0);
178
179     buffer += OPBRK_CMD_HEADER_LEN;
180
181     SSVAL(buffer,OPBRK_MESSAGE_CMD_OFFSET,KERNEL_OPLOCK_BREAK_CMD);
182     SIVAL(buffer,KERNEL_OPLOCK_BREAK_DEV_OFFSET,dev);
183
184 #ifdef LARGE_SMB_INO_T
185     SIVAL(buffer,KERNEL_OPLOCK_BREAK_INODE_OFFSET,inode & 0xFFFFFFFF);
186     SIVAL(buffer,KERNEL_OPLOCK_BREAK_INODE_OFFSET+4, (inode >> 32 ) & 0xFFFFFFFF );
187 #else /* LARGE_SMB_INO_T */
188     SIVAL(buffer,KERNEL_OPLOCK_BREAK_INODE_OFFSET,inode);
189 #endif /* LARGE_SMB_INO_T */
190
191     return True;
192   }
193 #endif /* HAVE_KERNEL_OPLOCKS */
194
195   /*
196    * From here down we deal with the smbd <--> smbd
197    * oplock break protocol only.
198    */
199
200   /*
201    * Read a loopback udp message.
202    */
203   msg_len = recvfrom(oplock_sock, &buffer[OPBRK_CMD_HEADER_LEN],
204                      buffer_len - OPBRK_CMD_HEADER_LEN, 0,
205                      (struct sockaddr *)&from, &fromlen);
206
207   if(msg_len < 0) {
208     DEBUG(0,("receive_local_message. Error in recvfrom. (%s).\n",strerror(errno)));
209     return False;
210   }
211
212   /* Validate message length. */
213   if(msg_len > (buffer_len - OPBRK_CMD_HEADER_LEN)) {
214     DEBUG(0,("receive_local_message: invalid msg_len (%d) max can be %d\n",
215               msg_len,
216               buffer_len  - OPBRK_CMD_HEADER_LEN));
217     return False;
218   }
219
220   /* Validate message from address (must be localhost). */
221   if(from.sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {
222     DEBUG(0,("receive_local_message: invalid 'from' address \
223 (was %lx should be 127.0.0.1\n", (long)from.sin_addr.s_addr));
224    return False;
225   }
226
227   /* Setup the message header */
228   SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,msg_len);
229   SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,ntohs(from.sin_port));
230
231   return True;
232 }
233
234 /****************************************************************************
235  Attempt to set an oplock on a file. Always succeeds if kernel oplocks are
236  disabled (just sets flags). Returns True if oplock set.
237 ****************************************************************************/
238
239 BOOL set_file_oplock(files_struct *fsp)
240 {
241 #if defined(HAVE_KERNEL_OPLOCKS)
242   if(lp_kernel_oplocks()) {
243
244     if(fcntl(fsp->fd_ptr->fd, F_OPLKREG, oplock_pipe_write) < 0 ) {
245       if(errno != EAGAIN) {
246         DEBUG(0,("set_file_oplock: Unable to get kernel oplock on file %s, dev = %x, \
247 inode = %.0f. Error was %s\n", 
248               fsp->fsp_name, (unsigned int)fsp->fd_ptr->dev, (double)fsp->fd_ptr->inode,
249                strerror(errno) ));
250       } else {
251         DEBUG(5,("set_file_oplock: Refused oplock on file %s, fd = %d, dev = %x, \
252 inode = %.0f. Another process had the file open.\n",
253               fsp->fsp_name, fsp->fd_ptr->fd, (unsigned int)fsp->fd_ptr->dev, (double)fsp->fd_ptr->inode ));
254       }
255       return False;
256     }
257
258     DEBUG(10,("set_file_oplock: got kernel oplock on file %s, dev = %x, inode = %.0f\n",
259           fsp->fsp_name, (unsigned int)fsp->fd_ptr->dev, (double)fsp->fd_ptr->inode));
260
261   }
262 #endif /* HAVE_KERNEL_OPLOCKS */
263
264   DEBUG(5,("set_file_oplock: granted oplock on file %s, dev = %x, inode = %.0f\n", 
265         fsp->fsp_name, (unsigned int)fsp->fd_ptr->dev, (double)fsp->fd_ptr->inode));
266
267   fsp->granted_oplock = True;
268   fsp->sent_oplock_break = False;
269   global_oplocks_open++;
270
271   return True;
272 }
273
274 /****************************************************************************
275  Attempt to release an oplock on a file. Always succeeds if kernel oplocks are
276  disabled (just clears flags).
277 ****************************************************************************/
278
279 static void release_file_oplock(files_struct *fsp)
280 {
281 #if defined(HAVE_KERNEL_OPLOCKS)
282
283   if(lp_kernel_oplocks())
284   {
285     if( DEBUGLVL( 10 ))
286     {
287       /*
288        * Check and print out the current kernel
289        * oplock state of this file.
290        */
291       int state = fcntl(fsp->fd_ptr->fd, F_OPLKACK, -1);
292       dbgtext("release_file_oplock: file %s, dev = %x, inode = %.0f has kernel \
293 oplock state of %x.\n", fsp->fsp_name, (unsigned int)fsp->fd_ptr->dev,
294                         (double)fsp->fd_ptr->inode, state );
295     }
296
297     /*
298      * Remote the kernel oplock on this file.
299      */
300
301     if(fcntl(fsp->fd_ptr->fd, F_OPLKACK, OP_REVOKE) < 0)
302     {
303       if( DEBUGLVL( 0 ))
304       {
305         dbgtext("release_file_oplock: Error when removing kernel oplock on file " );
306         dbgtext("%s, dev = %x, inode = %.0f. Error was %s\n",
307                  fsp->fsp_name, (unsigned int)fsp->fd_ptr->dev, 
308                  (double)fsp->fd_ptr->inode, strerror(errno) );
309       }
310     }
311   }
312 #endif /* HAVE_KERNEL_OPLOCKS */
313
314   fsp->granted_oplock = False;
315   fsp->sent_oplock_break = False;
316   global_oplocks_open--;
317 }
318
319 /****************************************************************************
320  Setup the listening set of file descriptors for an oplock break
321  message either from the UDP socket or from the kernel. Returns the maximum
322  fd used.
323 ****************************************************************************/
324
325 int setup_oplock_select_set( fd_set *fds)
326 {
327   int maxfd = oplock_sock;
328   FD_SET(oplock_sock,fds);
329
330 #if defined(HAVE_KERNEL_OPLOCKS)
331   if(lp_kernel_oplocks()) {
332     FD_SET(oplock_pipe_read,fds); 
333     maxfd = MAX(maxfd,oplock_pipe_read);
334   }
335 #endif /* HAVE_KERNEL_OPLOCKS */
336
337   return maxfd;
338 }
339
340 /****************************************************************************
341  Process an oplock break message - whether it came from the UDP socket
342  or from the kernel.
343 ****************************************************************************/
344
345 BOOL process_local_message(char *buffer, int buf_size)
346 {
347   int32 msg_len;
348   uint16 from_port;
349   char *msg_start;
350   SMB_DEV_T dev;
351   SMB_INO_T inode;
352   uint32 remotepid;
353   struct timeval tval;
354   struct timeval *ptval = NULL;
355
356   msg_len = IVAL(buffer,OPBRK_CMD_LEN_OFFSET);
357   from_port = SVAL(buffer,OPBRK_CMD_PORT_OFFSET);
358
359   msg_start = &buffer[OPBRK_CMD_HEADER_LEN];
360
361   DEBUG(5,("process_local_message: Got a message of length %d from port (%d)\n", 
362             msg_len, from_port));
363
364   /* 
365    * Pull the info out of the requesting packet.
366    */
367
368   switch(SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET))
369   {
370 #if defined(HAVE_KERNEL_OPLOCKS)
371     case KERNEL_OPLOCK_BREAK_CMD:
372       /* Ensure that the msg length is correct. */
373       if(msg_len != KERNEL_OPLOCK_BREAK_MSG_LEN)
374       {
375         DEBUG(0,("process_local_message: incorrect length for KERNEL_OPLOCK_BREAK_CMD (was %d, \
376 should be %d).\n", msg_len, KERNEL_OPLOCK_BREAK_MSG_LEN));
377         return False;
378       }
379       {
380         /*
381          * Warning - beware of SMB_INO_T <> 4 bytes. !!
382          */
383 #ifdef LARGE_SMB_INO_T
384         SMB_INO_T inode_low = IVAL(msg_start, KERNEL_OPLOCK_BREAK_INODE_OFFSET);
385         SMB_INO_T inode_high = IVAL(msg_start, KERNEL_OPLOCK_BREAK_INODE_OFFSET + 4);
386         inode = inode_low | (inode_high << 32);
387 #else /* LARGE_SMB_INO_T */
388         inode = IVAL(msg_start, KERNEL_OPLOCK_BREAK_INODE_OFFSET);
389 #endif /* LARGE_SMB_INO_T */
390
391         dev = IVAL(msg_start,KERNEL_OPLOCK_BREAK_DEV_OFFSET);
392
393         ptval = NULL;
394
395         DEBUG(5,("process_local_message: kernel oplock break request for \
396 file dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode));
397       }
398       break;
399 #endif /* HAVE_KERNEL_OPLOCKS */
400
401     case OPLOCK_BREAK_CMD:
402       /* Ensure that the msg length is correct. */
403       if(msg_len != OPLOCK_BREAK_MSG_LEN)
404       {
405         DEBUG(0,("process_local_message: incorrect length for OPLOCK_BREAK_CMD (was %d, \
406 should be %d).\n", msg_len, OPLOCK_BREAK_MSG_LEN));
407         return False;
408       }
409       {
410         /*
411          * Warning - beware of SMB_INO_T <> 4 bytes. !!
412          */
413 #ifdef LARGE_SMB_INO_T
414         SMB_INO_T inode_low = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET);
415         SMB_INO_T inode_high = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET + 4);
416         inode = inode_low | (inode_high << 32);
417 #else /* LARGE_SMB_INO_T */
418         inode = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET);
419 #endif /* LARGE_SMB_INO_T */
420
421         dev = IVAL(msg_start,OPLOCK_BREAK_DEV_OFFSET);
422
423         tval.tv_sec = (time_t)IVAL(msg_start, OPLOCK_BREAK_SEC_OFFSET);
424         tval.tv_usec = (long)IVAL(msg_start, OPLOCK_BREAK_USEC_OFFSET);
425
426         ptval = &tval;
427
428         remotepid = IVAL(msg_start,OPLOCK_BREAK_PID_OFFSET);
429
430         DEBUG(5,("process_local_message: oplock break request from \
431 pid %d, port %d, dev = %x, inode = %.0f\n", remotepid, from_port, (unsigned int)dev, (double)inode));
432       }
433       break;
434
435     /* 
436      * Keep this as a debug case - eventually we can remove it.
437      */
438     case 0x8001:
439       DEBUG(0,("process_local_message: Received unsolicited break \
440 reply - dumping info.\n"));
441
442       if(msg_len != OPLOCK_BREAK_MSG_LEN)
443       {
444         DEBUG(0,("process_local_message: ubr: incorrect length for reply \
445 (was %d, should be %d).\n", msg_len, OPLOCK_BREAK_MSG_LEN));
446         return False;
447       }
448
449       {
450         /*
451          * Warning - beware of SMB_INO_T <> 4 bytes. !!
452          */
453 #ifdef LARGE_SMB_INO_T
454         SMB_INO_T inode_low = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET);
455         SMB_INO_T inode_high = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET + 4);
456         inode = inode_low | (inode_high << 32);
457 #else /* LARGE_SMB_INO_T */
458         inode = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET);
459 #endif /* LARGE_SMB_INO_T */
460
461         remotepid = IVAL(msg_start,OPLOCK_BREAK_PID_OFFSET);
462         dev = IVAL(msg_start,OPLOCK_BREAK_DEV_OFFSET);
463
464         DEBUG(0,("process_local_message: unsolicited oplock break reply from \
465 pid %d, port %d, dev = %x, inode = %.0f\n", remotepid, from_port, (unsigned int)dev, (double)inode));
466
467        }
468        return False;
469
470     default:
471       DEBUG(0,("process_local_message: unknown UDP message command code (%x) - ignoring.\n",
472                 (unsigned int)SVAL(msg_start,0)));
473       return False;
474   }
475
476   /*
477    * Now actually process the break request.
478    */
479
480   if(global_oplocks_open != 0)
481   {
482     if(oplock_break(dev, inode, ptval) == False)
483     {
484       DEBUG(0,("process_local_message: oplock break failed.\n"));
485       return False;
486     }
487   }
488   else
489   {
490     /*
491      * If we have no record of any currently open oplocks,
492      * it's not an error, as a close command may have
493      * just been issued on the file that was oplocked.
494      * Just log a message and return success in this case.
495      */
496     DEBUG(3,("process_local_message: oplock break requested with no outstanding \
497 oplocks. Returning success.\n"));
498   }
499
500   /* 
501    * Do the appropriate reply - none in the kernel case.
502    */
503
504   if(SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET) == OPLOCK_BREAK_CMD)
505   {
506     struct sockaddr_in toaddr;
507
508     /* Send the message back after OR'ing in the 'REPLY' bit. */
509     SSVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD | CMD_REPLY);
510
511     bzero((char *)&toaddr,sizeof(toaddr));
512     toaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
513     toaddr.sin_port = htons(from_port);
514     toaddr.sin_family = AF_INET;
515
516     if(sendto( oplock_sock, msg_start, OPLOCK_BREAK_MSG_LEN, 0,
517             (struct sockaddr *)&toaddr, sizeof(toaddr)) < 0) 
518     {
519       DEBUG(0,("process_local_message: sendto process %d failed. Errno was %s\n",
520                 remotepid, strerror(errno)));
521       return False;
522     }
523
524     DEBUG(5,("process_local_message: oplock break reply sent to \
525 pid %d, port %d, for file dev = %x, inode = %.0f\n",
526           remotepid, from_port, (unsigned int)dev, (double)inode));
527   }
528
529   return True;
530 }
531
532 /****************************************************************************
533  Process an oplock break directly.
534 ****************************************************************************/
535
536 static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
537 {
538   extern struct current_user current_user;
539   extern int Client;
540   char *inbuf = NULL;
541   char *outbuf = NULL;
542   files_struct *fsp = NULL;
543   time_t start_time;
544   BOOL shutdown_server = False;
545   connection_struct *saved_conn;
546   int saved_vuid;
547   pstring saved_dir; 
548   int break_counter = OPLOCK_BREAK_RESENDS;
549
550   if( DEBUGLVL( 3 ) )
551   {
552     dbgtext( "oplock_break: called for dev = %x, inode = %.0f.\n", (unsigned int)dev, (double)inode );
553     dbgtext( "Current global_oplocks_open = %d\n", global_oplocks_open );
554   }
555
556   /* We need to search the file open table for the
557      entry containing this dev and inode, and ensure
558      we have an oplock on it. */
559   fsp = file_find_dit(dev, inode, tval);
560
561   if(fsp == NULL)
562   {
563     /* The file could have been closed in the meantime - return success. */
564     if( DEBUGLVL( 0 ) )
565     {
566       dbgtext( "oplock_break: cannot find open file with " );
567       dbgtext( "dev = %x, inode = %.0f ", (unsigned int)dev, (double)inode);
568       dbgtext( "allowing break to succeed.\n" );
569     }
570     return True;
571   }
572
573   /* Ensure we have an oplock on the file */
574
575   /* There is a potential race condition in that an oplock could
576      have been broken due to another udp request, and yet there are
577      still oplock break messages being sent in the udp message
578      queue for this file. So return true if we don't have an oplock,
579      as we may have just freed it.
580    */
581
582   if(!fsp->granted_oplock)
583   {
584     if( DEBUGLVL( 0 ) )
585     {
586       dbgtext( "oplock_break: file %s ", fsp->fsp_name );
587       dbgtext( "(dev = %x, inode = %.0f) has no oplock.\n", (unsigned int)dev, (double)inode );
588       dbgtext( "Allowing break to succeed regardless.\n" );
589     }
590     return True;
591   }
592
593   /* mark the oplock break as sent - we don't want to send twice! */
594   if (fsp->sent_oplock_break)
595   {
596     if( DEBUGLVL( 0 ) )
597     {
598       dbgtext( "oplock_break: ERROR: oplock_break already sent for " );
599       dbgtext( "file %s ", fsp->fsp_name);
600       dbgtext( "(dev = %x, inode = %.0f)\n", (unsigned int)dev, (double)inode );
601     }
602
603     /* We have to fail the open here as we cannot send another oplock break on
604        this file whilst we are awaiting a response from the client - neither
605        can we allow another open to succeed while we are waiting for the
606        client.
607      */
608     return False;
609   }
610
611   /* Now comes the horrid part. We must send an oplock break to the client,
612      and then process incoming messages until we get a close or oplock release.
613      At this point we know we need a new inbuf/outbuf buffer pair.
614      We cannot use these staticaly as we may recurse into here due to
615      messages crossing on the wire.
616    */
617
618   if((inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN))==NULL)
619   {
620     DEBUG(0,("oplock_break: malloc fail for input buffer.\n"));
621     return False;
622   }
623
624   if((outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN))==NULL)
625   {
626     DEBUG(0,("oplock_break: malloc fail for output buffer.\n"));
627     free(inbuf);
628     inbuf = NULL;
629     return False;
630   }
631
632   /* Prepare the SMBlockingX message. */
633   bzero(outbuf,smb_size);
634   set_message(outbuf,8,0,True);
635
636   SCVAL(outbuf,smb_com,SMBlockingX);
637   SSVAL(outbuf,smb_tid,fsp->conn->cnum);
638   SSVAL(outbuf,smb_pid,0xFFFF);
639   SSVAL(outbuf,smb_uid,0);
640   SSVAL(outbuf,smb_mid,0xFFFF);
641   SCVAL(outbuf,smb_vwv0,0xFF);
642   SSVAL(outbuf,smb_vwv2,fsp->fnum);
643   SCVAL(outbuf,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE);
644   /* Change this when we have level II oplocks. */
645   SCVAL(outbuf,smb_vwv3+1,OPLOCKLEVEL_NONE);
646  
647   send_smb(Client, outbuf);
648
649   /* Remember we just sent an oplock break on this file. */
650   fsp->sent_oplock_break = True;
651
652   /* We need this in case a readraw crosses on the wire. */
653   global_oplock_break = True;
654  
655   /* Process incoming messages. */
656
657   /* JRA - If we don't get a break from the client in OPLOCK_BREAK_TIMEOUT
658      seconds we should just die.... */
659
660   start_time = time(NULL);
661
662   /*
663    * Save the information we need to re-become the
664    * user, then unbecome the user whilst we're doing this.
665    */
666   saved_conn = fsp->conn;
667   saved_vuid = current_user.vuid;
668   dos_GetWd(saved_dir);
669   unbecome_user();
670   /* Save the chain fnum. */
671   file_chain_save();
672
673   while(OPEN_FSP(fsp) && fsp->granted_oplock)
674   {
675     if(receive_smb(Client,inbuf,
676                    (OPLOCK_BREAK_TIMEOUT/OPLOCK_BREAK_RESENDS) * 1000) == False)
677     {
678
679             /* Isaac suggestd that if a MS client doesn't respond to a
680                oplock break request then we might try resending
681                it. Certainly it's no worse than just dropping the
682                socket! */
683             if (smb_read_error == READ_TIMEOUT && break_counter--) {
684                     DEBUG(2, ( "oplock_break resend\n" ) );
685                     send_smb(Client, outbuf);
686                     continue;
687             }
688
689       /*
690        * Die if we got an error.
691        */
692
693       if (smb_read_error == READ_EOF)
694         DEBUG( 0, ( "oplock_break: end of file from client\n" ) );
695  
696       if (smb_read_error == READ_ERROR)
697         DEBUG( 0, ("oplock_break: receive_smb error (%s)\n", strerror(errno)) );
698
699       if (smb_read_error == READ_TIMEOUT)
700         DEBUG( 0, ( "oplock_break: receive_smb timed out after %d seconds.\n",
701                      OPLOCK_BREAK_TIMEOUT ) );
702
703       DEBUGADD( 0, ( "oplock_break failed for file %s ", fsp->fsp_name ) );
704       DEBUGADD( 0, ( "(dev = %x, inode = %.0f).\n", (unsigned int)dev, (double)inode));
705
706       shutdown_server = True;
707       break;
708     }
709
710     /*
711      * There are certain SMB requests that we shouldn't allow
712      * to recurse. opens, renames and deletes are the obvious
713      * ones. This is handled in the switch_message() function.
714      * If global_oplock_break is set they will push the packet onto
715      * the pending smb queue and return -1 (no reply).
716      * JRA.
717      */
718
719     process_smb(inbuf, outbuf);
720
721     /*
722      * Die if we go over the time limit.
723      */
724
725     if((time(NULL) - start_time) > OPLOCK_BREAK_TIMEOUT)
726     {
727       if( DEBUGLVL( 0 ) )
728         {
729         dbgtext( "oplock_break: no break received from client " );
730         dbgtext( "within %d seconds.\n", OPLOCK_BREAK_TIMEOUT );
731         dbgtext( "oplock_break failed for file %s ", fsp->fsp_name );
732         dbgtext( "(dev = %x, inode = %.0f).\n", (unsigned int)dev, (double)inode );
733         }
734       shutdown_server = True;
735       break;
736     }
737   }
738
739   /*
740    * Go back to being the user who requested the oplock
741    * break.
742    */
743   if(!become_user(saved_conn, saved_vuid))
744   {
745     DEBUG( 0, ( "oplock_break: unable to re-become user!" ) );
746     DEBUGADD( 0, ( "Shutting down server\n" ) );
747     close_sockets();
748     close(oplock_sock);
749     exit_server("unable to re-become user");
750   }
751   /* Including the directory. */
752   dos_ChDir(saved_dir);
753
754   /* Restore the chain fnum. */
755   file_chain_restore();
756
757   /* Free the buffers we've been using to recurse. */
758   free(inbuf);
759   free(outbuf);
760
761   /* We need this in case a readraw crossed on the wire. */
762   if(global_oplock_break)
763     global_oplock_break = False;
764
765   /*
766    * If the client did not respond we must die.
767    */
768
769   if(shutdown_server)
770   {
771     DEBUG( 0, ( "oplock_break: client failure in break - " ) );
772     DEBUGADD( 0, ( "shutting down this smbd.\n" ) );
773     close_sockets();
774     close(oplock_sock);
775     exit_server("oplock break failure");
776   }
777
778   if(OPEN_FSP(fsp))
779   {
780     /* The lockingX reply will have removed the oplock flag 
781        from the sharemode. */
782     release_file_oplock(fsp);
783   }
784
785   /* Santity check - remove this later. JRA */
786   if(global_oplocks_open < 0)
787   {
788     DEBUG(0,("oplock_break: global_oplocks_open < 0 (%d). PANIC ERROR\n",
789               global_oplocks_open));
790     exit_server("oplock_break: global_oplocks_open < 0");
791   }
792
793
794   if( DEBUGLVL( 3 ) )
795   {
796     dbgtext( "oplock_break: returning success for " );
797     dbgtext( "dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
798     dbgtext( "Current global_oplocks_open = %d\n", global_oplocks_open );
799   }
800
801   return True;
802 }
803
804 /****************************************************************************
805 Send an oplock break message to another smbd process. If the oplock is held 
806 by the local smbd then call the oplock break function directly.
807 ****************************************************************************/
808
809 BOOL request_oplock_break(share_mode_entry *share_entry, 
810                           SMB_DEV_T dev, SMB_INO_T inode)
811 {
812   char op_break_msg[OPLOCK_BREAK_MSG_LEN];
813   struct sockaddr_in addr_out;
814   int pid = getpid();
815   time_t start_time;
816   int time_left;
817
818   if(pid == share_entry->pid)
819   {
820     /* We are breaking our own oplock, make sure it's us. */
821     if(share_entry->op_port != global_oplock_port)
822     {
823       DEBUG(0,("request_oplock_break: corrupt share mode entry - pid = %d, port = %d \
824 should be %d\n", pid, share_entry->op_port, global_oplock_port));
825       return False;
826     }
827
828     DEBUG(5,("request_oplock_break: breaking our own oplock\n"));
829
830     /* Call oplock break direct. */
831     return oplock_break(dev, inode, &share_entry->time);
832   }
833
834   /* We need to send a OPLOCK_BREAK_CMD message to the
835      port in the share mode entry. */
836
837   SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD);
838   SIVAL(op_break_msg,OPLOCK_BREAK_PID_OFFSET,pid);
839   SIVAL(op_break_msg,OPLOCK_BREAK_SEC_OFFSET,(uint32)share_entry->time.tv_sec);
840   SIVAL(op_break_msg,OPLOCK_BREAK_USEC_OFFSET,(uint32)share_entry->time.tv_usec);
841   SIVAL(op_break_msg,OPLOCK_BREAK_DEV_OFFSET,dev);
842   /*
843    * WARNING - beware of SMB_INO_T <> 4 bytes.
844    */
845 #ifdef LARGE_SMB_INO_T
846   SIVAL(op_break_msg,OPLOCK_BREAK_INODE_OFFSET,(inode & 0xFFFFFFFFL));
847   SIVAL(op_break_msg,OPLOCK_BREAK_INODE_OFFSET+4,((inode >> 32) & 0xFFFFFFFFL));
848 #else /* LARGE_SMB_INO_T */
849   SIVAL(op_break_msg,OPLOCK_BREAK_INODE_OFFSET,inode);
850 #endif /* LARGE_SMB_INO_T */
851
852   /* set the address and port */
853   bzero((char *)&addr_out,sizeof(addr_out));
854   addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
855   addr_out.sin_port = htons( share_entry->op_port );
856   addr_out.sin_family = AF_INET;
857    
858   if( DEBUGLVL( 3 ) )
859   {
860     dbgtext( "request_oplock_break: sending a oplock break message to " );
861     dbgtext( "pid %d on port %d ", share_entry->pid, share_entry->op_port );
862     dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
863   }
864
865   if(sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0,
866          (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0)
867   {
868     if( DEBUGLVL( 0 ) )
869     {
870       dbgtext( "request_oplock_break: failed when sending a oplock " );
871       dbgtext( "break message to pid %d ", share_entry->pid );
872       dbgtext( "on port %d ", share_entry->op_port );
873       dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
874       dbgtext( "Error was %s\n", strerror(errno) );
875     }
876     return False;
877   }
878
879   /*
880    * Now we must await the oplock broken message coming back
881    * from the target smbd process. Timeout if it fails to
882    * return in (OPLOCK_BREAK_TIMEOUT + OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR) seconds.
883    * While we get messages that aren't ours, loop.
884    */
885
886   start_time = time(NULL);
887   time_left = OPLOCK_BREAK_TIMEOUT+OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR;
888
889   while(time_left >= 0)
890   {
891     char op_break_reply[OPBRK_CMD_HEADER_LEN+OPLOCK_BREAK_MSG_LEN];
892     int32 reply_msg_len;
893     uint16 reply_from_port;
894     char *reply_msg_start;
895     fd_set fds;
896
897     FD_ZERO(&fds);
898     FD_SET(oplock_sock,&fds);
899 #if defined(HAVE_KERNEL_OPLOCKS)
900     if(lp_kernel_oplocks())
901       FD_SET(oplock_pipe_read,&fds);
902 #endif /* HAVE_KERNEL_OPLOCKS */
903
904     if(receive_local_message(&fds, op_break_reply, sizeof(op_break_reply),
905                time_left ? time_left * 1000 : 1) == False)
906     {
907       if(smb_read_error == READ_TIMEOUT)
908       {
909         if( DEBUGLVL( 0 ) )
910         {
911           dbgtext( "request_oplock_break: no response received to oplock " );
912           dbgtext( "break request to pid %d ", share_entry->pid );
913           dbgtext( "on port %d ", share_entry->op_port );
914           dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
915         }
916
917         /*
918          * This is a hack to make handling of failing clients more robust.
919          * If a oplock break response message is not received in the timeout
920          * period we may assume that the smbd servicing that client holding
921          * the oplock has died and the client changes were lost anyway, so
922          * we should continue to try and open the file.
923          */
924         break;
925       }
926       else
927         if( DEBUGLVL( 0 ) )
928         {
929           dbgtext( "request_oplock_break: error in response received " );
930           dbgtext( "to oplock break request to pid %d ", share_entry->pid );
931           dbgtext( "on port %d ", share_entry->op_port );
932           dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
933           dbgtext( "Error was (%s).\n", strerror(errno) );
934         }
935       return False;
936     }
937
938     reply_msg_len = IVAL(op_break_reply,OPBRK_CMD_LEN_OFFSET);
939     reply_from_port = SVAL(op_break_reply,OPBRK_CMD_PORT_OFFSET);
940
941     reply_msg_start = &op_break_reply[OPBRK_CMD_HEADER_LEN];
942
943
944 #if defined(HAVE_KERNEL_OPLOCKS)
945     if((reply_msg_len != OPLOCK_BREAK_MSG_LEN) && (reply_msg_len != KERNEL_OPLOCK_BREAK_MSG_LEN))
946 #else
947     if(reply_msg_len != OPLOCK_BREAK_MSG_LEN)
948 #endif
949     {
950       /* Ignore it. */
951       DEBUG( 0, ( "request_oplock_break: invalid message length (%d) received.", reply_msg_len ) );
952       DEBUGADD( 0, ( "  Ignoring.\n" ) );
953       continue;
954     }
955
956     /*
957      * Test to see if this is the reply we are awaiting.
958      */
959
960     if((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & CMD_REPLY) &&
961        ((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & ~CMD_REPLY) == OPLOCK_BREAK_CMD) &&
962        (reply_from_port == share_entry->op_port) && 
963        (memcmp(&reply_msg_start[OPLOCK_BREAK_PID_OFFSET], 
964                &op_break_msg[OPLOCK_BREAK_PID_OFFSET],
965                OPLOCK_BREAK_MSG_LEN - OPLOCK_BREAK_PID_OFFSET) == 0))
966     {
967       /*
968        * This is the reply we've been waiting for.
969        */
970       break;
971     }
972     else
973     {
974       /*
975        * This is another message - a break request.
976        * Note that both kernel oplock break requests
977        * and UDP inter-smbd oplock break requests will
978        * be processed here.
979        *
980        * Process it to prevent potential deadlock.
981        * Note that the code in switch_message() prevents
982        * us from recursing into here as any SMB requests
983        * we might process that would cause another oplock
984        * break request to be made will be queued.
985        * JRA.
986        */
987
988       process_local_message(op_break_reply, sizeof(op_break_reply));
989     }
990
991     time_left -= (time(NULL) - start_time);
992   }
993
994   DEBUG(3,("request_oplock_break: broke oplock.\n"));
995
996   return True;
997 }
998
999 /****************************************************************************
1000   Attempt to break an oplock on a file (if oplocked).
1001   Returns True if the file was closed as a result of
1002   the oplock break, False otherwise.
1003   Used as a last ditch attempt to free a space in the 
1004   file table when we have run out.
1005 ****************************************************************************/
1006 BOOL attempt_close_oplocked_file(files_struct *fsp)
1007 {
1008
1009   DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fsp->fsp_name));
1010
1011   if (fsp->open && fsp->granted_oplock && !fsp->sent_oplock_break && (fsp->fd_ptr != NULL)) {
1012
1013     /* Try and break the oplock. */
1014     file_fd_struct *fd_ptr = fsp->fd_ptr;
1015     if(oplock_break( fd_ptr->dev, fd_ptr->inode, &fsp->open_time)) {
1016       if(!fsp->open) /* Did the oplock break close the file ? */
1017         return True;
1018     }
1019   }
1020
1021   return False;
1022 }
1023
1024 /****************************************************************************
1025  Init function to check if kernel level oplocks are available.
1026 ****************************************************************************/
1027
1028 void check_kernel_oplocks(void)
1029 {
1030   static BOOL done;
1031
1032   /*
1033    * We only do this check once on startup.
1034    */
1035
1036   if(done)
1037     return;
1038
1039   done = True;
1040   lp_set_kernel_oplocks(False);
1041
1042 #if defined(HAVE_KERNEL_OPLOCKS)
1043   {
1044     int fd;
1045     int pfd[2];
1046     pstring tmpname;
1047
1048     set_process_capability(KERNEL_OPLOCK_CAPABILITY,True);
1049     set_inherited_process_capability(KERNEL_OPLOCK_CAPABILITY,True);
1050
1051         slprintf(tmpname,sizeof(tmpname)-1, "%s/koplock.%d", lp_lockdir(), (int)getpid());
1052
1053     if(pipe(pfd) != 0) {
1054       DEBUG(0,("check_kernel_oplocks: Unable to create pipe. Error was %s\n",
1055             strerror(errno) ));
1056       return;
1057     }
1058
1059     if((fd = sys_open(tmpname, O_RDWR|O_CREAT|O_TRUNC|O_EXCL, 0600)) < 0) {
1060       DEBUG(0,("check_kernel_oplocks: Unable to open temp test file %s. Error was %s\n",
1061             tmpname, strerror(errno) ));
1062       unlink( tmpname );
1063       close(pfd[0]);
1064       close(pfd[1]);
1065       return;
1066     }
1067
1068     unlink( tmpname );
1069
1070     if(fcntl(fd, F_OPLKREG, pfd[1]) == -1) {
1071       DEBUG(0,("check_kernel_oplocks: Kernel oplocks are not available on this machine. \
1072 Disabling kernel oplock support.\n" ));
1073       close(pfd[0]);
1074       close(pfd[1]);
1075       close(fd);
1076       return;
1077     }
1078
1079     if(fcntl(fd, F_OPLKACK, OP_REVOKE) < 0 ) {
1080       DEBUG(0,("check_kernel_oplocks: Error when removing kernel oplock. Error was %s. \
1081 Disabling kernel oplock support.\n", strerror(errno) ));
1082       close(pfd[0]);
1083       close(pfd[1]);
1084       close(fd);
1085       return;
1086     }
1087
1088     oplock_pipe_read = pfd[0];
1089     oplock_pipe_write = pfd[1];
1090     close(fd);
1091
1092     lp_set_kernel_oplocks(True);
1093
1094     DEBUG(3,("check_kernel_oplocks: Kernel oplocks available and set to %s.\n",
1095           lp_kernel_oplocks() ? "True" : "False" ));
1096
1097   }
1098 #endif /* HAVE_KERNEL_OPLOCKS */
1099 }