source3/smbd/oplock.c

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