source/smbd/blocking.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Blocking Locking functions
   5    Copyright (C) Jeremy Allison 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 extern int DEBUGLEVEL;
  24 extern int Client;
  25 extern int chain_size;
  26 extern char *OutBuffer;
  27
  28 /****************************************************************************
  29  This is the structure to queue to implement blocking locks.
  30  notify. It consists of the requesting SMB and the expiry time.
  31 *****************************************************************************/
  32
  33 typedef struct {
  34   ubi_slNode msg_next;
  35   int com_type;
  36   files_struct *fsp;
  37   time_t expire_time;
  38   int lock_num;
  39   char *inbuf;
  40   int length;
  41 } blocking_lock_record;
  42
  43 static ubi_slList blocking_lock_queue = { NULL, (ubi_slNodePtr)&blocking_lock_queue, 0};
  44
  45 /****************************************************************************
  46  Destructor for the above structure.
  47 ****************************************************************************/
  48
  49 static void free_blocking_lock_record(blocking_lock_record *blr)
  50 {
  51   free(blr->inbuf);
  52   free((char *)blr);
  53 }
  54
  55 /****************************************************************************
  56  Get the files_struct given a particular queued SMB.
  57 *****************************************************************************/
  58
  59 static files_struct *get_fsp_from_pkt(char *inbuf)
  60 {
  61   switch(CVAL(inbuf,smb_com)) {
  62   case SMBlock:
  63   case SMBlockread:
  64     return file_fsp(inbuf,smb_vwv0);
  65   case SMBlockingX:
  66     return file_fsp(inbuf,smb_vwv2);
  67   default:
  68     DEBUG(0,("get_fsp_from_pkt: PANIC - unknown type on blocking lock queue - exiting.!\n"));
  69     exit_server("PANIC - unknown type on blocking lock queue");
  70   }
  71   return NULL; /* Keep compiler happy. */
  72 }
  73
  74 /****************************************************************************
  75  Determine if this is a secondary element of a chained SMB.
  76   **************************************************************************/
  77
  78 static BOOL in_chained_smb(void)
  79 {
  80   return (chain_size != 0);
  81 }
  82
  83 /****************************************************************************
  84  Function to push a blocking lock request onto the lock queue.
  85 ****************************************************************************/
  86
  87 BOOL push_blocking_lock_request( char *inbuf, int length, int lock_timeout, int lock_num)
  88 {
  89   blocking_lock_record *blr;
  90
  91   if(in_chained_smb() ) {
  92     DEBUG(0,("push_blocking_lock_request: cannot queue a chained request (currently).\n"));
  93     return False;
  94   }
  95
  96   /*
  97    * Now queue an entry on the blocking lock queue. We setup
  98    * the expiration time here.
  99    */
 100
 101   if((blr = (blocking_lock_record *)malloc(sizeof(blocking_lock_record))) == NULL) {
 102     DEBUG(0,("push_blocking_lock_request: Malloc fail !\n" ));
 103     return False;
 104   }
 105
 106   if((blr->inbuf = (char *)malloc(length)) == NULL) {
 107     DEBUG(0,("push_blocking_lock_request: Malloc fail (2)!\n" ));
 108     free((char *)blr);
 109     return False;
 110   }
 111
 112   blr->com_type = CVAL(inbuf,smb_com);
 113   blr->fsp = get_fsp_from_pkt(inbuf);
 114   blr->expire_time = (lock_timeout == -1) ? (time_t)-1 : time(NULL) + (time_t)lock_timeout;
 115   blr->lock_num = lock_num;
 116   memcpy(blr->inbuf, inbuf, length);
 117   blr->length = length;
 118
 119   ubi_slAddTail(&blocking_lock_queue, blr);
 120
 121
 122   DEBUG(3,("push_blocking_lock_request: lock request length=%d blocked with expiry time %d \
 123 for fnum = %d, name = %s\n", length, (int)blr->expire_time,
 124         blr->fsp->fnum, blr->fsp->fsp_name ));
 125
 126   return True;
 127 }
 128
 129 /****************************************************************************
 130  Return a smd with a given size.
 131 *****************************************************************************/
 132
 133 static void send_blocking_reply(char *outbuf, int outsize)
 134 {
 135   if(outsize > 4)
 136     smb_setlen(outbuf,outsize - 4);
 137
 138   send_smb(Client,outbuf);
 139 }
 140
 141 /****************************************************************************
 142  Return a lockingX success SMB.
 143 *****************************************************************************/
 144
 145 static void reply_lockingX_success(blocking_lock_record *blr)
 146 {
 147   char *outbuf = OutBuffer;
 148   int bufsize = BUFFER_SIZE;
 149   char *inbuf = blr->inbuf;
 150   int outsize = 0;
 151
 152   construct_reply_common(inbuf, outbuf);
 153   set_message(outbuf,2,0,True);
 154
 155   /*
 156    * As this message is a lockingX call we must handle
 157    * any following chained message correctly.
 158    * This is normally handled in construct_reply(),
 159    * but as that calls switch_message, we can't use
 160    * that here and must set up the chain info manually.
 161    */
 162
 163   outsize = chain_reply(inbuf,outbuf,blr->length,bufsize);
 164
 165   outsize += chain_size;
 166
 167   send_blocking_reply(outbuf,outsize);
 168 }
 169
 170 /****************************************************************************
 171  Return a generic lock fail error blocking call.
 172 *****************************************************************************/
 173
 174 static void generic_blocking_lock_error(blocking_lock_record *blr, int eclass, int32 ecode)
 175 {
 176   char *outbuf = OutBuffer;
 177   char *inbuf = blr->inbuf;
 178   construct_reply_common(inbuf, outbuf);
 179
 180   if(eclass == 0) /* NT Error. */
 181     SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2) | FLAGS2_32_BIT_ERROR_CODES);
 182
 183   ERROR(eclass,ecode);
 184   send_smb(Client,outbuf);
 185 }
 186
 187 /****************************************************************************
 188  Return a lock fail error for a lockingX call. Undo all the locks we have
 189  obtained first.
 190 *****************************************************************************/
 191
 192 static void reply_lockingX_error(blocking_lock_record *blr, int eclass, int32 ecode)
 193 {
 194   char *inbuf = blr->inbuf;
 195   files_struct *fsp = blr->fsp;
 196   connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
 197   uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
 198   SMB_OFF_T count = (SMB_OFF_T) 0, offset = (SMB_OFF_T) 0;
 199   unsigned char locktype = CVAL(inbuf,smb_vwv3);
 200   BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
 201   char *data;
 202   int i;
 203
 204   data = smb_buf(inbuf) + ((large_file_format ? 20 : 10)*num_ulocks);
 205
 206   /*
 207    * Data now points at the beginning of the list
 208    * of smb_lkrng structs.
 209    */
 210
 211   for(i = blr->lock_num; i >= 0; i--) {
 212     int dummy1;
 213     uint32 dummy2;
 214     BOOL err;
 215
 216     count = get_lock_count( data, i, large_file_format, &err);
 217     offset = get_lock_offset( data, i, large_file_format, &err);
 218
 219     /*
 220      * We know err cannot be set as if it was the lock
 221      * request would never have been queued. JRA.
 222      */
 223
 224     do_unlock(fsp,conn,count,offset,&dummy1,&dummy2);
 225   }
 226
 227   generic_blocking_lock_error(blr, eclass, ecode);
 228 }
 229
 230 /****************************************************************************
 231  Return a lock fail error.
 232 *****************************************************************************/
 233
 234 static void blocking_lock_reply_error(blocking_lock_record *blr, int eclass, int32 ecode)
 235 {
 236   switch(blr->com_type) {
 237   case SMBlock:
 238     generic_blocking_lock_error(blr, eclass, ecode);
 239     break;
 240   case SMBlockread:
 241     generic_blocking_lock_error(blr, eclass, ecode);
 242     break;
 243   case SMBlockingX:
 244     reply_lockingX_error(blr, eclass, ecode);
 245     break;
 246   default:
 247     DEBUG(0,("blocking_lock_reply_error: PANIC - unknown type on blocking lock queue - exiting.!\n"));
 248     exit_server("PANIC - unknown type on blocking lock queue");
 249   }
 250 }
 251
 252 /****************************************************************************
 253  Attempt to finish off getting all pending blocking locks for a lockread call.
 254  Returns True if we want to be removed from the list.
 255 *****************************************************************************/
 256
 257 static BOOL process_lockread(blocking_lock_record *blr)
 258 {
 259   char *outbuf = OutBuffer;
 260   char *inbuf = blr->inbuf;
 261   ssize_t nread = -1;
 262   char *data;
 263   int outsize = 0;
 264   SMB_OFF_T startpos;
 265   size_t numtoread;
 266   int eclass;
 267   uint32 ecode;
 268   connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
 269   files_struct *fsp = blr->fsp;
 270
 271   numtoread = SVAL(inbuf,smb_vwv1);
 272   startpos = IVAL(inbuf,smb_vwv2);
 273
 274   numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
 275   data = smb_buf(outbuf) + 3;
 276
 277   if(!do_lock( fsp, conn, numtoread, startpos, F_RDLCK, &eclass, &ecode)) {
 278     if((errno != EACCES) && (errno != EAGAIN)) {
 279       /*
 280        * We have other than a "can't get lock" POSIX
 281        * error. Send an error.
 282        * Return True so we get dequeued.
 283        */
 284
 285       generic_blocking_lock_error(blr, eclass, ecode);
 286       return True;
 287     }
 288
 289     /*
 290      * Still waiting for lock....
 291      */
 292
 293     DEBUG(10,("process_lockread: failed to get lock for file = %s. Still waiting....\n",
 294           fsp->fsp_name));
 295     return False;
 296   }
 297
 298   nread = read_file(fsp,data,startpos,numtoread);
 299
 300   if (nread < 0) {
 301     generic_blocking_lock_error(blr,ERRDOS,ERRnoaccess);
 302     return True;
 303   }
 304
 305   construct_reply_common(inbuf, outbuf);
 306   outsize = set_message(outbuf,5,3,True);
 307
 308   outsize += nread;
 309   SSVAL(outbuf,smb_vwv0,nread);
 310   SSVAL(outbuf,smb_vwv5,nread+3);
 311   SSVAL(smb_buf(outbuf),1,nread);
 312
 313   DEBUG(3, ( "process_lockread file = %s, fnum=%d num=%d nread=%d\n",
 314         fsp->fsp_name, fsp->fnum, (int)numtoread, (int)nread ) );
 315
 316   send_blocking_reply(outbuf,outsize);
 317   return True;
 318 }
 319
 320 /****************************************************************************
 321  Attempt to finish off getting all pending blocking locks for a lock call.
 322  Returns True if we want to be removed from the list.
 323 *****************************************************************************/
 324
 325 static BOOL process_lock(blocking_lock_record *blr)
 326 {
 327   char *outbuf = OutBuffer;
 328   char *inbuf = blr->inbuf;
 329   int outsize;
 330   SMB_OFF_T count = 0, offset = 0;
 331   int eclass;
 332   uint32 ecode;
 333   connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
 334   files_struct *fsp = blr->fsp;
 335
 336   count = IVAL(inbuf,smb_vwv1);
 337   offset = IVAL(inbuf,smb_vwv3);
 338
 339   errno = 0;
 340   if (!do_lock(fsp, conn, count, offset, F_WRLCK, &eclass, &ecode)) {
 341     if((errno != EACCES) && (errno != EAGAIN)) {
 342
 343       /*
 344        * We have other than a "can't get lock" POSIX
 345        * error. Send an error.
 346        * Return True so we get dequeued.
 347        */
 348
 349       blocking_lock_reply_error(blr, eclass, ecode);
 350       return True;
 351     }
 352
 353     /*
 354      * Still can't get the lock - keep waiting.
 355      */
 356
 357     DEBUG(10,("process_lock: failed to get lock for file = %s. Still waiting....\n",
 358           fsp->fsp_name));
 359     return False;
 360   }
 361
 362   /*
 363    * Success - we got the lock.
 364    */
 365
 366   DEBUG(3,("process_lock : file=%s fnum=%d offset=%.0f count=%.0f\n",
 367        fsp->fsp_name, fsp->fnum, (double)offset, (double)count));
 368
 369   construct_reply_common(inbuf, outbuf);
 370   outsize = set_message(outbuf,0,0,True);
 371   send_blocking_reply(outbuf,outsize);
 372   return True;
 373 }
 374
 375 /****************************************************************************
 376  Attempt to finish off getting all pending blocking locks for a lockingX call.
 377  Returns True if we want to be removed from the list.
 378 *****************************************************************************/
 379
 380 static BOOL process_lockingX(blocking_lock_record *blr)
 381 {
 382   char *inbuf = blr->inbuf;
 383   unsigned char locktype = CVAL(inbuf,smb_vwv3);
 384   files_struct *fsp = blr->fsp;
 385   connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
 386   uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
 387   uint16 num_locks = SVAL(inbuf,smb_vwv7);
 388   SMB_OFF_T count = 0, offset = 0;
 389   BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
 390   char *data;
 391   int eclass=0;
 392   uint32 ecode=0;
 393
 394   data = smb_buf(inbuf) + ((large_file_format ? 20 : 10)*num_ulocks);
 395
 396   /*
 397    * Data now points at the beginning of the list
 398    * of smb_lkrng structs.
 399    */
 400
 401   for(; blr->lock_num < num_locks; blr->lock_num++) {
 402     BOOL err;
 403
 404     count = get_lock_count( data, blr->lock_num, large_file_format, &err);
 405     offset = get_lock_offset( data, blr->lock_num, large_file_format, &err);
 406
 407     /*
 408      * We know err cannot be set as if it was the lock
 409      * request would never have been queued. JRA.
 410      */
 411     errno = 0;
 412     if(!do_lock(fsp,conn,count,offset, ((locktype & 1) ? F_RDLCK : F_WRLCK),
 413                 &eclass, &ecode))
 414       break;
 415   }
 416
 417   if(blr->lock_num == num_locks) {
 418
 419     /*
 420      * Success - we got all the locks.
 421      */
 422
 423     DEBUG(3,("process_lockingX file = %s, fnum=%d type=%d num_locks=%d\n",
 424           fsp->fsp_name, fsp->fnum, (unsigned int)locktype, num_locks) );
 425
 426     reply_lockingX_success(blr);
 427     return True;
 428
 429   } else if((errno != EACCES) && (errno != EAGAIN)) {
 430
 431     /*
 432      * We have other than a "can't get lock" POSIX
 433      * error. Free any locks we had and return an error.
 434      * Return True so we get dequeued.
 435      */
 436
 437     blocking_lock_reply_error(blr, eclass, ecode);
 438     return True;
 439   }
 440
 441   /*
 442    * Still can't get all the locks - keep waiting.
 443    */
 444
 445   DEBUG(10,("process_lockingX: only got %d locks of %d needed for file %s, fnum = %d. \
 446 Waiting....\n", blr->lock_num, num_locks, fsp->fsp_name, fsp->fnum));
 447
 448   return False;
 449 }
 450
 451 /****************************************************************************
 452  Process a blocking lock SMB.
 453  Returns True if we want to be removed from the list.
 454 *****************************************************************************/
 455
 456 static BOOL blocking_lock_record_process(blocking_lock_record *blr)
 457 {
 458   switch(blr->com_type) {
 459   case SMBlock:
 460     return process_lock(blr);
 461   case SMBlockread:
 462     return process_lockread(blr);
 463   case SMBlockingX:
 464     return process_lockingX(blr);
 465   default:
 466     DEBUG(0,("blocking_lock_record_process: PANIC - unknown type on blocking lock queue - exiting.!\n"));
 467     exit_server("PANIC - unknown type on blocking lock queue");
 468   }
 469   return False; /* Keep compiler happy. */
 470 }
 471
 472 /****************************************************************************
 473  Delete entries by fnum from the blocking lock pending queue.
 474 *****************************************************************************/
 475
 476 void remove_pending_lock_requests_by_fid(files_struct *fsp)
 477 {
 478   blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
 479   blocking_lock_record *prev = NULL;
 480
 481   while(blr != NULL) {
 482     if(blr->fsp->fnum == fsp->fnum) {
 483
 484       DEBUG(10,("remove_pending_lock_requests_by_fid - removing request type %d for \
 485 file %s fnum = %d\n", blr->com_type, fsp->fsp_name, fsp->fnum ));
 486
 487       free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
 488       blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
 489       continue;
 490     }
 491
 492     prev = blr;
 493     blr = (blocking_lock_record *)ubi_slNext(blr);
 494   }
 495 }
 496
 497 /****************************************************************************
 498  Delete entries by mid from the blocking lock pending queue. Always send reply.
 499 *****************************************************************************/
 500
 501 void remove_pending_lock_requests_by_mid(int mid)
 502 {
 503   blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
 504   blocking_lock_record *prev = NULL;
 505
 506   while(blr != NULL) {
 507     if(SVAL(blr->inbuf,smb_mid) == mid) {
 508       files_struct *fsp = blr->fsp;
 509
 510       DEBUG(10,("remove_pending_lock_requests_by_mid - removing request type %d for \
 511 file %s fnum = %d\n", blr->com_type, fsp->fsp_name, fsp->fnum ));
 512
 513       blocking_lock_reply_error(blr,0,NT_STATUS_CANCELLED);
 514       free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
 515       blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
 516       continue;
 517     }
 518
 519     prev = blr;
 520     blr = (blocking_lock_record *)ubi_slNext(blr);
 521   }
 522 }
 523
 524 /****************************************************************************
 525  Return True if the blocking lock queue has entries.
 526 *****************************************************************************/
 527
 528 BOOL blocking_locks_pending(void)
 529 {
 530   blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
 531   return (blr == NULL ? False : True);
 532 }
 533
 534 /****************************************************************************
 535  Process the blocking lock queue. Note that this is only called as root.
 536 *****************************************************************************/
 537
 538 void process_blocking_lock_queue(time_t t)
 539 {
 540   blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
 541   blocking_lock_record *prev = NULL;
 542
 543   if(blr == NULL)
 544     return;
 545
 546   /*
 547    * Go through the queue and see if we can get any of the locks.
 548    */
 549
 550   while(blr != NULL) {
 551     connection_struct *conn = NULL;
 552     uint16 vuid;
 553     files_struct *fsp = NULL;
 554
 555     /*
 556      * Ensure we don't have any old chain_fsp values
 557      * sitting around....
 558      */
 559     chain_size = 0;
 560     file_chain_reset();
 561     fsp = blr->fsp;
 562
 563     conn = conn_find(SVAL(blr->inbuf,smb_tid));
 564     vuid = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID :
 565                   SVAL(blr->inbuf,smb_uid);
 566
 567     DEBUG(5,("process_blocking_lock_queue: examining pending lock fnum = %d for file %s\n",
 568           fsp->fnum, fsp->fsp_name ));
 569
 570     if((blr->expire_time != -1) && (blr->expire_time > t)) {
 571       /*
 572        * Lock expired - throw away all previously
 573        * obtained locks and return lock error.
 574        */
 575       DEBUG(5,("process_blocking_lock_queue: pending lock fnum = %d for file %s timed out.\n",
 576           fsp->fnum, fsp->fsp_name ));
 577
 578       blocking_lock_reply_error(blr,ERRSRV,ERRaccess);
 579       free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
 580       blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
 581       continue;
 582     }
 583
 584     if(!become_user(conn,vuid)) {
 585       DEBUG(0,("process_blocking_lock_queue: Unable to become user vuid=%d.\n",
 586             vuid ));
 587       /*
 588        * Remove the entry and return an error to the client.
 589        */
 590       blocking_lock_reply_error(blr,ERRSRV,ERRaccess);
 591       free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
 592       blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
 593       continue;
 594     }
 595
 596     if(!become_service(conn,True)) {
 597       DEBUG(0,("process_blocking_lock_queue: Unable to become service Error was %s.\n", strerror(errno) ));
 598       /*
 599        * Remove the entry and return an error to the client.
 600        */
 601       blocking_lock_reply_error(blr,ERRSRV,ERRaccess);
 602       free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
 603       blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
 604       unbecome_user();
 605       continue;
 606     }
 607
 608     /*
 609      * Go through the remaining locks and try and obtain them.
 610      * The call returns True if all locks were obtained successfully
 611      * and False if we still need to wait.
 612      */
 613
 614     if(blocking_lock_record_process(blr)) {
 615       free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
 616       blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
 617       unbecome_user();
 618       continue;
 619     }
 620
 621     unbecome_user();
 622
 623     /*
 624      * Move to the next in the list.
 625      */
 626     prev = blr;
 627     blr = (blocking_lock_record *)ubi_slNext(blr);
 628   }
 629 }