import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / smbd / oplock.c
1 /* 
2    Unix SMB/CIFS implementation.
3    oplock processing
4    Copyright (C) Andrew Tridgell 1992-1998
5    Copyright (C) Jeremy Allison 1998 - 2001
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 /* Oplock ipc UDP socket. */
25 static int oplock_sock = -1;
26 uint16 global_oplock_port = 0;
27
28 /* Current number of oplocks we have outstanding. */
29 static int32 exclusive_oplocks_open = 0;
30 static int32 level_II_oplocks_open = 0;
31 BOOL global_client_failed_oplock_break = False;
32 BOOL global_oplock_break = False;
33
34 extern int smb_read_error;
35
36 static struct kernel_oplocks *koplocks;
37
38 static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id, BOOL local);
39
40 /****************************************************************************
41  Get the number of current exclusive oplocks.
42 ****************************************************************************/
43
44 int32 get_number_of_exclusive_open_oplocks(void)
45 {
46   return exclusive_oplocks_open;
47 }
48
49 /****************************************************************************
50  Return True if an oplock message is pending.
51 ****************************************************************************/
52
53 BOOL oplock_message_waiting(fd_set *fds)
54 {
55         if (koplocks && koplocks->msg_waiting(fds))
56                 return True;
57
58         if (FD_ISSET(oplock_sock, fds))
59                 return True;
60
61         return False;
62 }
63
64 /****************************************************************************
65  Read an oplock break message from either the oplock UDP fd or the
66  kernel (if kernel oplocks are supported).
67
68  If timeout is zero then *fds contains the file descriptors that
69  are ready to be read and acted upon. If timeout is non-zero then
70  *fds contains the file descriptors to be selected on for read.
71  The timeout is in milliseconds
72
73 ****************************************************************************/
74
75 BOOL receive_local_message( char *buffer, int buffer_len, int timeout)
76 {
77         struct sockaddr_in from;
78         socklen_t fromlen = sizeof(from);
79         int32 msg_len = 0;
80         fd_set fds;
81         int selrtn = -1;
82
83         FD_ZERO(&fds);
84         smb_read_error = 0;
85
86         /*
87          * We need to check for kernel oplocks before going into the select
88          * here, as the EINTR generated by the linux kernel oplock may have
89          * already been eaten. JRA.
90          */
91
92         if (koplocks && koplocks->msg_waiting(&fds)) {
93                 return koplocks->receive_message(&fds, buffer, buffer_len);
94         }
95
96         while (timeout > 0 && selrtn == -1) {
97                 struct timeval to;
98                 int maxfd = oplock_sock;
99                 time_t starttime = time(NULL);
100
101                 FD_ZERO(&fds);
102                 maxfd = setup_oplock_select_set(&fds);
103
104                 to.tv_sec = timeout / 1000;
105                 to.tv_usec = (timeout % 1000) * 1000;
106
107                 DEBUG(5,("receive_local_message: doing select with timeout of %d ms\n", timeout));
108
109                 selrtn = sys_select(maxfd+1,&fds,NULL,NULL,&to);
110
111                 if (selrtn == -1 && errno == EINTR) {
112
113                         /* could be a kernel oplock interrupt */
114                         if (koplocks && koplocks->msg_waiting(&fds)) {
115                                 return koplocks->receive_message(&fds, buffer, buffer_len);
116                         }
117
118                         /*
119                          * Linux 2.0.x seems to have a bug in that
120                          * it can return -1, EINTR with a timeout of zero.
121                          * Make sure we bail out here with a read timeout
122                          * if we got EINTR on a timeout of 1 or less.
123                          */
124
125                         if (timeout <= 1) {
126                                 smb_read_error = READ_TIMEOUT;
127                                 return False;
128                         }
129
130                         /* Not a kernel interrupt - could be a SIGUSR1 message. We must restart. */
131                         /* We need to decrement the timeout here. */
132                         timeout -= ((time(NULL) - starttime)*1000);
133                         if (timeout < 0)
134                                 timeout = 1;
135
136                         DEBUG(5,("receive_local_message: EINTR : new timeout %d ms\n", timeout));
137                         continue;
138                 }
139
140                 /* Check if error */
141                 if(selrtn == -1) {
142                         /* something is wrong. Maybe the socket is dead? */
143                         smb_read_error = READ_ERROR;
144                         return False;
145                 }
146
147                 /* Did we timeout ? */
148                 if (selrtn == 0) {
149                         smb_read_error = READ_TIMEOUT;
150                         return False;
151                 }
152         }
153
154         if (koplocks && koplocks->msg_waiting(&fds)) {
155                 return koplocks->receive_message(&fds, buffer, buffer_len);
156         }
157
158         if (!FD_ISSET(oplock_sock, &fds))
159                 return False;
160
161         /*
162          * From here down we deal with the smbd <--> smbd
163          * oplock break protocol only.
164          */
165
166         /*
167          * Read a loopback udp message.
168          */
169         msg_len = sys_recvfrom(oplock_sock, &buffer[OPBRK_CMD_HEADER_LEN],
170                                                 buffer_len - OPBRK_CMD_HEADER_LEN, 0, (struct sockaddr *)&from, &fromlen);
171
172         if(msg_len < 0) {
173                 DEBUG(0,("receive_local_message. Error in recvfrom. (%s).\n",strerror(errno)));
174                 return False;
175         }
176
177         /* Validate message length. */
178         if(msg_len > (buffer_len - OPBRK_CMD_HEADER_LEN)) {
179                 DEBUG(0,("receive_local_message: invalid msg_len (%d) max can be %d\n", msg_len,
180                         buffer_len  - OPBRK_CMD_HEADER_LEN));
181                 return False;
182         }
183
184         /* Validate message from address (must be localhost). */
185         if(from.sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {
186                 DEBUG(0,("receive_local_message: invalid 'from' address \
187 (was %lx should be 127.0.0.1)\n", (long)from.sin_addr.s_addr));
188                 return False;
189         }
190
191         /* Setup the message header */
192         SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,msg_len);
193         SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,ntohs(from.sin_port));
194
195         return True;
196 }
197
198 /****************************************************************************
199  Attempt to set an oplock on a file. Always succeeds if kernel oplocks are
200  disabled (just sets flags). Returns True if oplock set.
201 ****************************************************************************/
202
203 BOOL set_file_oplock(files_struct *fsp, int oplock_type)
204 {
205         if (koplocks && !koplocks->set_oplock(fsp, oplock_type))
206                 return False;
207
208         fsp->oplock_type = oplock_type;
209         fsp->sent_oplock_break = NO_BREAK_SENT;
210         if (oplock_type == LEVEL_II_OPLOCK)
211                 level_II_oplocks_open++;
212         else
213                 exclusive_oplocks_open++;
214
215         DEBUG(5,("set_file_oplock: granted oplock on file %s, dev = %x, inode = %.0f, file_id = %lu, \
216 tv_sec = %x, tv_usec = %x\n",
217                  fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id,
218                  (int)fsp->open_time.tv_sec, (int)fsp->open_time.tv_usec ));
219
220         return True;
221 }
222
223 /****************************************************************************
224  Attempt to release an oplock on a file. Decrements oplock count.
225 ****************************************************************************/
226
227 void release_file_oplock(files_struct *fsp)
228 {
229         if ((fsp->oplock_type != NO_OPLOCK) && koplocks)
230                 koplocks->release_oplock(fsp);
231
232         if (fsp->oplock_type == LEVEL_II_OPLOCK)
233                 level_II_oplocks_open--;
234         else if (fsp->oplock_type)
235                 exclusive_oplocks_open--;
236         
237         fsp->oplock_type = NO_OPLOCK;
238         fsp->sent_oplock_break = NO_BREAK_SENT;
239         
240         flush_write_cache(fsp, OPLOCK_RELEASE_FLUSH);
241 }
242
243 /****************************************************************************
244  Attempt to downgrade an oplock on a file. Doesn't decrement oplock count.
245 ****************************************************************************/
246
247 static void downgrade_file_oplock(files_struct *fsp)
248 {
249         if (koplocks)
250                 koplocks->release_oplock(fsp);
251         fsp->oplock_type = LEVEL_II_OPLOCK;
252         exclusive_oplocks_open--;
253         level_II_oplocks_open++;
254         fsp->sent_oplock_break = NO_BREAK_SENT;
255 }
256
257 /****************************************************************************
258  Remove a file oplock. Copes with level II and exclusive.
259  Locks then unlocks the share mode lock. Client can decide to go directly
260  to none even if a "break-to-level II" was sent.
261 ****************************************************************************/
262
263 BOOL remove_oplock(files_struct *fsp, BOOL break_to_none)
264 {
265         SMB_DEV_T dev = fsp->dev;
266         SMB_INO_T inode = fsp->inode;
267         BOOL ret = True;
268
269         /* Remove the oplock flag from the sharemode. */
270         if (lock_share_entry_fsp(fsp) == False) {
271                 DEBUG(0,("remove_oplock: failed to lock share entry for file %s\n",
272                          fsp->fsp_name ));
273                 return False;
274         }
275
276         if (fsp->sent_oplock_break == EXCLUSIVE_BREAK_SENT || break_to_none) {
277                 /*
278                  * Deal with a reply when a break-to-none was sent.
279                  */
280
281                 if(remove_share_oplock(fsp)==False) {
282                         DEBUG(0,("remove_oplock: failed to remove share oplock for file %s fnum %d, \
283 dev = %x, inode = %.0f\n", fsp->fsp_name, fsp->fnum, (unsigned int)dev, (double)inode));
284                         ret = False;
285                 }
286
287                 release_file_oplock(fsp);
288         } else {
289                 /*
290                  * Deal with a reply when a break-to-level II was sent.
291                  */
292                 if(downgrade_share_oplock(fsp)==False) {
293                         DEBUG(0,("remove_oplock: failed to downgrade share oplock for file %s fnum %d, \
294 dev = %x, inode = %.0f\n", fsp->fsp_name, fsp->fnum, (unsigned int)dev, (double)inode));
295                         ret = False;
296                 }
297                 
298                 downgrade_file_oplock(fsp);
299         }
300
301         unlock_share_entry_fsp(fsp);
302         return ret;
303 }
304
305 /****************************************************************************
306  Setup the listening set of file descriptors for an oplock break
307  message either from the UDP socket or from the kernel. Returns the maximum
308  fd used.
309 ****************************************************************************/
310
311 int setup_oplock_select_set( fd_set *fds)
312 {
313         int maxfd = oplock_sock;
314
315         if(oplock_sock == -1)
316                 return 0;
317
318         FD_SET(oplock_sock,fds);
319
320         if (koplocks && koplocks->notification_fd != -1) {
321                 FD_SET(koplocks->notification_fd, fds);
322                 maxfd = MAX(maxfd, koplocks->notification_fd);
323         }
324
325         return maxfd;
326 }
327
328 /****************************************************************************
329  Process an oplock break message - whether it came from the UDP socket
330  or from the kernel.
331 ****************************************************************************/
332
333 BOOL process_local_message(char *buffer, int buf_size)
334 {
335         int32 msg_len;
336         uint16 from_port;
337         char *msg_start;
338         pid_t remotepid;
339         SMB_DEV_T dev;
340         SMB_INO_T inode;
341         unsigned long file_id;
342         uint16 break_cmd_type;
343
344         msg_len = IVAL(buffer,OPBRK_CMD_LEN_OFFSET);
345         from_port = SVAL(buffer,OPBRK_CMD_PORT_OFFSET);
346
347         msg_start = &buffer[OPBRK_CMD_HEADER_LEN];
348
349         DEBUG(5,("process_local_message: Got a message of length %d from port (%d)\n", 
350                 msg_len, from_port));
351
352         /* 
353          * Pull the info out of the requesting packet.
354          */
355
356         break_cmd_type = SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET);
357
358         switch(break_cmd_type) {
359                 case KERNEL_OPLOCK_BREAK_CMD:
360                         if (!koplocks) {
361                                 DEBUG(0,("unexpected kernel oplock break!\n"));
362                                 break;
363                         } 
364                         if (!koplocks->parse_message(msg_start, msg_len, &inode, &dev, &file_id)) {
365                                 DEBUG(0,("kernel oplock break parse failure!\n"));
366                         }
367                         break;
368
369                 case OPLOCK_BREAK_CMD:
370                 case LEVEL_II_OPLOCK_BREAK_CMD:
371                 case ASYNC_LEVEL_II_OPLOCK_BREAK_CMD:
372
373                         /* Ensure that the msg length is correct. */
374                         if(msg_len != OPLOCK_BREAK_MSG_LEN) {
375                                 DEBUG(0,("process_local_message: incorrect length for OPLOCK_BREAK_CMD (was %d, should be %d).\n",
376                                         (int)msg_len, (int)OPLOCK_BREAK_MSG_LEN));
377                                 return False;
378                         }
379
380                         memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid));
381                         memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode));
382                         memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev));
383                         memcpy((char *)&file_id, msg_start+OPLOCK_BREAK_FILEID_OFFSET,sizeof(file_id));
384
385                         DEBUG(5,("process_local_message: (%s) oplock break request from \
386 pid %d, port %d, dev = %x, inode = %.0f, file_id = %lu\n",
387                                 (break_cmd_type == OPLOCK_BREAK_CMD) ? "exclusive" : "level II",
388                                 (int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id));
389                         break;
390
391                 /* 
392                  * Keep this as a debug case - eventually we can remove it.
393                  */
394                 case 0x8001:
395                         DEBUG(0,("process_local_message: Received unsolicited break \
396 reply - dumping info.\n"));
397
398                         if(msg_len != OPLOCK_BREAK_MSG_LEN) {
399                                 DEBUG(0,("process_local_message: ubr: incorrect length for reply \
400 (was %d, should be %d).\n", (int)msg_len, (int)OPLOCK_BREAK_MSG_LEN));
401                                 return False;
402                         }
403
404                         memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode));
405                         memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid));
406                         memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev));
407                         memcpy((char *)&file_id, msg_start+OPLOCK_BREAK_FILEID_OFFSET,sizeof(file_id));
408
409                         DEBUG(0,("process_local_message: unsolicited oplock break reply from \
410 pid %d, port %d, dev = %x, inode = %.0f, file_id = %lu\n",
411                                 (int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id));
412
413                         return False;
414
415                 default:
416                         DEBUG(0,("process_local_message: unknown UDP message command code (%x) - ignoring.\n",
417                                 (unsigned int)SVAL(msg_start,0)));
418                         return False;
419         }
420
421         /*
422          * Now actually process the break request.
423          */
424
425         if((exclusive_oplocks_open + level_II_oplocks_open) != 0) {
426                 if (oplock_break(dev, inode, file_id, False) == False) {
427                         DEBUG(0,("process_local_message: oplock break failed.\n"));
428                         return False;
429                 }
430         } else {
431                 /*
432                  * If we have no record of any currently open oplocks,
433                  * it's not an error, as a close command may have
434                  * just been issued on the file that was oplocked.
435                  * Just log a message and return success in this case.
436                  */
437                 DEBUG(3,("process_local_message: oplock break requested with no outstanding \
438 oplocks. Returning success.\n"));
439         }
440
441         /* 
442          * Do the appropriate reply - none in the kernel or async level II case.
443          */
444
445         if(break_cmd_type == OPLOCK_BREAK_CMD || break_cmd_type == LEVEL_II_OPLOCK_BREAK_CMD) {
446                 struct sockaddr_in toaddr;
447
448                 /* Send the message back after OR'ing in the 'REPLY' bit. */
449                 SSVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET,break_cmd_type | CMD_REPLY);
450
451                 memset((char *)&toaddr,'\0',sizeof(toaddr));
452                 toaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
453                 toaddr.sin_port = htons(from_port);
454                 toaddr.sin_family = AF_INET;
455
456                 if(sys_sendto( oplock_sock, msg_start, OPLOCK_BREAK_MSG_LEN, 0,
457                                 (struct sockaddr *)&toaddr, sizeof(toaddr)) < 0) {
458                         DEBUG(0,("process_local_message: sendto process %d failed. Errno was %s\n",
459                                 (int)remotepid, strerror(errno)));
460                         return False;
461                 }
462
463                 DEBUG(5,("process_local_message: oplock break reply sent to \
464 pid %d, port %d, for file dev = %x, inode = %.0f, file_id = %lu\n",
465                         (int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id));
466         }
467
468         return True;
469 }
470
471 /****************************************************************************
472  Set up an oplock break message.
473 ****************************************************************************/
474
475 static void prepare_break_message(char *outbuf, files_struct *fsp, BOOL level2)
476 {
477         memset(outbuf,'\0',smb_size);
478         set_message(outbuf,8,0,True);
479
480         SCVAL(outbuf,smb_com,SMBlockingX);
481         SSVAL(outbuf,smb_tid,fsp->conn->cnum);
482         SSVAL(outbuf,smb_pid,0xFFFF);
483         SSVAL(outbuf,smb_uid,0);
484         SSVAL(outbuf,smb_mid,0xFFFF);
485         SCVAL(outbuf,smb_vwv0,0xFF);
486         SSVAL(outbuf,smb_vwv2,fsp->fnum);
487         SCVAL(outbuf,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE);
488         SCVAL(outbuf,smb_vwv3+1,level2 ? OPLOCKLEVEL_II : OPLOCKLEVEL_NONE);
489 }
490
491 /****************************************************************************
492  Function to do the waiting before sending a local break.
493 ****************************************************************************/
494
495 static void wait_before_sending_break(BOOL local_request)
496 {
497         extern struct timeval smb_last_time;
498
499         if(local_request) {
500                 struct timeval cur_tv;
501                 long wait_left = (long)lp_oplock_break_wait_time();
502
503                 if (wait_left == 0)
504                         return;
505
506                 GetTimeOfDay(&cur_tv);
507
508                 wait_left -= ((cur_tv.tv_sec - smb_last_time.tv_sec)*1000) +
509                 ((cur_tv.tv_usec - smb_last_time.tv_usec)/1000);
510
511                 if(wait_left > 0) {
512                         wait_left = MIN(wait_left, 1000);
513                         sys_usleep(wait_left * 1000);
514                 }
515         }
516 }
517
518 /****************************************************************************
519  Ensure that we have a valid oplock.
520 ****************************************************************************/
521
522 static files_struct *initial_break_processing(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id)
523 {
524         files_struct *fsp = NULL;
525
526         if( DEBUGLVL( 3 ) ) {
527                 dbgtext( "initial_break_processing: called for dev = %x, inode = %.0f file_id = %lu\n",
528                         (unsigned int)dev, (double)inode, file_id);
529                 dbgtext( "Current oplocks_open (exclusive = %d, levelII = %d)\n",
530                         exclusive_oplocks_open, level_II_oplocks_open );
531         }
532
533         /*
534          * We need to search the file open table for the
535          * entry containing this dev and inode, and ensure
536          * we have an oplock on it.
537          */
538
539         fsp = file_find_dif(dev, inode, file_id);
540
541         if(fsp == NULL) {
542                 /* The file could have been closed in the meantime - return success. */
543                 if( DEBUGLVL( 3 ) ) {
544                         dbgtext( "initial_break_processing: cannot find open file with " );
545                         dbgtext( "dev = %x, inode = %.0f file_id = %lu", (unsigned int)dev,
546                                 (double)inode, file_id);
547                         dbgtext( "allowing break to succeed.\n" );
548                 }
549                 return NULL;
550         }
551
552         /* Ensure we have an oplock on the file */
553
554         /*
555          * There is a potential race condition in that an oplock could
556          * have been broken due to another udp request, and yet there are
557          * still oplock break messages being sent in the udp message
558          * queue for this file. So return true if we don't have an oplock,
559          * as we may have just freed it.
560          */
561
562         if(fsp->oplock_type == NO_OPLOCK) {
563                 if( DEBUGLVL( 3 ) ) {
564                         dbgtext( "initial_break_processing: file %s ", fsp->fsp_name );
565                         dbgtext( "(dev = %x, inode = %.0f, file_id = %lu) has no oplock.\n",
566                                 (unsigned int)dev, (double)inode, fsp->file_id );
567                         dbgtext( "Allowing break to succeed regardless.\n" );
568                 }
569                 return NULL;
570         }
571
572         return fsp;
573 }
574
575 /****************************************************************************
576  Process a level II oplock break directly.
577 ****************************************************************************/
578
579 BOOL oplock_break_level2(files_struct *fsp, BOOL local_request, int token)
580 {
581         extern uint32 global_client_caps;
582         char outbuf[128];
583         BOOL got_lock = False;
584         SMB_DEV_T dev = fsp->dev;
585         SMB_INO_T inode = fsp->inode;
586
587         /*
588          * We can have a level II oplock even if the client is not
589          * level II oplock aware. In this case just remove the
590          * flags and don't send the break-to-none message to
591          * the client.
592          */
593
594         if (global_client_caps & CAP_LEVEL_II_OPLOCKS) {
595                 /*
596                  * If we are sending an oplock break due to an SMB sent
597                  * by our own client we ensure that we wait at leat
598                  * lp_oplock_break_wait_time() milliseconds before sending
599                  * the packet. Sending the packet sooner can break Win9x
600                  * and has reported to cause problems on NT. JRA.
601                  */
602
603                 wait_before_sending_break(local_request);
604
605                 /* Prepare the SMBlockingX message. */
606
607                 prepare_break_message( outbuf, fsp, False);
608                 if (!send_smb(smbd_server_fd(), outbuf))
609                         exit_server("oplock_break_level2: send_smb failed.");
610         }
611
612         /*
613          * Now we must update the shared memory structure to tell
614          * everyone else we no longer have a level II oplock on 
615          * this open file. If local_request is true then token is
616          * the existing lock on the shared memory area.
617          */
618
619         if(!local_request && lock_share_entry_fsp(fsp) == False) {
620                 DEBUG(0,("oplock_break_level2: unable to lock share entry for file %s\n", fsp->fsp_name ));
621         } else {
622                 got_lock = True;
623         }
624
625         if(remove_share_oplock(fsp)==False) {
626                 DEBUG(0,("oplock_break_level2: unable to remove level II oplock for file %s\n", fsp->fsp_name ));
627         }
628
629         release_file_oplock(fsp);
630
631         if (!local_request && got_lock)
632                 unlock_share_entry_fsp(fsp);
633
634         if(level_II_oplocks_open < 0) {
635                 DEBUG(0,("oplock_break_level2: level_II_oplocks_open < 0 (%d). PANIC ERROR\n",
636                         level_II_oplocks_open));
637                 abort();
638         }
639
640         if( DEBUGLVL( 3 ) ) {
641                 dbgtext( "oplock_break_level2: returning success for " );
642                 dbgtext( "dev = %x, inode = %.0f, file_id = %lu\n", (unsigned int)dev, (double)inode, fsp->file_id );
643                 dbgtext( "Current level II oplocks_open = %d\n", level_II_oplocks_open );
644         }
645
646         return True;
647 }
648
649 /****************************************************************************
650  Process an oplock break directly.
651 ****************************************************************************/
652
653 static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id, BOOL local_request)
654 {
655         extern uint32 global_client_caps;
656         extern struct current_user current_user;
657         char *inbuf = NULL;
658         char *outbuf = NULL;
659         files_struct *fsp = NULL;
660         time_t start_time;
661         BOOL shutdown_server = False;
662         BOOL oplock_timeout = False;
663         BOOL sign_state;
664         connection_struct *saved_user_conn;
665         connection_struct *saved_fsp_conn;
666         int saved_vuid;
667         pstring saved_dir; 
668         int timeout = (OPLOCK_BREAK_TIMEOUT * 1000);
669         pstring file_name;
670         BOOL using_levelII;
671
672         if((fsp = initial_break_processing(dev, inode, file_id)) == NULL)
673                 return True;
674
675         /*
676          * Deal with a level II oplock going break to none separately.
677          */
678
679         if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
680                 return oplock_break_level2(fsp, local_request, -1);
681
682         /* Mark the oplock break as sent - we don't want to send twice! */
683         if (fsp->sent_oplock_break) {
684                 if( DEBUGLVL( 0 ) ) {
685                         dbgtext( "oplock_break: ERROR: oplock_break already sent for " );
686                         dbgtext( "file %s ", fsp->fsp_name);
687                         dbgtext( "(dev = %x, inode = %.0f, file_id = %lu)\n", (unsigned int)dev, (double)inode, fsp->file_id );
688                 }
689
690                 /*
691                  * We have to fail the open here as we cannot send another oplock break on
692                  * this file whilst we are awaiting a response from the client - neither
693                  * can we allow another open to succeed while we are waiting for the client.
694                  */
695                 return False;
696         }
697
698         if(global_oplock_break) {
699                 DEBUG(0,("ABORT : ABORT : recursion in oplock_break !!!!!\n"));
700                 abort();
701         }
702
703         /*
704          * Now comes the horrid part. We must send an oplock break to the client,
705          * and then process incoming messages until we get a close or oplock release.
706          * At this point we know we need a new inbuf/outbuf buffer pair.
707          * We cannot use these staticaly as we may recurse into here due to
708          * messages crossing on the wire.
709          */
710
711         if((inbuf = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL) {
712                 DEBUG(0,("oplock_break: malloc fail for input buffer.\n"));
713                 return False;
714         }
715
716         if((outbuf = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL) {
717                 DEBUG(0,("oplock_break: malloc fail for output buffer.\n"));
718                 SAFE_FREE(inbuf);
719                 return False;
720         }
721
722         /*
723          * If we are sending an oplock break due to an SMB sent
724          * by our own client we ensure that we wait at leat
725          * lp_oplock_break_wait_time() milliseconds before sending
726          * the packet. Sending the packet sooner can break Win9x
727          * and has reported to cause problems on NT. JRA.
728          */
729
730         wait_before_sending_break(local_request);
731
732         /* Prepare the SMBlockingX message. */
733
734         if ((global_client_caps & CAP_LEVEL_II_OPLOCKS) && 
735                         !koplocks && /* NOTE: we force levelII off for kernel oplocks - this will change when it is supported */
736                         lp_level2_oplocks(SNUM(fsp->conn))) {
737                 using_levelII = True;
738         } else {
739                 using_levelII = False;
740         }
741
742         prepare_break_message( outbuf, fsp, using_levelII);
743         /* Remember if we just sent a break to level II on this file. */
744         fsp->sent_oplock_break = using_levelII? LEVEL_II_BREAK_SENT:EXCLUSIVE_BREAK_SENT;
745
746         /* Save the server smb signing state. */
747         sign_state = srv_oplock_set_signing(False);
748
749         if (!send_smb(smbd_server_fd(), outbuf)) {
750                 srv_oplock_set_signing(sign_state);
751                 exit_server("oplock_break: send_smb failed.");
752         }
753
754         /* Restore the sign state to what it was. */
755         srv_oplock_set_signing(sign_state);
756
757         /* We need this in case a readraw crosses on the wire. */
758         global_oplock_break = True;
759  
760         /* Process incoming messages. */
761
762         /*
763          * JRA - If we don't get a break from the client in OPLOCK_BREAK_TIMEOUT
764          * seconds we should just die....
765          */
766
767         start_time = time(NULL);
768
769         /*
770          * Save the information we need to re-become the
771          * user, then unbecome the user whilst we're doing this.
772          */
773         saved_user_conn = current_user.conn;
774         saved_vuid = current_user.vuid;
775         saved_fsp_conn = fsp->conn;
776         change_to_root_user();
777         vfs_GetWd(saved_fsp_conn,saved_dir);
778         /* Save the chain fnum. */
779         file_chain_save();
780
781         /*
782          * From Charles Hoch <hoch@exemplary.com>. If the break processing
783          * code closes the file (as it often does), then the fsp pointer here
784          * points to free()'d memory. We *must* revalidate fsp each time
785          * around the loop.
786          */
787
788         pstrcpy(file_name, fsp->fsp_name);
789
790         while((fsp = initial_break_processing(dev, inode, file_id)) &&
791                         OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
792                 if(receive_smb(smbd_server_fd(),inbuf, timeout) == False) {
793                         /*
794                          * Die if we got an error.
795                          */
796
797                         if (smb_read_error == READ_EOF) {
798                                 DEBUG( 0, ( "oplock_break: end of file from client\n" ) );
799                                 shutdown_server = True;
800                         } else if (smb_read_error == READ_ERROR) {
801                                 DEBUG( 0, ("oplock_break: receive_smb error (%s)\n", strerror(errno)) );
802                                 shutdown_server = True;
803                         } else if (smb_read_error == READ_BAD_SIG) {
804                                 DEBUG( 0, ("oplock_break: bad signature from client\n" ));
805                                 shutdown_server = True;
806                         } else if (smb_read_error == READ_TIMEOUT) {
807                                 DEBUG( 0, ( "oplock_break: receive_smb timed out after %d seconds.\n", OPLOCK_BREAK_TIMEOUT ) );
808                                 oplock_timeout = True;
809                         }
810
811                         DEBUGADD( 0, ( "oplock_break failed for file %s ", file_name ) );
812                         DEBUGADD( 0, ( "(dev = %x, inode = %.0f, file_id = %lu).\n",
813                                 (unsigned int)dev, (double)inode, file_id));
814
815                         break;
816                 }
817
818                 /*
819                  * There are certain SMB requests that we shouldn't allow
820                  * to recurse. opens, renames and deletes are the obvious
821                  * ones. This is handled in the switch_message() function.
822                  * If global_oplock_break is set they will push the packet onto
823                  * the pending smb queue and return -1 (no reply).
824                  * JRA.
825                  */
826
827                 process_smb(inbuf, outbuf);
828
829                 /*
830                  * Die if we go over the time limit.
831                  */
832
833                 if((time(NULL) - start_time) > OPLOCK_BREAK_TIMEOUT) {
834                         if( DEBUGLVL( 0 ) ) {
835                                 dbgtext( "oplock_break: no break received from client " );
836                                 dbgtext( "within %d seconds.\n", OPLOCK_BREAK_TIMEOUT );
837                                 dbgtext( "oplock_break failed for file %s ", fsp->fsp_name );
838                                 dbgtext( "(dev = %x, inode = %.0f, file_id = %lu).\n",  
839                                         (unsigned int)dev, (double)inode, file_id );
840                         }
841                         oplock_timeout = True;
842                         break;
843                 }
844         }
845
846         /*
847          * Go back to being the user who requested the oplock
848          * break.
849          */
850         if((saved_user_conn != NULL) && (saved_vuid != UID_FIELD_INVALID) && !change_to_user(saved_user_conn, saved_vuid)) {
851                 DEBUG( 0, ( "oplock_break: unable to re-become user!" ) );
852                 DEBUGADD( 0, ( "Shutting down server\n" ) );
853                 close(oplock_sock);
854                 exit_server("unable to re-become user");
855         }
856
857         /* Including the directory. */
858         vfs_ChDir(saved_fsp_conn,saved_dir);
859
860         /* Restore the chain fnum. */
861         file_chain_restore();
862
863         /* Free the buffers we've been using to recurse. */
864         SAFE_FREE(inbuf);
865         SAFE_FREE(outbuf);
866
867         /* We need this in case a readraw crossed on the wire. */
868         if(global_oplock_break)
869                 global_oplock_break = False;
870
871         /*
872          * If the client timed out then clear the oplock (or go to level II)
873          * and continue. This seems to be what NT does and is better than dropping
874          * the connection.
875          */
876
877         if(oplock_timeout && (fsp = initial_break_processing(dev, inode, file_id)) &&
878                         OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
879                 DEBUG(0,("oplock_break: client failure in oplock break in file %s\n", fsp->fsp_name));
880                 remove_oplock(fsp,True);
881 #if FASCIST_OPLOCK_BACKOFF
882                 global_client_failed_oplock_break = True; /* Never grant this client an oplock again. */
883 #endif
884         }
885
886         /*
887          * If the client had an error we must die.
888          */
889
890         if(shutdown_server) {
891                 DEBUG( 0, ( "oplock_break: client failure in break - " ) );
892                 DEBUGADD( 0, ( "shutting down this smbd.\n" ) );
893                 close(oplock_sock);
894                 exit_server("oplock break failure");
895         }
896
897         /* Santity check - remove this later. JRA */
898         if(exclusive_oplocks_open < 0) {
899                 DEBUG(0,("oplock_break: exclusive_oplocks_open < 0 (%d). PANIC ERROR\n", exclusive_oplocks_open));
900                 abort();
901         }
902
903         if( DEBUGLVL( 3 ) ) {
904                 dbgtext( "oplock_break: returning success for " );
905                 dbgtext( "dev = %x, inode = %.0f, file_id = %lu\n", (unsigned int)dev, (double)inode, file_id );
906                 dbgtext( "Current exclusive_oplocks_open = %d\n", exclusive_oplocks_open );
907         }
908
909         return True;
910 }
911
912 /****************************************************************************
913 Send an oplock break message to another smbd process. If the oplock is held 
914 by the local smbd then call the oplock break function directly.
915 ****************************************************************************/
916
917 BOOL request_oplock_break(share_mode_entry *share_entry, BOOL async)
918 {
919         char op_break_msg[OPLOCK_BREAK_MSG_LEN];
920         struct sockaddr_in addr_out;
921         pid_t pid = sys_getpid();
922         time_t start_time;
923         int time_left;
924         SMB_DEV_T dev = share_entry->dev;
925         SMB_INO_T inode = share_entry->inode;
926         unsigned long file_id = share_entry->share_file_id;
927         uint16 break_cmd_type;
928
929         if(pid == share_entry->pid) {
930                 /* We are breaking our own oplock, make sure it's us. */
931                 if(share_entry->op_port != global_oplock_port) {
932                         DEBUG(0,("request_oplock_break: corrupt share mode entry - pid = %d, port = %d \
933 should be %d\n", (int)pid, share_entry->op_port, global_oplock_port));
934                         return False;
935                 }
936
937                 DEBUG(5,("request_oplock_break: breaking our own oplock\n"));
938
939 #if 1 /* JRA PARANOIA TEST.... */
940                 {
941                         files_struct *fsp = file_find_dif(dev, inode, file_id);
942                         if (!fsp) {
943                                 DEBUG(0,("request_oplock_break: PANIC : breaking our own oplock requested for \
944 dev = %x, inode = %.0f, file_id = %lu and no fsp found !\n",
945             (unsigned int)dev, (double)inode, file_id ));
946                                 smb_panic("request_oplock_break: no fsp found for our own oplock\n");
947                         }
948                 }
949 #endif /* END JRA PARANOIA TEST... */
950
951                 /* Call oplock break direct. */
952                 return oplock_break(dev, inode, file_id, True);
953         }
954
955         /* We need to send a OPLOCK_BREAK_CMD message to the port in the share mode entry. */
956
957         if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
958                 break_cmd_type = async ? ASYNC_LEVEL_II_OPLOCK_BREAK_CMD : LEVEL_II_OPLOCK_BREAK_CMD;
959         } else {
960                 break_cmd_type = OPLOCK_BREAK_CMD;
961         }
962
963         SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,break_cmd_type);
964         memcpy(op_break_msg+OPLOCK_BREAK_PID_OFFSET,(char *)&pid,sizeof(pid));
965         memcpy(op_break_msg+OPLOCK_BREAK_DEV_OFFSET,(char *)&dev,sizeof(dev));
966         memcpy(op_break_msg+OPLOCK_BREAK_INODE_OFFSET,(char *)&inode,sizeof(inode));
967         memcpy(op_break_msg+OPLOCK_BREAK_FILEID_OFFSET,(char *)&file_id,sizeof(file_id));
968
969         /* Set the address and port. */
970         memset((char *)&addr_out,'\0',sizeof(addr_out));
971         addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
972         addr_out.sin_port = htons( share_entry->op_port );
973         addr_out.sin_family = AF_INET;
974    
975         if( DEBUGLVL( 3 ) ) {
976                 dbgtext( "request_oplock_break: sending a %s oplock break message to ", async ? "asynchronous" : "synchronous" );
977                 dbgtext( "pid %d on port %d ", (int)share_entry->pid, share_entry->op_port );
978                 dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
979             (unsigned int)dev, (double)inode, file_id );
980         }
981
982         if(sys_sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0,
983                         (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0) {
984                 if( DEBUGLVL( 0 ) ) {
985                         dbgtext( "request_oplock_break: failed when sending a oplock " );
986                         dbgtext( "break message to pid %d ", (int)share_entry->pid );
987                         dbgtext( "on port %d ", share_entry->op_port );
988                         dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
989                                 (unsigned int)dev, (double)inode, file_id );
990                         dbgtext( "Error was %s\n", strerror(errno) );
991                 }
992                 return False;
993         }
994
995         /*
996          * If we just sent a message to a level II oplock share entry in async mode then
997          * we are done and may return.
998          */
999
1000         if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type) && async) {
1001                 DEBUG(3,("request_oplock_break: sent async break message to level II entry.\n"));
1002                 return True;
1003         }
1004
1005         /*
1006          * Now we must await the oplock broken message coming back
1007          * from the target smbd process. Timeout if it fails to
1008          * return in (OPLOCK_BREAK_TIMEOUT + OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR) seconds.
1009          * While we get messages that aren't ours, loop.
1010          */
1011
1012         start_time = time(NULL);
1013         time_left = OPLOCK_BREAK_TIMEOUT+OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR;
1014
1015         while(time_left >= 0) {
1016                 char op_break_reply[OPBRK_CMD_HEADER_LEN+OPLOCK_BREAK_MSG_LEN];
1017                 uint16 reply_from_port;
1018                 char *reply_msg_start;
1019
1020                 if(receive_local_message(op_break_reply, sizeof(op_break_reply),
1021                                 time_left ? time_left * 1000 : 1) == False) {
1022                         if(smb_read_error == READ_TIMEOUT) {
1023                                 if( DEBUGLVL( 0 ) ) {
1024                                         dbgtext( "request_oplock_break: no response received to oplock " );
1025                                         dbgtext( "break request to pid %d ", (int)share_entry->pid );
1026                                         dbgtext( "on port %d ", share_entry->op_port );
1027                                         dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
1028                                                         (unsigned int)dev, (double)inode, file_id );
1029                                 }
1030
1031                                 /*
1032                                  * This is a hack to make handling of failing clients more robust.
1033                                  * If a oplock break response message is not received in the timeout
1034                                  * period we may assume that the smbd servicing that client holding
1035                                  * the oplock has died and the client changes were lost anyway, so
1036                                  * we should continue to try and open the file.
1037                                  */
1038                                 break;
1039                         } else {
1040                                 if( DEBUGLVL( 0 ) ) {
1041                                         dbgtext( "request_oplock_break: error in response received " );
1042                                         dbgtext( "to oplock break request to pid %d ", (int)share_entry->pid );
1043                                         dbgtext( "on port %d ", share_entry->op_port );
1044                                         dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
1045                                                 (unsigned int)dev, (double)inode, file_id );
1046                                         dbgtext( "Error was (%s).\n", strerror(errno) );
1047                                 }
1048                         }
1049                         return False;
1050                 }
1051
1052                 reply_from_port = SVAL(op_break_reply,OPBRK_CMD_PORT_OFFSET);
1053                 reply_msg_start = &op_break_reply[OPBRK_CMD_HEADER_LEN];
1054
1055                 /*
1056                  * Test to see if this is the reply we are awaiting (ie. the one we sent with the CMD_REPLY flag OR'ed in).
1057                  */
1058                 if((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & CMD_REPLY) &&
1059                         ((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & ~CMD_REPLY) == break_cmd_type) &&
1060                         (reply_from_port == share_entry->op_port) && 
1061                         (memcmp(&reply_msg_start[OPLOCK_BREAK_PID_OFFSET], &op_break_msg[OPLOCK_BREAK_PID_OFFSET],
1062                                 OPLOCK_BREAK_MSG_LEN - OPLOCK_BREAK_PID_OFFSET) == 0)) {
1063
1064                         /*
1065                          * This is the reply we've been waiting for.
1066                          */
1067                         break;
1068                 } else {
1069                         /*
1070                          * This is another message - a break request.
1071                          * Note that both kernel oplock break requests
1072                          * and UDP inter-smbd oplock break requests will
1073                          * be processed here.
1074                          *
1075                          * Process it to prevent potential deadlock.
1076                          * Note that the code in switch_message() prevents
1077                          * us from recursing into here as any SMB requests
1078                          * we might process that would cause another oplock
1079                          * break request to be made will be queued.
1080                          * JRA.
1081                          */
1082
1083                         process_local_message(op_break_reply, sizeof(op_break_reply));
1084                 }
1085
1086                 time_left -= (time(NULL) - start_time);
1087         }
1088
1089         DEBUG(3,("request_oplock_break: broke oplock.\n"));
1090
1091         return True;
1092 }
1093
1094 /****************************************************************************
1095   Attempt to break an oplock on a file (if oplocked).
1096   Returns True if the file was closed as a result of
1097   the oplock break, False otherwise.
1098   Used as a last ditch attempt to free a space in the 
1099   file table when we have run out.
1100 ****************************************************************************/
1101
1102 BOOL attempt_close_oplocked_file(files_struct *fsp)
1103 {
1104         DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fsp->fsp_name));
1105
1106         if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && !fsp->sent_oplock_break && (fsp->fd != -1)) {
1107                 /* Try and break the oplock. */
1108                 if (oplock_break(fsp->dev, fsp->inode, fsp->file_id, True)) {
1109                         if(file_find_fsp(fsp) == NULL) /* Did the oplock break close the file ? */
1110                                 return True;
1111                 }
1112         }
1113
1114         return False;
1115 }
1116
1117 /****************************************************************************
1118  This function is called on any file modification or lock request. If a file
1119  is level 2 oplocked then it must tell all other level 2 holders to break to none.
1120 ****************************************************************************/
1121
1122 void release_level_2_oplocks_on_change(files_struct *fsp)
1123 {
1124         share_mode_entry *share_list = NULL;
1125         pid_t pid = sys_getpid();
1126         int token = -1;
1127         int num_share_modes = 0;
1128         int i;
1129
1130         /*
1131          * If this file is level II oplocked then we need
1132          * to grab the shared memory lock and inform all
1133          * other files with a level II lock that they need
1134          * to flush their read caches. We keep the lock over
1135          * the shared memory area whilst doing this.
1136          */
1137
1138         if (!LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
1139                 return;
1140
1141         if (lock_share_entry_fsp(fsp) == False) {
1142                 DEBUG(0,("release_level_2_oplocks_on_change: failed to lock share mode entry for file %s.\n", fsp->fsp_name ));
1143         }
1144
1145         num_share_modes = get_share_modes(fsp->conn, fsp->dev, fsp->inode, &share_list);
1146
1147         DEBUG(10,("release_level_2_oplocks_on_change: num_share_modes = %d\n", 
1148                         num_share_modes ));
1149
1150         for(i = 0; i < num_share_modes; i++) {
1151                 share_mode_entry *share_entry = &share_list[i];
1152
1153                 /*
1154                  * As there could have been multiple writes waiting at the lock_share_entry
1155                  * gate we may not be the first to enter. Hence the state of the op_types
1156                  * in the share mode entries may be partly NO_OPLOCK and partly LEVEL_II
1157                  * oplock. It will do no harm to re-send break messages to those smbd's
1158                  * that are still waiting their turn to remove their LEVEL_II state, and
1159                  * also no harm to ignore existing NO_OPLOCK states. JRA.
1160                  */
1161
1162                 DEBUG(10,("release_level_2_oplocks_on_change: share_entry[%i]->op_type == %d\n",
1163                                 i, share_entry->op_type ));
1164
1165                 if (share_entry->op_type == NO_OPLOCK)
1166                         continue;
1167
1168                 /* Paranoia .... */
1169                 if (EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) {
1170                         DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is an exlusive oplock !\n", i ));
1171                         unlock_share_entry(fsp->conn, fsp->dev, fsp->inode);
1172                         abort();
1173                 }
1174
1175                 /*
1176                  * Check if this is a file we have open (including the
1177                  * file we've been called to do write_file on. If so
1178                  * then break it directly without releasing the lock.
1179                  */
1180
1181                 if (pid == share_entry->pid) {
1182                         files_struct *new_fsp = file_find_dif(share_entry->dev, share_entry->inode, share_entry->share_file_id);
1183
1184                         /* Paranoia check... */
1185                         if(new_fsp == NULL) {
1186                                 DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is not a local file !\n", i ));
1187                                 unlock_share_entry(fsp->conn, fsp->dev, fsp->inode);
1188                                 abort();
1189                         }
1190
1191                         DEBUG(10,("release_level_2_oplocks_on_change: breaking our own oplock.\n"));
1192
1193                         oplock_break_level2(new_fsp, True, token);
1194
1195                 } else {
1196
1197                         /*
1198                          * This is a remote file and so we send an asynchronous
1199                          * message.
1200                          */
1201
1202                         DEBUG(10,("release_level_2_oplocks_on_change: breaking remote oplock (async).\n"));
1203                         request_oplock_break(share_entry, True);
1204                 }
1205         }
1206
1207         SAFE_FREE(share_list);
1208         unlock_share_entry_fsp(fsp);
1209
1210         /* Paranoia check... */
1211         if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type)) {
1212                 DEBUG(0,("release_level_2_oplocks_on_change: PANIC. File %s still has a level II oplock.\n", fsp->fsp_name));
1213                 smb_panic("release_level_2_oplocks_on_change");
1214         }
1215 }
1216
1217 /****************************************************************************
1218 setup oplocks for this process
1219 ****************************************************************************/
1220
1221 BOOL init_oplocks(void)
1222 {
1223         struct sockaddr_in sock_name;
1224         socklen_t len = sizeof(sock_name);
1225
1226         DEBUG(3,("open_oplock_ipc: opening loopback UDP socket.\n"));
1227
1228         /* Open a lookback UDP socket on a random port. */
1229         oplock_sock = open_socket_in(SOCK_DGRAM, 0, 0, htonl(INADDR_LOOPBACK),False);
1230         if (oplock_sock == -1) {
1231                 DEBUG(0,("open_oplock_ipc: Failed to get local UDP socket for \
1232 address %lx. Error was %s\n", (long)htonl(INADDR_LOOPBACK), strerror(errno)));
1233                 global_oplock_port = 0;
1234                 return(False);
1235         }
1236
1237         /* Find out the transient UDP port we have been allocated. */
1238         if(getsockname(oplock_sock, (struct sockaddr *)&sock_name, &len)<0) {
1239                 DEBUG(0,("open_oplock_ipc: Failed to get local UDP port. Error was %s\n",
1240                          strerror(errno)));
1241                 close(oplock_sock);
1242                 oplock_sock = -1;
1243                 global_oplock_port = 0;
1244                 return False;
1245         }
1246         global_oplock_port = ntohs(sock_name.sin_port);
1247
1248         if (lp_kernel_oplocks()) {
1249 #if HAVE_KERNEL_OPLOCKS_IRIX
1250                 koplocks = irix_init_kernel_oplocks();
1251 #elif HAVE_KERNEL_OPLOCKS_LINUX
1252                 koplocks = linux_init_kernel_oplocks();
1253 #endif
1254         }
1255
1256         DEBUG(3,("open_oplock ipc: pid = %d, global_oplock_port = %u\n", 
1257                  (int)sys_getpid(), global_oplock_port));
1258
1259         return True;
1260 }