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                 case RETRY_DEFERRED_OPEN_CMD:
 392
 393                         /* Request to retry and open that would return SHARING_VIOLATION. */
 394                         if (msg_len != DEFERRED_OPEN_MSG_LEN) {
 395                                 DEBUG(0,("process_local_message: incorrect length for RETRY_DEFERRED_OPEN_CMD (was %d, should be %d).\n",
 396                                         (int)msg_len, (int)DEFERRED_OPEN_MSG_LEN));
 397                                 return False;
 398                         }
 399                         {
 400                                 uint16 mid;
 401
 402                                 memcpy((char *)&remotepid, msg_start+DEFERRED_OPEN_PID_OFFSET,sizeof(remotepid));
 403                                 memcpy((char *)&inode, msg_start+DEFERRED_OPEN_INODE_OFFSET,sizeof(inode));
 404                                 memcpy((char *)&dev, msg_start+DEFERRED_OPEN_DEV_OFFSET,sizeof(dev));
 405                                 memcpy((char *)&mid, msg_start+DEFERRED_OPEN_MID_OFFSET,sizeof(mid));
 406
 407                                 DEBUG(5,("process_local_message: RETRY_DEFERRED_OPEN from \
 408 pid %d, port %d, dev = %x, inode = %.0f, mid = %u\n",
 409                                         (int)remotepid, from_port, (unsigned int)dev, (double)inode, (unsigned int)mid));
 410
 411                                 schedule_sharing_violation_open_smb_message(mid);
 412                         }
 413                         return True;
 414
 415                 /*
 416                  * Keep this as a debug case - eventually we can remove it.
 417                  */
 418                 case 0x8001:
 419                         DEBUG(0,("process_local_message: Received unsolicited break \
 420 reply - dumping info.\n"));
 421
 422                         if(msg_len != OPLOCK_BREAK_MSG_LEN) {
 423                                 DEBUG(0,("process_local_message: ubr: incorrect length for reply \
 424 (was %d, should be %d).\n", (int)msg_len, (int)OPLOCK_BREAK_MSG_LEN));
 425                                 return False;
 426                         }
 427
 428                         memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode));
 429                         memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid));
 430                         memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev));
 431                         memcpy((char *)&file_id, msg_start+OPLOCK_BREAK_FILEID_OFFSET,sizeof(file_id));
 432
 433                         DEBUG(0,("process_local_message: unsolicited oplock break reply from \
 434 pid %d, port %d, dev = %x, inode = %.0f, file_id = %lu\n",
 435                                 (int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id));
 436
 437                         return False;
 438
 439                 default:
 440                         DEBUG(0,("process_local_message: unknown UDP message command code (%x) - ignoring.\n",
 441                                 (unsigned int)SVAL(msg_start,0)));
 442                         return False;
 443         }
 444
 445         /*
 446          * Now actually process the break request.
 447          */
 448
 449         if((exclusive_oplocks_open + level_II_oplocks_open) != 0) {
 450                 if (oplock_break(dev, inode, file_id, False) == False) {
 451                         DEBUG(0,("process_local_message: oplock break failed.\n"));
 452                         return False;
 453                 }
 454         } else {
 455                 /*
 456                  * If we have no record of any currently open oplocks,
 457                  * it's not an error, as a close command may have
 458                  * just been issued on the file that was oplocked.
 459                  * Just log a message and return success in this case.
 460                  */
 461                 DEBUG(3,("process_local_message: oplock break requested with no outstanding \
 462 oplocks. Returning success.\n"));
 463         }
 464
 465         /*
 466          * Do the appropriate reply - none in the kernel or async level II case.
 467          */
 468
 469         if(break_cmd_type == OPLOCK_BREAK_CMD || break_cmd_type == LEVEL_II_OPLOCK_BREAK_CMD) {
 470                 struct sockaddr_in toaddr;
 471
 472                 /* Send the message back after OR'ing in the 'REPLY' bit. */
 473                 SSVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET,break_cmd_type | CMD_REPLY);
 474
 475                 memset((char *)&toaddr,'\0',sizeof(toaddr));
 476                 toaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 477                 toaddr.sin_port = htons(from_port);
 478                 toaddr.sin_family = AF_INET;
 479
 480                 if(sys_sendto( oplock_sock, msg_start, OPLOCK_BREAK_MSG_LEN, 0,
 481                                 (struct sockaddr *)&toaddr, sizeof(toaddr)) < 0) {
 482                         DEBUG(0,("process_local_message: sendto process %d failed. Errno was %s\n",
 483                                 (int)remotepid, strerror(errno)));
 484                         return False;
 485                 }
 486
 487                 DEBUG(5,("process_local_message: oplock break reply sent to \
 488 pid %d, port %d, for file dev = %x, inode = %.0f, file_id = %lu\n",
 489                         (int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id));
 490         }
 491
 492         return True;
 493 }
 494
 495 /****************************************************************************
 496  Set up an oplock break message.
 497 ****************************************************************************/
 498
 499 static void prepare_break_message(char *outbuf, files_struct *fsp, BOOL level2)
 500 {
 501         memset(outbuf,'\0',smb_size);
 502         set_message(outbuf,8,0,True);
 503
 504         SCVAL(outbuf,smb_com,SMBlockingX);
 505         SSVAL(outbuf,smb_tid,fsp->conn->cnum);
 506         SSVAL(outbuf,smb_pid,0xFFFF);
 507         SSVAL(outbuf,smb_uid,0);
 508         SSVAL(outbuf,smb_mid,0xFFFF);
 509         SCVAL(outbuf,smb_vwv0,0xFF);
 510         SSVAL(outbuf,smb_vwv2,fsp->fnum);
 511         SCVAL(outbuf,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE);
 512         SCVAL(outbuf,smb_vwv3+1,level2 ? OPLOCKLEVEL_II : OPLOCKLEVEL_NONE);
 513 }
 514
 515 /****************************************************************************
 516  Function to do the waiting before sending a local break.
 517 ****************************************************************************/
 518
 519 static void wait_before_sending_break(BOOL local_request)
 520 {
 521         extern struct timeval smb_last_time;
 522
 523         if(local_request) {
 524                 struct timeval cur_tv;
 525                 long wait_left = (long)lp_oplock_break_wait_time();
 526
 527                 if (wait_left == 0)
 528                         return;
 529
 530                 GetTimeOfDay(&cur_tv);
 531
 532                 wait_left -= ((cur_tv.tv_sec - smb_last_time.tv_sec)*1000) +
 533                 ((cur_tv.tv_usec - smb_last_time.tv_usec)/1000);
 534
 535                 if(wait_left > 0) {
 536                         wait_left = MIN(wait_left, 1000);
 537                         sys_usleep(wait_left * 1000);
 538                 }
 539         }
 540 }
 541
 542 /****************************************************************************
 543  Ensure that we have a valid oplock.
 544 ****************************************************************************/
 545
 546 static files_struct *initial_break_processing(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id)
 547 {
 548         files_struct *fsp = NULL;
 549
 550         if( DEBUGLVL( 3 ) ) {
 551                 dbgtext( "initial_break_processing: called for dev = %x, inode = %.0f file_id = %lu\n",
 552                         (unsigned int)dev, (double)inode, file_id);
 553                 dbgtext( "Current oplocks_open (exclusive = %d, levelII = %d)\n",
 554                         exclusive_oplocks_open, level_II_oplocks_open );
 555         }
 556
 557         /*
 558          * We need to search the file open table for the
 559          * entry containing this dev and inode, and ensure
 560          * we have an oplock on it.
 561          */
 562
 563         fsp = file_find_dif(dev, inode, file_id);
 564
 565         if(fsp == NULL) {
 566                 /* The file could have been closed in the meantime - return success. */
 567                 if( DEBUGLVL( 3 ) ) {
 568                         dbgtext( "initial_break_processing: cannot find open file with " );
 569                         dbgtext( "dev = %x, inode = %.0f file_id = %lu", (unsigned int)dev,
 570                                 (double)inode, file_id);
 571                         dbgtext( "allowing break to succeed.\n" );
 572                 }
 573                 return NULL;
 574         }
 575
 576         /* Ensure we have an oplock on the file */
 577
 578         /*
 579          * There is a potential race condition in that an oplock could
 580          * have been broken due to another udp request, and yet there are
 581          * still oplock break messages being sent in the udp message
 582          * queue for this file. So return true if we don't have an oplock,
 583          * as we may have just freed it.
 584          */
 585
 586         if(fsp->oplock_type == NO_OPLOCK) {
 587                 if( DEBUGLVL( 3 ) ) {
 588                         dbgtext( "initial_break_processing: file %s ", fsp->fsp_name );
 589                         dbgtext( "(dev = %x, inode = %.0f, file_id = %lu) has no oplock.\n",
 590                                 (unsigned int)dev, (double)inode, fsp->file_id );
 591                         dbgtext( "Allowing break to succeed regardless.\n" );
 592                 }
 593                 return NULL;
 594         }
 595
 596         return fsp;
 597 }
 598
 599 /****************************************************************************
 600  Process a level II oplock break directly.
 601  We must call this function with the share mode entry locked.
 602 ****************************************************************************/
 603
 604 static BOOL oplock_break_level2(files_struct *fsp, BOOL local_request)
 605 {
 606         extern uint32 global_client_caps;
 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                 if (!send_smb(smbd_server_fd(), outbuf))
 638                         exit_server("oplock_break_level2: send_smb failed.");
 639
 640                 /* Restore the sign state to what it was. */
 641                 srv_oplock_set_signing(sign_state);
 642         }
 643
 644         /*
 645          * Now we must update the shared memory structure to tell
 646          * everyone else we no longer have a level II oplock on
 647          * this open file. We must call this function with the share mode
 648          * entry locked so we can change the entry directly.
 649          */
 650
 651         if(remove_share_oplock(fsp)==False) {
 652                 DEBUG(0,("oplock_break_level2: unable to remove level II oplock for file %s\n", fsp->fsp_name ));
 653         }
 654
 655         release_file_oplock(fsp);
 656
 657         if(level_II_oplocks_open < 0) {
 658                 DEBUG(0,("oplock_break_level2: level_II_oplocks_open < 0 (%d). PANIC ERROR\n",
 659                         level_II_oplocks_open));
 660                 abort();
 661         }
 662
 663         if( DEBUGLVL( 3 ) ) {
 664                 dbgtext( "oplock_break_level2: returning success for " );
 665                 dbgtext( "dev = %x, inode = %.0f, file_id = %lu\n", (unsigned int)dev, (double)inode, fsp->file_id );
 666                 dbgtext( "Current level II oplocks_open = %d\n", level_II_oplocks_open );
 667         }
 668
 669         return True;
 670 }
 671
 672 /****************************************************************************
 673  Process an oplock break directly.
 674  This is always called with the share mode lock *NOT* held.
 675 ****************************************************************************/
 676
 677 static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id, BOOL local_request)
 678 {
 679         extern uint32 global_client_caps;
 680         extern struct current_user current_user;
 681         char *inbuf = NULL;
 682         char *outbuf = NULL;
 683         files_struct *fsp = NULL;
 684         time_t start_time;
 685         BOOL shutdown_server = False;
 686         BOOL oplock_timeout = False;
 687         BOOL sign_state;
 688         connection_struct *saved_user_conn;
 689         connection_struct *saved_fsp_conn;
 690         int saved_vuid;
 691         pstring saved_dir;
 692         int timeout = (OPLOCK_BREAK_TIMEOUT * 1000);
 693         pstring file_name;
 694         BOOL using_levelII;
 695
 696         if((fsp = initial_break_processing(dev, inode, file_id)) == NULL)
 697                 return True;
 698
 699         /*
 700          * Deal with a level II oplock going break to none separately.
 701          */
 702
 703         if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type)) {
 704                 BOOL ret;
 705                 /* We must always call oplock_break_level2() with
 706                    the share mode entry locked. */
 707                 if (lock_share_entry_fsp(fsp) == False) {
 708                         DEBUG(0,("oplock_break: unable to lock share entry for file %s\n", fsp->fsp_name ));
 709                         return False;
 710                 }
 711                 ret = oplock_break_level2(fsp, local_request);
 712                 unlock_share_entry_fsp(fsp);
 713                 return ret;
 714         }
 715
 716         /* Mark the oplock break as sent - we don't want to send twice! */
 717         if (fsp->sent_oplock_break) {
 718                 if( DEBUGLVL( 0 ) ) {
 719                         dbgtext( "oplock_break: ERROR: oplock_break already sent for " );
 720                         dbgtext( "file %s ", fsp->fsp_name);
 721                         dbgtext( "(dev = %x, inode = %.0f, file_id = %lu)\n", (unsigned int)dev, (double)inode, fsp->file_id );
 722                 }
 723
 724                 /*
 725                  * We have to fail the open here as we cannot send another oplock break on
 726                  * this file whilst we are awaiting a response from the client - neither
 727                  * can we allow another open to succeed while we are waiting for the client.
 728                  */
 729                 return False;
 730         }
 731
 732         if(global_oplock_break) {
 733                 DEBUG(0,("ABORT : ABORT : recursion in oplock_break !!!!!\n"));
 734                 abort();
 735         }
 736
 737         /*
 738          * Now comes the horrid part. We must send an oplock break to the client,
 739          * and then process incoming messages until we get a close or oplock release.
 740          * At this point we know we need a new inbuf/outbuf buffer pair.
 741          * We cannot use these staticaly as we may recurse into here due to
 742          * messages crossing on the wire.
 743          */
 744
 745         if((inbuf = (char *)SMB_MALLOC(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL) {
 746                 DEBUG(0,("oplock_break: malloc fail for input buffer.\n"));
 747                 return False;
 748         }
 749
 750         if((outbuf = (char *)SMB_MALLOC(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL) {
 751                 DEBUG(0,("oplock_break: malloc fail for output buffer.\n"));
 752                 SAFE_FREE(inbuf);
 753                 return False;
 754         }
 755
 756         /*
 757          * If we are sending an oplock break due to an SMB sent
 758          * by our own client we ensure that we wait at leat
 759          * lp_oplock_break_wait_time() milliseconds before sending
 760          * the packet. Sending the packet sooner can break Win9x
 761          * and has reported to cause problems on NT. JRA.
 762          */
 763
 764         wait_before_sending_break(local_request);
 765
 766         /* Prepare the SMBlockingX message. */
 767
 768         if ((global_client_caps & CAP_LEVEL_II_OPLOCKS) &&
 769                         !koplocks && /* NOTE: we force levelII off for kernel oplocks - this will change when it is supported */
 770                         lp_level2_oplocks(SNUM(fsp->conn))) {
 771                 using_levelII = True;
 772         } else {
 773                 using_levelII = False;
 774         }
 775
 776         prepare_break_message( outbuf, fsp, using_levelII);
 777         /* Remember if we just sent a break to level II on this file. */
 778         fsp->sent_oplock_break = using_levelII? LEVEL_II_BREAK_SENT:EXCLUSIVE_BREAK_SENT;
 779
 780         /* Save the server smb signing state. */
 781         sign_state = srv_oplock_set_signing(False);
 782
 783         if (!send_smb(smbd_server_fd(), outbuf)) {
 784                 srv_oplock_set_signing(sign_state);
 785                 exit_server("oplock_break: send_smb failed.");
 786         }
 787
 788         /* Restore the sign state to what it was. */
 789         srv_oplock_set_signing(sign_state);
 790
 791         /* We need this in case a readraw crosses on the wire. */
 792         global_oplock_break = True;
 793
 794         /* Process incoming messages. */
 795
 796         /*
 797          * JRA - If we don't get a break from the client in OPLOCK_BREAK_TIMEOUT
 798          * seconds we should just die....
 799          */
 800
 801         start_time = time(NULL);
 802
 803         /*
 804          * Save the information we need to re-become the
 805          * user, then unbecome the user whilst we're doing this.
 806          */
 807         saved_user_conn = current_user.conn;
 808         saved_vuid = current_user.vuid;
 809         saved_fsp_conn = fsp->conn;
 810         change_to_root_user();
 811         vfs_GetWd(saved_fsp_conn,saved_dir);
 812         /* Save the chain fnum. */
 813         file_chain_save();
 814
 815         /*
 816          * From Charles Hoch <hoch@exemplary.com>. If the break processing
 817          * code closes the file (as it often does), then the fsp pointer here
 818          * points to free()'d memory. We *must* revalidate fsp each time
 819          * around the loop.
 820          */
 821
 822         pstrcpy(file_name, fsp->fsp_name);
 823
 824         while((fsp = initial_break_processing(dev, inode, file_id)) &&
 825                         OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
 826                 if(receive_smb(smbd_server_fd(),inbuf, timeout) == False) {
 827                         /*
 828                          * Die if we got an error.
 829                          */
 830
 831                         if (smb_read_error == READ_EOF) {
 832                                 DEBUG( 0, ( "oplock_break: end of file from client\n" ) );
 833                                 shutdown_server = True;
 834                         } else if (smb_read_error == READ_ERROR) {
 835                                 DEBUG( 0, ("oplock_break: receive_smb error (%s)\n", strerror(errno)) );
 836                                 shutdown_server = True;
 837                         } else if (smb_read_error == READ_BAD_SIG) {
 838                                 DEBUG( 0, ("oplock_break: bad signature from client\n" ));
 839                                 shutdown_server = True;
 840                         } else if (smb_read_error == READ_TIMEOUT) {
 841                                 DEBUG( 0, ( "oplock_break: receive_smb timed out after %d seconds.\n", OPLOCK_BREAK_TIMEOUT ) );
 842                                 oplock_timeout = True;
 843                         }
 844
 845                         DEBUGADD( 0, ( "oplock_break failed for file %s ", file_name ) );
 846                         DEBUGADD( 0, ( "(dev = %x, inode = %.0f, file_id = %lu).\n",
 847                                 (unsigned int)dev, (double)inode, file_id));
 848
 849                         break;
 850                 }
 851
 852                 /*
 853                  * There are certain SMB requests that we shouldn't allow
 854                  * to recurse. opens, renames and deletes are the obvious
 855                  * ones. This is handled in the switch_message() function.
 856                  * If global_oplock_break is set they will push the packet onto
 857                  * the pending smb queue and return -1 (no reply).
 858                  * JRA.
 859                  */
 860
 861                 process_smb(inbuf, outbuf);
 862
 863                 /*
 864                  * Die if we go over the time limit.
 865                  */
 866
 867                 if((time(NULL) - start_time) > OPLOCK_BREAK_TIMEOUT) {
 868                         if( DEBUGLVL( 0 ) ) {
 869                                 dbgtext( "oplock_break: no break received from client " );
 870                                 dbgtext( "within %d seconds.\n", OPLOCK_BREAK_TIMEOUT );
 871                                 dbgtext( "oplock_break failed for file %s ", fsp->fsp_name );
 872                                 dbgtext( "(dev = %x, inode = %.0f, file_id = %lu).\n",
 873                                         (unsigned int)dev, (double)inode, file_id );
 874                         }
 875                         oplock_timeout = True;
 876                         break;
 877                 }
 878         }
 879
 880         /*
 881          * Go back to being the user who requested the oplock
 882          * break.
 883          */
 884         if((saved_user_conn != NULL) && (saved_vuid != UID_FIELD_INVALID) && !change_to_user(saved_user_conn, saved_vuid)) {
 885                 DEBUG( 0, ( "oplock_break: unable to re-become user!" ) );
 886                 DEBUGADD( 0, ( "Shutting down server\n" ) );
 887                 close(oplock_sock);
 888                 exit_server("unable to re-become user");
 889         }
 890
 891         /* Including the directory. */
 892         vfs_ChDir(saved_fsp_conn,saved_dir);
 893
 894         /* Restore the chain fnum. */
 895         file_chain_restore();
 896
 897         /* Free the buffers we've been using to recurse. */
 898         SAFE_FREE(inbuf);
 899         SAFE_FREE(outbuf);
 900
 901         /* We need this in case a readraw crossed on the wire. */
 902         if(global_oplock_break)
 903                 global_oplock_break = False;
 904
 905         /*
 906          * If the client timed out then clear the oplock (or go to level II)
 907          * and continue. This seems to be what NT does and is better than dropping
 908          * the connection.
 909          */
 910
 911         if(oplock_timeout && (fsp = initial_break_processing(dev, inode, file_id)) &&
 912                         OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
 913                 DEBUG(0,("oplock_break: client failure in oplock break in file %s\n", fsp->fsp_name));
 914                 remove_oplock(fsp,True);
 915 #if FASCIST_OPLOCK_BACKOFF
 916                 global_client_failed_oplock_break = True; /* Never grant this client an oplock again. */
 917 #endif
 918         }
 919
 920         /*
 921          * If the client had an error we must die.
 922          */
 923
 924         if(shutdown_server) {
 925                 DEBUG( 0, ( "oplock_break: client failure in break - " ) );
 926                 DEBUGADD( 0, ( "shutting down this smbd.\n" ) );
 927                 close(oplock_sock);
 928                 exit_server("oplock break failure");
 929         }
 930
 931         /* Santity check - remove this later. JRA */
 932         if(exclusive_oplocks_open < 0) {
 933                 DEBUG(0,("oplock_break: exclusive_oplocks_open < 0 (%d). PANIC ERROR\n", exclusive_oplocks_open));
 934                 abort();
 935         }
 936
 937         /* We know we have no saved errors here. */
 938         set_saved_error_triple(0, 0, NT_STATUS_OK);
 939
 940         if( DEBUGLVL( 3 ) ) {
 941                 dbgtext( "oplock_break: returning success for " );
 942                 dbgtext( "dev = %x, inode = %.0f, file_id = %lu\n", (unsigned int)dev, (double)inode, file_id );
 943                 dbgtext( "Current exclusive_oplocks_open = %d\n", exclusive_oplocks_open );
 944         }
 945
 946         return True;
 947 }
 948
 949 /****************************************************************************
 950  Send an oplock break message to another smbd process. If the oplock is held
 951  by the local smbd then call the oplock break function directly.
 952  This function is called with no share locks held.
 953 ****************************************************************************/
 954
 955 BOOL request_oplock_break(share_mode_entry *share_entry)
 956 {
 957         char op_break_msg[OPLOCK_BREAK_MSG_LEN];
 958         struct sockaddr_in addr_out;
 959         pid_t pid = sys_getpid();
 960         time_t start_time;
 961         int time_left;
 962         SMB_DEV_T dev = share_entry->dev;
 963         SMB_INO_T inode = share_entry->inode;
 964         unsigned long file_id = share_entry->share_file_id;
 965         uint16 break_cmd_type;
 966
 967         if(pid == share_entry->pid) {
 968                 /* We are breaking our own oplock, make sure it's us. */
 969                 if(share_entry->op_port != global_oplock_port) {
 970                         DEBUG(0,("request_oplock_break: corrupt share mode entry - pid = %d, port = %d \
 971 should be %d\n", (int)pid, share_entry->op_port, global_oplock_port));
 972                         return False;
 973                 }
 974
 975                 DEBUG(5,("request_oplock_break: breaking our own oplock\n"));
 976
 977 #if 1 /* JRA PARANOIA TEST.... */
 978                 {
 979                         files_struct *fsp = file_find_dif(dev, inode, file_id);
 980                         if (!fsp) {
 981                                 DEBUG(0,("request_oplock_break: PANIC : breaking our own oplock requested for \
 982 dev = %x, inode = %.0f, file_id = %lu and no fsp found !\n",
 983             (unsigned int)dev, (double)inode, file_id ));
 984                                 smb_panic("request_oplock_break: no fsp found for our own oplock\n");
 985                         }
 986                 }
 987 #endif /* END JRA PARANOIA TEST... */
 988
 989                 /* Call oplock break direct. */
 990                 return oplock_break(dev, inode, file_id, True);
 991         }
 992
 993         /* We need to send a OPLOCK_BREAK_CMD message to the port in the share mode entry. */
 994
 995         if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
 996                 break_cmd_type = LEVEL_II_OPLOCK_BREAK_CMD;
 997         } else {
 998                 break_cmd_type = OPLOCK_BREAK_CMD;
 999         }
1000
1001         SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,break_cmd_type);
1002         memcpy(op_break_msg+OPLOCK_BREAK_PID_OFFSET,(char *)&pid,sizeof(pid));
1003         memcpy(op_break_msg+OPLOCK_BREAK_DEV_OFFSET,(char *)&dev,sizeof(dev));
1004         memcpy(op_break_msg+OPLOCK_BREAK_INODE_OFFSET,(char *)&inode,sizeof(inode));
1005         memcpy(op_break_msg+OPLOCK_BREAK_FILEID_OFFSET,(char *)&file_id,sizeof(file_id));
1006
1007         /* Set the address and port. */
1008         memset((char *)&addr_out,'\0',sizeof(addr_out));
1009         addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1010         addr_out.sin_port = htons( share_entry->op_port );
1011         addr_out.sin_family = AF_INET;
1012
1013         if( DEBUGLVL( 3 ) ) {
1014                 dbgtext( "request_oplock_break: sending a synchronous oplock break message to " );
1015                 dbgtext( "pid %d on port %d ", (int)share_entry->pid, share_entry->op_port );
1016                 dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
1017             (unsigned int)dev, (double)inode, file_id );
1018         }
1019
1020         if(sys_sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0,
1021                         (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0) {
1022                 if( DEBUGLVL( 0 ) ) {
1023                         dbgtext( "request_oplock_break: failed when sending a oplock " );
1024                         dbgtext( "break message to pid %d ", (int)share_entry->pid );
1025                         dbgtext( "on port %d ", share_entry->op_port );
1026                         dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
1027                                 (unsigned int)dev, (double)inode, file_id );
1028                         dbgtext( "Error was %s\n", strerror(errno) );
1029                 }
1030                 return False;
1031         }
1032
1033         /*
1034          * Now we must await the oplock broken message coming back
1035          * from the target smbd process. Timeout if it fails to
1036          * return in (OPLOCK_BREAK_TIMEOUT + OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR) seconds.
1037          * While we get messages that aren't ours, loop.
1038          */
1039
1040         start_time = time(NULL);
1041         time_left = OPLOCK_BREAK_TIMEOUT+OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR;
1042
1043         while(time_left >= 0) {
1044                 char op_break_reply[OPBRK_CMD_HEADER_LEN+OPLOCK_BREAK_MSG_LEN];
1045                 uint16 reply_from_port;
1046                 char *reply_msg_start;
1047
1048                 if(receive_local_message(op_break_reply, sizeof(op_break_reply),
1049                                 time_left ? time_left * 1000 : 1) == False) {
1050                         if(smb_read_error == READ_TIMEOUT) {
1051                                 if( DEBUGLVL( 0 ) ) {
1052                                         dbgtext( "request_oplock_break: no response received to oplock " );
1053                                         dbgtext( "break request to pid %d ", (int)share_entry->pid );
1054                                         dbgtext( "on port %d ", share_entry->op_port );
1055                                         dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
1056                                                         (unsigned int)dev, (double)inode, file_id );
1057                                 }
1058
1059                                 /*
1060                                  * This is a hack to make handling of failing clients more robust.
1061                                  * If a oplock break response message is not received in the timeout
1062                                  * period we may assume that the smbd servicing that client holding
1063                                  * the oplock has died and the client changes were lost anyway, so
1064                                  * we should continue to try and open the file.
1065                                  */
1066                                 break;
1067                         } else {
1068                                 if( DEBUGLVL( 0 ) ) {
1069                                         dbgtext( "request_oplock_break: error in response received " );
1070                                         dbgtext( "to oplock break request to pid %d ", (int)share_entry->pid );
1071                                         dbgtext( "on port %d ", share_entry->op_port );
1072                                         dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
1073                                                 (unsigned int)dev, (double)inode, file_id );
1074                                         dbgtext( "Error was (%s).\n", strerror(errno) );
1075                                 }
1076                         }
1077                         return False;
1078                 }
1079
1080                 reply_from_port = SVAL(op_break_reply,OPBRK_CMD_PORT_OFFSET);
1081                 reply_msg_start = &op_break_reply[OPBRK_CMD_HEADER_LEN];
1082
1083                 /*
1084                  * Test to see if this is the reply we are awaiting (ie. the one we sent with the CMD_REPLY flag OR'ed in).
1085                  */
1086                 if((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & CMD_REPLY) &&
1087                         ((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & ~CMD_REPLY) == break_cmd_type) &&
1088                         (reply_from_port == share_entry->op_port) &&
1089                         (memcmp(&reply_msg_start[OPLOCK_BREAK_PID_OFFSET], &op_break_msg[OPLOCK_BREAK_PID_OFFSET],
1090                                 OPLOCK_BREAK_MSG_LEN - OPLOCK_BREAK_PID_OFFSET) == 0)) {
1091
1092                         /*
1093                          * This is the reply we've been waiting for.
1094                          */
1095                         break;
1096                 } else {
1097                         /*
1098                          * This is another message - a break request.
1099                          * Note that both kernel oplock break requests
1100                          * and UDP inter-smbd oplock break requests will
1101                          * be processed here.
1102                          *
1103                          * Process it to prevent potential deadlock.
1104                          * Note that the code in switch_message() prevents
1105                          * us from recursing into here as any SMB requests
1106                          * we might process that would cause another oplock
1107                          * break request to be made will be queued.
1108                          * JRA.
1109                          */
1110
1111                         process_local_message(op_break_reply, sizeof(op_break_reply));
1112                 }
1113
1114                 time_left -= (time(NULL) - start_time);
1115         }
1116
1117         DEBUG(3,("request_oplock_break: broke oplock.\n"));
1118
1119         return True;
1120 }
1121
1122 /****************************************************************************
1123   Attempt to break an oplock on a file (if oplocked).
1124   Returns True if the file was closed as a result of
1125   the oplock break, False otherwise.
1126   Used as a last ditch attempt to free a space in the
1127   file table when we have run out.
1128 ****************************************************************************/
1129
1130 BOOL attempt_close_oplocked_file(files_struct *fsp)
1131 {
1132         DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fsp->fsp_name));
1133
1134         if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && !fsp->sent_oplock_break && (fsp->fd != -1)) {
1135                 /* Try and break the oplock. */
1136                 if (oplock_break(fsp->dev, fsp->inode, fsp->file_id, True)) {
1137                         if(file_find_fsp(fsp) == NULL) /* Did the oplock break close the file ? */
1138                                 return True;
1139                 }
1140         }
1141
1142         return False;
1143 }
1144
1145 /****************************************************************************
1146  Send an asynchronous oplock break message to another smbd process.
1147 ****************************************************************************/
1148
1149 static BOOL request_remote_level2_async_oplock_break(share_mode_entry *share_entry)
1150 {
1151         char op_break_msg[OPLOCK_BREAK_MSG_LEN];
1152         struct sockaddr_in addr_out;
1153         pid_t pid = sys_getpid();
1154         SMB_DEV_T dev = share_entry->dev;
1155         SMB_INO_T inode = share_entry->inode;
1156         unsigned long file_id = share_entry->share_file_id;
1157
1158         /* We need to send a ASYNC_LEVEL_II_OPLOCK_BREAK_CMD message to the port in the share mode entry. */
1159
1160         SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,ASYNC_LEVEL_II_OPLOCK_BREAK_CMD);
1161         memcpy(op_break_msg+OPLOCK_BREAK_PID_OFFSET,(char *)&pid,sizeof(pid));
1162         memcpy(op_break_msg+OPLOCK_BREAK_DEV_OFFSET,(char *)&dev,sizeof(dev));
1163         memcpy(op_break_msg+OPLOCK_BREAK_INODE_OFFSET,(char *)&inode,sizeof(inode));
1164         memcpy(op_break_msg+OPLOCK_BREAK_FILEID_OFFSET,(char *)&file_id,sizeof(file_id));
1165
1166         /* Set the address and port. */
1167         memset((char *)&addr_out,'\0',sizeof(addr_out));
1168         addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1169         addr_out.sin_port = htons( share_entry->op_port );
1170         addr_out.sin_family = AF_INET;
1171
1172         if( DEBUGLVL( 3 ) ) {
1173                 dbgtext( "request_remote_level2_async_oplock_break: sending an asynchronous oplock break message to ");
1174                 dbgtext( "pid %d on port %d ", (int)share_entry->pid, share_entry->op_port );
1175                 dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
1176             (unsigned int)dev, (double)inode, file_id );
1177         }
1178
1179         if(sys_sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0,
1180                         (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0) {
1181                 if( DEBUGLVL( 0 ) ) {
1182                         dbgtext( "request_remote_level2_async_oplock_break: failed when sending a oplock " );
1183                         dbgtext( "break message to pid %d ", (int)share_entry->pid );
1184                         dbgtext( "on port %d ", share_entry->op_port );
1185                         dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
1186                                 (unsigned int)dev, (double)inode, file_id );
1187                         dbgtext( "Error was %s\n", strerror(errno) );
1188                 }
1189                 return False;
1190         }
1191
1192         DEBUG(3,("request_remote_level2_async_oplock_break: sent async break message to level II entry.\n"));
1193         return True;
1194 }
1195
1196 /****************************************************************************
1197  This function is called on any file modification or lock request. If a file
1198  is level 2 oplocked then it must tell all other level 2 holders to break to none.
1199 ****************************************************************************/
1200
1201 void release_level_2_oplocks_on_change(files_struct *fsp)
1202 {
1203         share_mode_entry *share_list = NULL;
1204         pid_t pid = sys_getpid();
1205         int num_share_modes = 0;
1206         int i;
1207
1208         /*
1209          * If this file is level II oplocked then we need
1210          * to grab the shared memory lock and inform all
1211          * other files with a level II lock that they need
1212          * to flush their read caches. We keep the lock over
1213          * the shared memory area whilst doing this.
1214          */
1215
1216         if (!LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
1217                 return;
1218
1219         if (lock_share_entry_fsp(fsp) == False) {
1220                 DEBUG(0,("release_level_2_oplocks_on_change: failed to lock share mode entry for file %s.\n", fsp->fsp_name ));
1221         }
1222
1223         num_share_modes = get_share_modes(fsp->conn, fsp->dev, fsp->inode, &share_list);
1224
1225         DEBUG(10,("release_level_2_oplocks_on_change: num_share_modes = %d\n",
1226                         num_share_modes ));
1227
1228         for(i = 0; i < num_share_modes; i++) {
1229                 share_mode_entry *share_entry = &share_list[i];
1230
1231                 /*
1232                  * As there could have been multiple writes waiting at the lock_share_entry
1233                  * gate we may not be the first to enter. Hence the state of the op_types
1234                  * in the share mode entries may be partly NO_OPLOCK and partly LEVEL_II
1235                  * oplock. It will do no harm to re-send break messages to those smbd's
1236                  * that are still waiting their turn to remove their LEVEL_II state, and
1237                  * also no harm to ignore existing NO_OPLOCK states. JRA.
1238                  */
1239
1240                 DEBUG(10,("release_level_2_oplocks_on_change: share_entry[%i]->op_type == %d\n",
1241                                 i, share_entry->op_type ));
1242
1243                 if (share_entry->op_type == NO_OPLOCK)
1244                         continue;
1245
1246                 /* Paranoia .... */
1247                 if (EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) {
1248                         DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is an exlusive oplock !\n", i ));
1249                         unlock_share_entry(fsp->conn, fsp->dev, fsp->inode);
1250                         abort();
1251                 }
1252
1253                 /*
1254                  * Check if this is a file we have open (including the
1255                  * file we've been called to do write_file on. If so
1256                  * then break it directly without releasing the lock.
1257                  */
1258
1259                 if (pid == share_entry->pid) {
1260                         files_struct *new_fsp = file_find_dif(share_entry->dev, share_entry->inode, share_entry->share_file_id);
1261
1262                         /* Paranoia check... */
1263                         if(new_fsp == NULL) {
1264                                 DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is not a local file !\n", i ));
1265                                 unlock_share_entry(fsp->conn, fsp->dev, fsp->inode);
1266                                 abort();
1267                         }
1268
1269                         DEBUG(10,("release_level_2_oplocks_on_change: breaking our own oplock.\n"));
1270
1271                         oplock_break_level2(new_fsp, True);
1272
1273                 } else {
1274
1275                         /*
1276                          * This is a remote file and so we send an asynchronous
1277                          * message.
1278                          */
1279
1280                         DEBUG(10,("release_level_2_oplocks_on_change: breaking remote oplock (async).\n"));
1281                         request_remote_level2_async_oplock_break(share_entry);
1282                 }
1283         }
1284
1285         SAFE_FREE(share_list);
1286         unlock_share_entry_fsp(fsp);
1287
1288         /* Paranoia check... */
1289         if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type)) {
1290                 DEBUG(0,("release_level_2_oplocks_on_change: PANIC. File %s still has a level II oplock.\n", fsp->fsp_name));
1291                 smb_panic("release_level_2_oplocks_on_change");
1292         }
1293 }
1294
1295 /****************************************************************************
1296  Send a 'retry your open' message to a process with a deferred open entry.
1297 ****************************************************************************/
1298
1299 BOOL send_deferred_open_retry_message(deferred_open_entry *entry)
1300 {
1301         char de_msg[DEFERRED_OPEN_MSG_LEN];
1302         struct sockaddr_in addr_out;
1303         pid_t pid = sys_getpid();
1304
1305         memset(de_msg, '\0', DEFERRED_OPEN_MSG_LEN);
1306         SSVAL(de_msg,DEFERRED_OPEN_CMD_OFFSET,RETRY_DEFERRED_OPEN_CMD);
1307         memcpy(de_msg+DEFERRED_OPEN_PID_OFFSET,(char *)&pid,sizeof(pid));
1308         memcpy(de_msg+DEFERRED_OPEN_DEV_OFFSET,(char *)&entry->dev,sizeof(entry->dev));
1309         memcpy(de_msg+DEFERRED_OPEN_INODE_OFFSET,(char *)&entry->inode,sizeof(entry->inode));
1310         memcpy(de_msg+DEFERRED_OPEN_MID_OFFSET,(char *)&entry->mid,sizeof(entry->mid));
1311
1312         /* Set the address and port. */
1313         memset((char *)&addr_out,'\0',sizeof(addr_out));
1314         addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1315         addr_out.sin_port = htons( entry->port );
1316         addr_out.sin_family = AF_INET;
1317
1318         if( DEBUGLVL( 3 ) ) {
1319                 dbgtext( "send_deferred_open_retry_message: sending a message to ");
1320                 dbgtext( "pid %d on port %d ", (int)entry->pid, entry->port );
1321                 dbgtext( "for dev = %x, inode = %.0f, mid = %u\n",
1322                         (unsigned int)entry->dev, (double)entry->inode, (unsigned int)entry->mid );
1323         }
1324
1325         if(sys_sendto(oplock_sock,de_msg,DEFERRED_OPEN_MSG_LEN,0,
1326                         (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0) {
1327                 if( DEBUGLVL( 0 ) ) {
1328                         dbgtext( "send_deferred_open_retry_message: failed sending a message to ");
1329                         dbgtext( "pid %d on port %d ", (int)entry->pid, entry->port );
1330                         dbgtext( "for dev = %x, inode = %.0f, mid = %u\n",
1331                                 (unsigned int)entry->dev, (double)entry->inode, (unsigned int)entry->mid );
1332                         dbgtext( "Error was %s\n", strerror(errno) );
1333                 }
1334                 return False;
1335         }
1336         return True;
1337 }
1338
1339 /****************************************************************************
1340  Setup oplocks for this process.
1341 ****************************************************************************/
1342
1343 BOOL init_oplocks(void)
1344 {
1345         struct sockaddr_in sock_name;
1346         socklen_t len = sizeof(sock_name);
1347
1348         DEBUG(3,("open_oplock_ipc: opening loopback UDP socket.\n"));
1349
1350         /* Open a lookback UDP socket on a random port. */
1351         oplock_sock = open_socket_in(SOCK_DGRAM, 0, 0, htonl(INADDR_LOOPBACK),False);
1352         if (oplock_sock == -1) {
1353                 DEBUG(0,("open_oplock_ipc: Failed to get local UDP socket for \
1354 address %lx. Error was %s\n", (long)htonl(INADDR_LOOPBACK), strerror(errno)));
1355                 global_oplock_port = 0;
1356                 return(False);
1357         }
1358
1359         /* Find out the transient UDP port we have been allocated. */
1360         if(getsockname(oplock_sock, (struct sockaddr *)&sock_name, &len)<0) {
1361                 DEBUG(0,("open_oplock_ipc: Failed to get local UDP port. Error was %s\n",
1362                          strerror(errno)));
1363                 close(oplock_sock);
1364                 oplock_sock = -1;
1365                 global_oplock_port = 0;
1366                 return False;
1367         }
1368         global_oplock_port = ntohs(sock_name.sin_port);
1369
1370         if (lp_kernel_oplocks()) {
1371 #if HAVE_KERNEL_OPLOCKS_IRIX
1372                 koplocks = irix_init_kernel_oplocks();
1373 #elif HAVE_KERNEL_OPLOCKS_LINUX
1374                 koplocks = linux_init_kernel_oplocks();
1375 #endif
1376         }
1377
1378         DEBUG(3,("open_oplock ipc: pid = %d, global_oplock_port = %u\n",
1379                  (int)sys_getpid(), global_oplock_port));
1380
1381         return True;
1382 }