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