source3/smbd/nttrans.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    SMB NT transaction handling
   5    Copyright (C) Jeremy Allison 1994-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 #include "nterr.h"
  24
  25 extern int DEBUGLEVEL;
  26 extern int Protocol;
  27 extern int Client;
  28 extern int smb_read_error;
  29 extern int global_oplock_break;
  30 extern int chain_size;
  31 extern BOOL case_sensitive;
  32 extern BOOL case_preserve;
  33 extern BOOL short_case_preserve;
  34
  35 static void remove_pending_change_notify_requests_by_mid(int mid);
  36
  37 static char *known_nt_pipes[] = {
  38   "\\LANMAN",
  39   "\\srvsvc",
  40   "\\samr",
  41   "\\wkssvc",
  42   "\\NETLOGON",
  43   "\\ntlsa",
  44   "\\ntsvcs",
  45   "\\lsass",
  46   "\\lsarpc",
  47   "\\winreg",
  48   NULL
  49 };
  50
  51 /****************************************************************************
  52  Send the required number of replies back.
  53  We assume all fields other than the data fields are
  54  set correctly for the type of call.
  55  HACK ! Always assumes smb_setup field is zero.
  56 ****************************************************************************/
  57
  58 static int send_nt_replies(char *inbuf, char *outbuf, int bufsize, uint32 nt_error, char *params,
  59                            int paramsize, char *pdata, int datasize)
  60 {
  61   extern int max_send;
  62   int data_to_send = datasize;
  63   int params_to_send = paramsize;
  64   int useable_space;
  65   char *pp = params;
  66   char *pd = pdata;
  67   int params_sent_thistime, data_sent_thistime, total_sent_thistime;
  68   int alignment_offset = 3;
  69   int data_alignment_offset = 0;
  70
  71   /*
  72    * Initially set the wcnt area to be 18 - this is true for all
  73    * transNT replies.
  74    */
  75
  76   set_message(outbuf,18,0,True);
  77
  78   if(nt_error != 0) {
  79     /* NT Error. */
  80     SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2) | FLAGS2_32_BIT_ERROR_CODES);
  81
  82     ERROR(0,nt_error);
  83   }
  84
  85   /*
  86    * If there genuinely are no parameters or data to send just send
  87    * the empty packet.
  88    */
  89
  90   if(params_to_send == 0 && data_to_send == 0) {
  91     send_smb(Client,outbuf);
  92     return 0;
  93   }
  94
  95   /*
  96    * When sending params and data ensure that both are nicely aligned.
  97    * Only do this alignment when there is also data to send - else
  98    * can cause NT redirector problems.
  99    */
 100
 101   if (((params_to_send % 4) != 0) && (data_to_send != 0))
 102     data_alignment_offset = 4 - (params_to_send % 4);
 103
 104   /*
 105    * Space is bufsize minus Netbios over TCP header minus SMB header.
 106    * The alignment_offset is to align the param bytes on a four byte
 107    * boundary (2 bytes for data len, one byte pad).
 108    * NT needs this to work correctly.
 109    */
 110
 111   useable_space = bufsize - ((smb_buf(outbuf)+
 112                     alignment_offset+data_alignment_offset) -
 113                     outbuf);
 114
 115   /*
 116    * useable_space can never be more than max_send minus the
 117    * alignment offset.
 118    */
 119
 120   useable_space = MIN(useable_space,
 121                       max_send - (alignment_offset+data_alignment_offset));
 122
 123
 124   while (params_to_send || data_to_send) {
 125
 126     /*
 127      * Calculate whether we will totally or partially fill this packet.
 128      */
 129
 130     total_sent_thistime = params_to_send + data_to_send +
 131                             alignment_offset + data_alignment_offset;
 132
 133     /*
 134      * We can never send more than useable_space.
 135      */
 136
 137     total_sent_thistime = MIN(total_sent_thistime, useable_space);
 138
 139     set_message(outbuf, 18, total_sent_thistime, True);
 140
 141     /*
 142      * Set total params and data to be sent.
 143      */
 144
 145     SIVAL(outbuf,smb_ntr_TotalParameterCount,paramsize);
 146     SIVAL(outbuf,smb_ntr_TotalDataCount,datasize);
 147
 148     /*
 149      * Calculate how many parameters and data we can fit into
 150      * this packet. Parameters get precedence.
 151      */
 152
 153     params_sent_thistime = MIN(params_to_send,useable_space);
 154     data_sent_thistime = useable_space - params_sent_thistime;
 155     data_sent_thistime = MIN(data_sent_thistime,data_to_send);
 156
 157     SIVAL(outbuf,smb_ntr_ParameterCount,params_sent_thistime);
 158
 159     if(params_sent_thistime == 0) {
 160       SIVAL(outbuf,smb_ntr_ParameterOffset,0);
 161       SIVAL(outbuf,smb_ntr_ParameterDisplacement,0);
 162     } else {
 163       /*
 164        * smb_ntr_ParameterOffset is the offset from the start of the SMB header to the
 165        * parameter bytes, however the first 4 bytes of outbuf are
 166        * the Netbios over TCP header. Thus use smb_base() to subtract
 167        * them from the calculation.
 168        */
 169
 170       SIVAL(outbuf,smb_ntr_ParameterOffset,
 171             ((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
 172       /*
 173        * Absolute displacement of param bytes sent in this packet.
 174        */
 175
 176       SIVAL(outbuf,smb_ntr_ParameterDisplacement,pp - params);
 177     }
 178
 179     /*
 180      * Deal with the data portion.
 181      */
 182
 183     SIVAL(outbuf,smb_ntr_DataCount, data_sent_thistime);
 184
 185     if(data_sent_thistime == 0) {
 186       SIVAL(outbuf,smb_ntr_DataOffset,0);
 187       SIVAL(outbuf,smb_ntr_DataDisplacement, 0);
 188     } else {
 189       /*
 190        * The offset of the data bytes is the offset of the
 191        * parameter bytes plus the number of parameters being sent this time.
 192        */
 193
 194       SIVAL(outbuf,smb_ntr_DataOffset,((smb_buf(outbuf)+alignment_offset) -
 195             smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
 196       SIVAL(outbuf,smb_ntr_DataDisplacement, pd - pdata);
 197     }
 198
 199     /*
 200      * Copy the param bytes into the packet.
 201      */
 202
 203     if(params_sent_thistime)
 204       memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
 205
 206     /*
 207      * Copy in the data bytes
 208      */
 209
 210     if(data_sent_thistime)
 211       memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
 212              data_alignment_offset,pd,data_sent_thistime);
 213
 214     DEBUG(9,("nt_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
 215           params_sent_thistime, data_sent_thistime, useable_space));
 216     DEBUG(9,("nt_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
 217           params_to_send, data_to_send, paramsize, datasize));
 218
 219     /* Send the packet */
 220     send_smb(Client,outbuf);
 221
 222     pp += params_sent_thistime;
 223     pd += data_sent_thistime;
 224
 225     params_to_send -= params_sent_thistime;
 226     data_to_send -= data_sent_thistime;
 227
 228     /*
 229      * Sanity check
 230      */
 231
 232     if(params_to_send < 0 || data_to_send < 0) {
 233       DEBUG(0,("send_nt_replies failed sanity check pts = %d, dts = %d\n!!!",
 234             params_to_send, data_to_send));
 235       return -1;
 236     }
 237   }
 238
 239   return 0;
 240 }
 241
 242 /****************************************************************************
 243  (Hopefully) temporary call to fix bugs in NT5.0beta2. This OS sends unicode
 244  strings in NT calls AND DOESN'T SET THE UNICODE BIT !!!!!!!
 245 ****************************************************************************/
 246
 247 static void my_wcstombs(char *dst, uint16 *src, size_t len)
 248 {
 249   size_t i;
 250
 251   for(i = 0; i < len; i++)
 252     dst[i] = (char)SVAL(src,i*2);
 253 }
 254
 255 static void get_filename( char *fname, char *inbuf, int data_offset, int data_len, int fname_len)
 256 {
 257   if(data_len - fname_len > 1) {
 258     /*
 259      * NT 5.0 Beta 2 has kindly sent us a UNICODE string
 260      * without bothering to set the unicode bit. How kind.
 261      *
 262      * Firstly - ensure that the data offset is aligned
 263      * on a 2 byte boundary - add one if not.
 264      */
 265     fname_len = fname_len/2;
 266     if(data_offset & 1)
 267       data_offset++;
 268     my_wcstombs( fname, (uint16 *)(inbuf+data_offset), fname_len);
 269   } else {
 270     StrnCpy(fname,inbuf+data_offset,fname_len);
 271   }
 272   fname[fname_len] = '\0';
 273 }
 274
 275 /****************************************************************************
 276  Save case statics.
 277 ****************************************************************************/
 278
 279 static BOOL saved_case_sensitive;
 280 static BOOL saved_case_preserve;
 281 static BOOL saved_short_case_preserve;
 282
 283 /****************************************************************************
 284  Save case semantics.
 285 ****************************************************************************/
 286
 287 static void set_posix_case_semantics(uint32 file_attributes)
 288 {
 289   if(!(file_attributes & FILE_FLAG_POSIX_SEMANTICS))
 290     return;
 291
 292   saved_case_sensitive = case_sensitive;
 293   saved_case_preserve = case_preserve;
 294   saved_short_case_preserve = short_case_preserve;
 295
 296   /* Set to POSIX. */
 297   case_sensitive = True;
 298   case_preserve = True;
 299   short_case_preserve = True;
 300 }
 301
 302 /****************************************************************************
 303  Restore case semantics.
 304 ****************************************************************************/
 305
 306 static void restore_case_semantics(uint32 file_attributes)
 307 {
 308   if(!(file_attributes & FILE_FLAG_POSIX_SEMANTICS))
 309     return;
 310
 311   case_sensitive = saved_case_sensitive;
 312   case_preserve = saved_case_preserve;
 313   short_case_preserve = saved_short_case_preserve;
 314 }
 315
 316 /****************************************************************************
 317  Utility function to map create disposition.
 318 ****************************************************************************/
 319
 320 static int map_create_disposition( uint32 create_disposition)
 321 {
 322   int ret;
 323
 324   switch( create_disposition ) {
 325   case FILE_CREATE:
 326     /* create if not exist, fail if exist */
 327     ret = (FILE_CREATE_IF_NOT_EXIST|FILE_EXISTS_FAIL);
 328     break;
 329   case FILE_SUPERSEDE:
 330   case FILE_OVERWRITE_IF:
 331     /* create if not exist, trunc if exist */
 332     ret = (FILE_CREATE_IF_NOT_EXIST|FILE_EXISTS_TRUNCATE);
 333     break;
 334   case FILE_OPEN:
 335     /* fail if not exist, open if exists */
 336     ret = (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN);
 337     break;
 338   case FILE_OPEN_IF:
 339     /* create if not exist, open if exists */
 340     ret = (FILE_CREATE_IF_NOT_EXIST|FILE_EXISTS_OPEN);
 341     break;
 342   case FILE_OVERWRITE:
 343     /* fail if not exist, truncate if exists */
 344     ret = (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_TRUNCATE);
 345     break;
 346   default:
 347     DEBUG(0,("map_create_disposition: Incorrect value for create_disposition = %d\n",
 348              create_disposition ));
 349     return -1;
 350   }
 351
 352   DEBUG(10,("map_create_disposition: Mapped create_disposition %lx to %x\n",
 353         (unsigned long)create_disposition, ret ));
 354
 355   return ret;
 356 }
 357
 358 /****************************************************************************
 359  Utility function to map share modes.
 360 ****************************************************************************/
 361
 362 static int map_share_mode( BOOL *pstat_open_only, char *fname,
 363                                                         uint32 desired_access, uint32 share_access, uint32 file_attributes)
 364 {
 365   int smb_open_mode = -1;
 366
 367   *pstat_open_only = False;
 368
 369   switch( desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA) ) {
 370   case FILE_READ_DATA:
 371     smb_open_mode = DOS_OPEN_RDONLY;
 372     break;
 373   case FILE_WRITE_DATA:
 374   case FILE_APPEND_DATA:
 375   case FILE_WRITE_DATA|FILE_APPEND_DATA:
 376     smb_open_mode = DOS_OPEN_WRONLY;
 377     break;
 378   case FILE_READ_DATA|FILE_WRITE_DATA:
 379   case FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA:
 380   case FILE_READ_DATA|FILE_APPEND_DATA:
 381     smb_open_mode = DOS_OPEN_RDWR;
 382     break;
 383   }
 384
 385   /*
 386    * NB. For DELETE_ACCESS we should really check the
 387    * directory permissions, as that is what controls
 388    * delete, and for WRITE_DAC_ACCESS we should really
 389    * check the ownership, as that is what controls the
 390    * chmod. Note that this is *NOT* a security hole (this
 391    * note is for you, Andrew) as we are not *allowing*
 392    * the access at this point, the actual unlink or
 393    * chown or chmod call would do this. We are just helping
 394    * clients out by telling them if they have a hope
 395    * of any of this succeeding. POSIX acls may still
 396    * deny the real call. JRA.
 397    */
 398
 399   if (smb_open_mode == -1) {
 400         if(desired_access == WRITE_DAC_ACCESS || desired_access == READ_CONTROL_ACCESS)
 401                 *pstat_open_only = True;
 402
 403     if(desired_access & (DELETE_ACCESS|WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS|
 404                               FILE_EXECUTE|FILE_READ_ATTRIBUTES|
 405                               FILE_READ_EA|FILE_WRITE_EA|SYSTEM_SECURITY_ACCESS|
 406                               FILE_WRITE_ATTRIBUTES|READ_CONTROL_ACCESS))
 407       smb_open_mode = DOS_OPEN_RDONLY;
 408     else {
 409       DEBUG(0,("map_share_mode: Incorrect value %lx for desired_access to file %s\n",
 410              (unsigned long)desired_access, fname));
 411       return -1;
 412     }
 413   }
 414
 415   /*
 416    * Set the special bit that means allow share delete.
 417    * This is held outside the normal share mode bits at 1<<15.
 418    * JRA.
 419    */
 420
 421   if(share_access & FILE_SHARE_DELETE)
 422     smb_open_mode |= ALLOW_SHARE_DELETE;
 423
 424   /* Add in the requested share mode. */
 425   switch( share_access & (FILE_SHARE_READ|FILE_SHARE_WRITE)) {
 426   case FILE_SHARE_READ:
 427     smb_open_mode |= SET_DENY_MODE(DENY_WRITE);
 428     break;
 429   case FILE_SHARE_WRITE:
 430     smb_open_mode |= SET_DENY_MODE(DENY_READ);
 431     break;
 432   case (FILE_SHARE_READ|FILE_SHARE_WRITE):
 433     smb_open_mode |= SET_DENY_MODE(DENY_NONE);
 434     break;
 435   case FILE_SHARE_NONE:
 436     smb_open_mode |= SET_DENY_MODE(DENY_ALL);
 437     break;
 438   }
 439
 440   /*
 441    * Handle an O_SYNC request.
 442    */
 443
 444   if(file_attributes & FILE_FLAG_WRITE_THROUGH)
 445     smb_open_mode |= FILE_SYNC_OPENMODE;
 446
 447   DEBUG(10,("map_share_mode: Mapped desired access %lx, share access %lx, file attributes %lx \
 448 to open_mode %x\n", (unsigned long)desired_access, (unsigned long)share_access,
 449                     (unsigned long)file_attributes, smb_open_mode ));
 450
 451   return smb_open_mode;
 452 }
 453
 454 /*
 455  * This is a *disgusting* hack.
 456  * This is *so* bad that even I'm embarrassed (and I
 457  * have no shame). Here's the deal :
 458  * Until we get the correct SPOOLSS code into smbd
 459  * then when we're running with NT SMB support then
 460  * NT makes this call with a level of zero, and then
 461  * immediately follows it with an open request to
 462  * the \\SRVSVC pipe. If we allow that open to
 463  * succeed then NT barfs when it cannot open the
 464  * \\SPOOLSS pipe immediately after and continually
 465  * whines saying "Printer name is invalid" forever
 466  * after. If we cause *JUST THIS NEXT OPEN* of \\SRVSVC
 467  * to fail, then NT downgrades to using the downlevel code
 468  * and everything works as well as before. I hate
 469  * myself for adding this code.... JRA.
 470  *
 471  * The HACK_FAIL_TIME define allows only a 2
 472  * second window for this to occur, just in
 473  * case...
 474  */
 475
 476 static BOOL fail_next_srvsvc = False;
 477 static time_t fail_time;
 478 #define HACK_FAIL_TIME 2 /* In seconds. */
 479
 480 void fail_next_srvsvc_open(void)
 481 {
 482   /* Check client is WinNT proper; Win2K doesn't like Jeremy's hack - matty */
 483   if (get_remote_arch() != RA_WINNT)
 484     return;
 485
 486   fail_next_srvsvc = True;
 487   fail_time = time(NULL);
 488   DEBUG(10,("fail_next_srvsvc_open: setting up timeout close of \\srvsvc pipe for print fix.\n"));
 489 }
 490
 491 /*
 492  * HACK alert.... see above - JRA.
 493  */
 494
 495 BOOL should_fail_next_srvsvc_open(const char *pipename)
 496 {
 497
 498   DEBUG(10,("should_fail_next_srvsvc_open: fail = %d, pipe = %s\n",
 499     (int)fail_next_srvsvc, pipename));
 500
 501   if(fail_next_srvsvc && (time(NULL) > fail_time + HACK_FAIL_TIME)) {
 502     fail_next_srvsvc = False;
 503     fail_time = (time_t)0;
 504     DEBUG(10,("should_fail_next_srvsvc_open: End of timeout close of \\srvsvc pipe for print fix.\n"));
 505   }
 506
 507   if(fail_next_srvsvc && strequal(pipename, "srvsvc")) {
 508     fail_next_srvsvc = False;
 509     DEBUG(10,("should_fail_next_srvsvc_open: Deliberately failing open of \\srvsvc pipe for print fix.\n"));
 510     return True;
 511   }
 512   return False;
 513 }
 514
 515
 516 /****************************************************************************
 517  Reply to an NT create and X call on a pipe.
 518 ****************************************************************************/
 519 static int nt_open_pipe(char *fname, connection_struct *conn,
 520                         char *inbuf, char *outbuf, int *ppnum)
 521 {
 522         pipes_struct *p = NULL;
 523
 524         uint16 vuid = SVAL(inbuf, smb_uid);
 525         int i;
 526
 527         DEBUG(4,("nt_open_pipe: Opening pipe %s.\n", fname));
 528
 529         /* See if it is one we want to handle. */
 530         for( i = 0; known_nt_pipes[i]; i++ )
 531                 if( strequal(fname,known_nt_pipes[i]))
 532                         break;
 533
 534         if ( known_nt_pipes[i] == NULL )
 535                 return(ERROR(ERRSRV,ERRaccess));
 536
 537         /* Strip \\ off the name. */
 538         fname++;
 539
 540         if(should_fail_next_srvsvc_open(fname))
 541                 return (ERROR(ERRSRV,ERRaccess));
 542
 543         DEBUG(3,("nt_open_pipe: Known pipe %s opening.\n", fname));
 544
 545         p = open_rpc_pipe_p(fname, conn, vuid);
 546         if (!p)
 547                 return(ERROR(ERRSRV,ERRnofids));
 548
 549         *ppnum = p->pnum;
 550
 551         return 0;
 552 }
 553
 554 /****************************************************************************
 555  Reply to an NT create and X call.
 556 ****************************************************************************/
 557
 558 int reply_ntcreate_and_X(connection_struct *conn,
 559                          char *inbuf,char *outbuf,int length,int bufsize)
 560 {
 561         pstring fname;
 562         uint32 flags = IVAL(inbuf,smb_ntcreate_Flags);
 563         uint32 desired_access = IVAL(inbuf,smb_ntcreate_DesiredAccess);
 564         uint32 file_attributes = IVAL(inbuf,smb_ntcreate_FileAttributes);
 565         uint32 share_access = IVAL(inbuf,smb_ntcreate_ShareAccess);
 566         uint32 create_disposition = IVAL(inbuf,smb_ntcreate_CreateDisposition);
 567         uint32 create_options = IVAL(inbuf,smb_ntcreate_CreateOptions);
 568         uint32 fname_len = MIN(((uint32)SVAL(inbuf,smb_ntcreate_NameLength)),
 569                                ((uint32)sizeof(fname)-1));
 570         uint16 root_dir_fid = (uint16)IVAL(inbuf,smb_ntcreate_RootDirectoryFid);
 571         int smb_ofun;
 572         int smb_open_mode;
 573         int smb_attr = (file_attributes & SAMBA_ATTRIBUTES_MASK);
 574         /* Breakout the oplock request bits so we can set the
 575            reply bits separately. */
 576         int oplock_request = 0;
 577         mode_t unixmode;
 578         int pnum = -1;
 579         int fmode=0,rmode=0;
 580         SMB_OFF_T file_len = 0;
 581         SMB_STRUCT_STAT sbuf;
 582         int smb_action = 0;
 583         BOOL bad_path = False;
 584         files_struct *fsp=NULL;
 585         char *p = NULL;
 586         BOOL stat_open_only = False;
 587
 588         /*
 589          * We need to construct the open_and_X ofun value from the
 590          * NT values, as that's what our code is structured to accept.
 591          */
 592
 593         if((smb_ofun = map_create_disposition( create_disposition )) == -1)
 594                 return(ERROR(ERRDOS,ERRbadaccess));
 595
 596         /*
 597          * Get the file name.
 598          */
 599
 600     if(root_dir_fid != 0) {
 601       /*
 602        * This filename is relative to a directory fid.
 603        */
 604       files_struct *dir_fsp = file_fsp(inbuf,smb_ntcreate_RootDirectoryFid);
 605       size_t dir_name_len;
 606
 607       if(!dir_fsp)
 608         return(ERROR(ERRDOS,ERRbadfid));
 609
 610       if(!dir_fsp->is_directory) {
 611         /*
 612          * Check to see if this is a mac fork of some kind.
 613          */
 614
 615         get_filename(&fname[0], inbuf, smb_buf(inbuf)-inbuf,
 616                    smb_buflen(inbuf),fname_len);
 617
 618         if( fname[0] == ':') {
 619           SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
 620           return(ERROR(0, 0xc0000000|NT_STATUS_OBJECT_PATH_NOT_FOUND));
 621         }
 622         return(ERROR(ERRDOS,ERRbadfid));
 623       }
 624
 625       /*
 626        * Copy in the base directory name.
 627        */
 628
 629       pstrcpy( fname, dir_fsp->fsp_name );
 630       dir_name_len = strlen(fname);
 631
 632       /*
 633        * Ensure it ends in a '\'.
 634        */
 635
 636       if(fname[dir_name_len-1] != '\\' && fname[dir_name_len-1] != '/') {
 637         pstrcat(fname, "\\");
 638         dir_name_len++;
 639       }
 640
 641       if(fname_len + dir_name_len >= sizeof(pstring))
 642         return(ERROR(ERRSRV,ERRfilespecs));
 643
 644       get_filename(&fname[dir_name_len], inbuf, smb_buf(inbuf)-inbuf,
 645                    smb_buflen(inbuf),fname_len);
 646
 647     } else {
 648
 649       get_filename(fname, inbuf, smb_buf(inbuf)-inbuf,
 650                    smb_buflen(inbuf),fname_len);
 651     }
 652
 653         /* If it's an IPC, use the pipe handler. */
 654
 655         if (IS_IPC(conn) && lp_nt_pipe_support()) {
 656
 657                 int ret = nt_open_pipe(fname, conn, inbuf, outbuf, &pnum);
 658                 if(ret != 0)
 659                         return ret;
 660
 661                 /*
 662                  * Deal with pipe return.
 663                  */
 664
 665                 set_message(outbuf,34,0,True);
 666
 667                 p = outbuf + smb_vwv2;
 668                 p++;
 669                 SSVAL(p,0,pnum);
 670                 p += 2;
 671                 SIVAL(p,0,FILE_WAS_OPENED);
 672                 p += 4;
 673                 p += 32;
 674                 SIVAL(p,0,FILE_ATTRIBUTE_NORMAL); /* File Attributes. */
 675                 p += 20;
 676                 /* File type. */
 677                 SSVAL(p,0,FILE_TYPE_MESSAGE_MODE_PIPE);
 678                 /* Device state. */
 679                 SSVAL(p,2, 0x5FF); /* ? */
 680
 681                 DEBUG(5,("reply_ntcreate_and_X: open pipe = %s\n", fname));
 682
 683                 return chain_reply(inbuf,outbuf,length,bufsize);
 684         }
 685
 686         /*
 687          * Now contruct the smb_open_mode value from the filename,
 688      * desired access and the share access.
 689          */
 690
 691         if((smb_open_mode = map_share_mode(&stat_open_only, fname, desired_access,
 692                                            share_access,
 693                                            file_attributes)) == -1)
 694                 return(ERROR(ERRDOS,ERRbadaccess));
 695
 696         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
 697         oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
 698
 699         /*
 700          * Ordinary file or directory.
 701          */
 702
 703         /*
 704          * Check if POSIX semantics are wanted.
 705          */
 706
 707         set_posix_case_semantics(file_attributes);
 708
 709         unix_convert(fname,conn,0,&bad_path,NULL);
 710
 711         fsp = file_new();
 712         if (!fsp) {
 713                 restore_case_semantics(file_attributes);
 714                 return(ERROR(ERRSRV,ERRnofids));
 715         }
 716
 717         if (!check_name(fname,conn)) {
 718                 if((errno == ENOENT) && bad_path) {
 719                         unix_ERR_class = ERRDOS;
 720                         unix_ERR_code = ERRbadpath;
 721                 }
 722                 file_free(fsp);
 723
 724                 restore_case_semantics(file_attributes);
 725
 726                 return(UNIXERROR(ERRDOS,ERRnoaccess));
 727         }
 728
 729         unixmode = unix_mode(conn,smb_attr | aARCH);
 730
 731         /*
 732          * If it's a request for a directory open, deal with it separately.
 733          */
 734
 735         if(create_options & FILE_DIRECTORY_FILE) {
 736                 oplock_request = 0;
 737
 738                 open_directory(fsp, conn, fname, smb_ofun,
 739                                unixmode, &smb_action);
 740
 741                 restore_case_semantics(file_attributes);
 742
 743                 if(!fsp->open) {
 744                         file_free(fsp);
 745                         return(UNIXERROR(ERRDOS,ERRnoaccess));
 746                 }
 747         } else {
 748                 /*
 749                  * Ordinary file case.
 750                  */
 751
 752                 /* NB. We have a potential bug here. If we
 753                  * cause an oplock break to ourselves, then we
 754                  * could end up processing filename related
 755                  * SMB requests whilst we await the oplock
 756                  * break response. As we may have changed the
 757                  * filename case semantics to be POSIX-like,
 758                  * this could mean a filename request could
 759                  * fail when it should succeed. This is a rare
 760                  * condition, but eventually we must arrange
 761                  * to restore the correct case semantics
 762                  * before issuing an oplock break request to
 763                  * our client. JRA.  */
 764
 765                 open_file_shared(fsp,conn,fname,smb_open_mode,
 766                                  smb_ofun,unixmode, oplock_request,&rmode,&smb_action);
 767
 768                 if (!fsp->open) {
 769                         /* We cheat here. There are two cases we
 770                          * care about. One is a directory rename,
 771                          * where the NT client will attempt to
 772                          * open the source directory for
 773                          * DELETE access. Note that when the
 774                          * NT client does this it does *not*
 775                          * set the directory bit in the
 776                          * request packet. This is translated
 777                          * into a read/write open
 778                          * request. POSIX states that any open
 779                          * for write request on a directory
 780                          * will generate an EISDIR error, so
 781                          * we can catch this here and open a
 782                          * pseudo handle that is flagged as a
 783                          * directory. The second is an open
 784                          * for a permissions read only, which
 785                          * we handle in the open_file_stat case. JRA.
 786                          */
 787
 788                         if(errno == EISDIR) {
 789
 790                                 /*
 791                                  * Fail the open if it was explicitly a non-directory file.
 792                                  */
 793
 794                                 if (create_options & FILE_NON_DIRECTORY_FILE) {
 795                                         file_free(fsp);
 796                                         restore_case_semantics(file_attributes);
 797                                         SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
 798                                         return(ERROR(0, 0xc0000000|NT_STATUS_FILE_IS_A_DIRECTORY));
 799                                 }
 800
 801                                 oplock_request = 0;
 802                                 open_directory(fsp, conn, fname, smb_ofun, unixmode, &smb_action);
 803
 804                                 if(!fsp->open) {
 805                                         file_free(fsp);
 806                                         restore_case_semantics(file_attributes);
 807                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
 808                                 }
 809 #ifdef EROFS
 810                         } else if (((errno == EACCES) || (errno == EROFS)) && stat_open_only) {
 811 #else /* !EROFS */
 812                         } else if (errno == EACCES && stat_open_only) {
 813 #endif
 814                                 /*
 815                                  * We couldn't open normally and all we want
 816                                  * are the permissions. Try and do a stat open.
 817                                  */
 818
 819                                 oplock_request = 0;
 820
 821                                 open_file_stat(fsp,conn,fname,smb_open_mode,&sbuf,&smb_action);
 822
 823                                 if(!fsp->open) {
 824                                         file_free(fsp);
 825                                         restore_case_semantics(file_attributes);
 826                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
 827                                 }
 828
 829                         } else {
 830
 831                                 if((errno == ENOENT) && bad_path) {
 832                                         unix_ERR_class = ERRDOS;
 833                                         unix_ERR_code = ERRbadpath;
 834                                 }
 835
 836                                 file_free(fsp);
 837
 838                                 restore_case_semantics(file_attributes);
 839
 840                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
 841                         }
 842                 }
 843         }
 844
 845         if(fsp->is_directory) {
 846                 if(dos_stat(fsp->fsp_name, &sbuf) != 0) {
 847                         close_file(fsp,True);
 848                         restore_case_semantics(file_attributes);
 849                         return(ERROR(ERRDOS,ERRnoaccess));
 850                 }
 851         } else {
 852                 if (!fsp->stat_open && sys_fstat(fsp->fd_ptr->fd,&sbuf) != 0) {
 853                         close_file(fsp,False);
 854                         restore_case_semantics(file_attributes);
 855                         return(ERROR(ERRDOS,ERRnoaccess));
 856                 }
 857         }
 858
 859         restore_case_semantics(file_attributes);
 860
 861         file_len = sbuf.st_size;
 862         fmode = dos_mode(conn,fname,&sbuf);
 863         if(fmode == 0)
 864                 fmode = FILE_ATTRIBUTE_NORMAL;
 865         if (!fsp->is_directory && (fmode & aDIR)) {
 866                 close_file(fsp,False);
 867                 return(ERROR(ERRDOS,ERRnoaccess));
 868         }
 869
 870         /*
 871          * If the caller set the extended oplock request bit
 872          * and we granted one (by whatever means) - set the
 873          * correct bit for extended oplock reply.
 874          */
 875
 876         if (oplock_request && lp_fake_oplocks(SNUM(conn)))
 877                 smb_action |= EXTENDED_OPLOCK_GRANTED;
 878
 879         if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
 880                 smb_action |= EXTENDED_OPLOCK_GRANTED;
 881
 882         set_message(outbuf,34,0,True);
 883
 884         p = outbuf + smb_vwv2;
 885
 886         /*
 887          * Currently as we don't support level II oplocks we just report
 888          * exclusive & batch here.
 889          */
 890
 891     if (smb_action & EXTENDED_OPLOCK_GRANTED)
 892                 SCVAL(p,0, BATCH_OPLOCK_RETURN);
 893         else if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
 894         SCVAL(p,0, LEVEL_II_OPLOCK_RETURN);
 895         else
 896                 SCVAL(p,0,NO_OPLOCK_RETURN);
 897
 898         p++;
 899         SSVAL(p,0,fsp->fnum);
 900         p += 2;
 901         SIVAL(p,0,smb_action);
 902         p += 4;
 903
 904         /* Create time. */
 905         put_long_date(p,get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn))));
 906         p += 8;
 907         put_long_date(p,sbuf.st_atime); /* access time */
 908         p += 8;
 909         put_long_date(p,sbuf.st_mtime); /* write time */
 910         p += 8;
 911         put_long_date(p,sbuf.st_mtime); /* change time */
 912         p += 8;
 913         SIVAL(p,0,fmode); /* File Attributes. */
 914         p += 4;
 915         SOFF_T(p, 0, file_len);
 916         p += 8;
 917         SOFF_T(p,0,file_len);
 918         p += 12;
 919         SCVAL(p,0,fsp->is_directory ? 1 : 0);
 920
 921         DEBUG(5,("reply_ntcreate_and_X: fnum = %d, open name = %s\n", fsp->fnum, fsp->fsp_name));
 922
 923         return chain_reply(inbuf,outbuf,length,bufsize);
 924 }
 925
 926 /****************************************************************************
 927  Reply to a NT_TRANSACT_CREATE call (needs to process SD's).
 928 ****************************************************************************/
 929
 930 static int call_nt_transact_create(connection_struct *conn,
 931                                    char *inbuf, char *outbuf, int length,
 932                                    int bufsize,
 933                                    char **ppsetup, char **ppparams,
 934                                    char **ppdata)
 935 {
 936   pstring fname;
 937   char *params = *ppparams;
 938   uint32 flags = IVAL(params,0);
 939   uint32 desired_access = IVAL(params,8);
 940   uint32 file_attributes = IVAL(params,20);
 941   uint32 share_access = IVAL(params,24);
 942   uint32 create_disposition = IVAL(params,28);
 943   uint32 create_options = IVAL(params,32);
 944   uint32 fname_len = MIN(((uint32)IVAL(params,44)),
 945                          ((uint32)sizeof(fname)-1));
 946   uint16 root_dir_fid = (uint16)IVAL(params,4);
 947   int smb_ofun;
 948   int smb_open_mode;
 949   int smb_attr = (file_attributes & SAMBA_ATTRIBUTES_MASK);
 950   /* Breakout the oplock request bits so we can set the
 951      reply bits separately. */
 952   int oplock_request = 0;
 953   mode_t unixmode;
 954   int pnum = -1;
 955   int fmode=0,rmode=0;
 956   SMB_OFF_T file_len = 0;
 957   SMB_STRUCT_STAT sbuf;
 958   int smb_action = 0;
 959   BOOL bad_path = False;
 960   files_struct *fsp = NULL;
 961   char *p = NULL;
 962   BOOL stat_open_only = False;
 963
 964   /*
 965    * We need to construct the open_and_X ofun value from the
 966    * NT values, as that's what our code is structured to accept.
 967    */
 968
 969   if((smb_ofun = map_create_disposition( create_disposition )) == -1)
 970     return(ERROR(ERRDOS,ERRbadaccess));
 971
 972   /*
 973    * Get the file name.
 974    */
 975
 976   if(root_dir_fid != 0) {
 977     /*
 978      * This filename is relative to a directory fid.
 979      */
 980
 981     files_struct *dir_fsp = file_fsp(params,4);
 982     size_t dir_name_len;
 983
 984     if(!dir_fsp)
 985         return(ERROR(ERRDOS,ERRbadfid));
 986
 987     if(!dir_fsp->is_directory) {
 988       /*
 989        * Check to see if this is a mac fork of some kind.
 990        */
 991
 992       StrnCpy(fname,params+53,fname_len);
 993       fname[fname_len] = '\0';
 994
 995       if( fname[0] == ':') {
 996           SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
 997           return(ERROR(0, 0xc0000000|NT_STATUS_OBJECT_PATH_NOT_FOUND));
 998       }
 999
1000       return(ERROR(ERRDOS,ERRbadfid));
1001     }
1002
1003     /*
1004      * Copy in the base directory name.
1005      */
1006
1007     pstrcpy( fname, dir_fsp->fsp_name );
1008     dir_name_len = strlen(fname);
1009
1010     /*
1011      * Ensure it ends in a '\'.
1012      */
1013
1014     if((fname[dir_name_len-1] != '\\') && (fname[dir_name_len-1] != '/')) {
1015       pstrcat(fname, "\\");
1016       dir_name_len++;
1017     }
1018
1019     if(fname_len + dir_name_len >= sizeof(pstring))
1020       return(ERROR(ERRSRV,ERRfilespecs));
1021
1022     StrnCpy(&fname[dir_name_len], params+53, fname_len);
1023     fname[dir_name_len+fname_len] = '\0';
1024
1025   } else {
1026     StrnCpy(fname,params+53,fname_len);
1027     fname[fname_len] = '\0';
1028   }
1029
1030   /* If it's an IPC, use the pipe handler. */
1031   if (IS_IPC(conn)) {
1032     int ret = nt_open_pipe(fname, conn, inbuf, outbuf, &pnum);
1033     if(ret != 0)
1034       return ret;
1035     smb_action = FILE_WAS_OPENED;
1036   } else {
1037
1038     /*
1039      * Now contruct the smb_open_mode value from the desired access
1040      * and the share access.
1041      */
1042
1043     if((smb_open_mode = map_share_mode( &stat_open_only, fname, desired_access,
1044                                         share_access, file_attributes)) == -1)
1045       return(ERROR(ERRDOS,ERRbadaccess));
1046
1047     oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
1048     oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
1049
1050     /*
1051      * Check if POSIX semantics are wanted.
1052      */
1053
1054     set_posix_case_semantics(file_attributes);
1055
1056     unix_convert(fname,conn,0,&bad_path,NULL);
1057
1058     fsp = file_new();
1059     if (!fsp) {
1060             restore_case_semantics(file_attributes);
1061             return(ERROR(ERRSRV,ERRnofids));
1062     }
1063
1064     if (!check_name(fname,conn)) {
1065       if((errno == ENOENT) && bad_path) {
1066         unix_ERR_class = ERRDOS;
1067         unix_ERR_code = ERRbadpath;
1068       }
1069       file_free(fsp);
1070
1071       restore_case_semantics(file_attributes);
1072
1073       return(UNIXERROR(ERRDOS,ERRnoaccess));
1074     }
1075
1076     unixmode = unix_mode(conn,smb_attr | aARCH);
1077
1078     /*
1079      * If it's a request for a directory open, deal with it separately.
1080      */
1081
1082     if(create_options & FILE_DIRECTORY_FILE) {
1083
1084       oplock_request = 0;
1085
1086       /*
1087        * We will get a create directory here if the Win32
1088        * app specified a security descriptor in the
1089        * CreateDirectory() call.
1090        */
1091
1092       open_directory(fsp, conn, fname, smb_ofun, unixmode, &smb_action);
1093
1094       if(!fsp->open) {
1095         file_free(fsp);
1096         restore_case_semantics(file_attributes);
1097         return(UNIXERROR(ERRDOS,ERRnoaccess));
1098       }
1099
1100       if(dos_stat(fsp->fsp_name, &sbuf) != 0) {
1101         close_file(fsp,True);
1102         restore_case_semantics(file_attributes);
1103         return(ERROR(ERRDOS,ERRnoaccess));
1104       }
1105
1106     } else {
1107
1108       /*
1109        * Ordinary file case.
1110        */
1111
1112       open_file_shared(fsp,conn,fname,smb_open_mode,smb_ofun,unixmode,
1113                        oplock_request,&rmode,&smb_action);
1114
1115       if (!fsp->open) {
1116
1117                 if(errno == EISDIR) {
1118
1119                         /*
1120                          * Fail the open if it was explicitly a non-directory file.
1121                          */
1122
1123                         if (create_options & FILE_NON_DIRECTORY_FILE) {
1124                                 file_free(fsp);
1125                                 restore_case_semantics(file_attributes);
1126                                 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
1127                                 return(ERROR(0, 0xc0000000|NT_STATUS_FILE_IS_A_DIRECTORY));
1128                         }
1129
1130                         oplock_request = 0;
1131                         open_directory(fsp, conn, fname, smb_ofun, unixmode, &smb_action);
1132
1133                         if(!fsp->open) {
1134                                 file_free(fsp);
1135                                 restore_case_semantics(file_attributes);
1136                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
1137                         }
1138 #ifdef EROFS
1139                 } else if (((errno == EACCES) || (errno == EROFS)) && stat_open_only) {
1140 #else /* !EROFS */
1141                 } else if (errno == EACCES && stat_open_only) {
1142 #endif
1143
1144                         /*
1145                          * We couldn't open normally and all we want
1146                          * are the permissions. Try and do a stat open.
1147                          */
1148
1149                         oplock_request = 0;
1150
1151                         open_file_stat(fsp,conn,fname,smb_open_mode,&sbuf,&smb_action);
1152
1153                         if(!fsp->open) {
1154                                 file_free(fsp);
1155                                 restore_case_semantics(file_attributes);
1156                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
1157                         }
1158                 } else {
1159
1160                         if((errno == ENOENT) && bad_path) {
1161                                 unix_ERR_class = ERRDOS;
1162                                 unix_ERR_code = ERRbadpath;
1163                         }
1164                         file_free(fsp);
1165
1166                         restore_case_semantics(file_attributes);
1167
1168                         return(UNIXERROR(ERRDOS,ERRnoaccess));
1169                 }
1170       }
1171
1172       if(fsp->is_directory) {
1173           if(dos_stat(fsp->fsp_name, &sbuf) != 0) {
1174               close_file(fsp,True);
1175               restore_case_semantics(file_attributes);
1176               return(ERROR(ERRDOS,ERRnoaccess));
1177           }
1178       } else {
1179           if (!fsp->stat_open && sys_fstat(fsp->fd_ptr->fd,&sbuf) != 0) {
1180               close_file(fsp,False);
1181               restore_case_semantics(file_attributes);
1182               return(ERROR(ERRDOS,ERRnoaccess));
1183           }
1184       }
1185
1186       file_len = sbuf.st_size;
1187       fmode = dos_mode(conn,fname,&sbuf);
1188       if(fmode == 0)
1189         fmode = FILE_ATTRIBUTE_NORMAL;
1190
1191       if (fmode & aDIR) {
1192         close_file(fsp,False);
1193         restore_case_semantics(file_attributes);
1194         return(ERROR(ERRDOS,ERRnoaccess));
1195       }
1196
1197       /*
1198        * If the caller set the extended oplock request bit
1199        * and we granted one (by whatever means) - set the
1200        * correct bit for extended oplock reply.
1201        */
1202
1203       if (oplock_request && lp_fake_oplocks(SNUM(conn)))
1204         smb_action |= EXTENDED_OPLOCK_GRANTED;
1205
1206       if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
1207         smb_action |= EXTENDED_OPLOCK_GRANTED;
1208     }
1209   }
1210
1211   restore_case_semantics(file_attributes);
1212
1213   /* Realloc the size of parameters and data we will return */
1214   params = *ppparams = Realloc(*ppparams, 69);
1215   if(params == NULL)
1216     return(ERROR(ERRDOS,ERRnomem));
1217
1218   memset((char *)params,'\0',69);
1219
1220   p = params;
1221   if (smb_action & EXTENDED_OPLOCK_GRANTED)
1222         SCVAL(p,0, BATCH_OPLOCK_RETURN);
1223   else if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
1224     SCVAL(p,0, LEVEL_II_OPLOCK_RETURN);
1225   else
1226         SCVAL(p,0,NO_OPLOCK_RETURN);
1227
1228   p += 2;
1229   if (IS_IPC(conn)) {
1230           SSVAL(p,0,pnum);
1231   } else {
1232           SSVAL(p,0,fsp->fnum);
1233   }
1234   p += 2;
1235   SIVAL(p,0,smb_action);
1236   p += 8;
1237
1238   if (IS_IPC(conn)) {
1239     /*
1240      * Deal with pipe return.
1241      */
1242     p += 32;
1243     SIVAL(p,0,FILE_ATTRIBUTE_NORMAL); /* File Attributes. */
1244     p += 20;
1245     /* File type. */
1246     SSVAL(p,0,FILE_TYPE_MESSAGE_MODE_PIPE);
1247     /* Device state. */
1248     SSVAL(p,2, 0x5FF); /* ? */
1249   } else {
1250     /*
1251      * Deal with file return.
1252      */
1253     /* Create time. */
1254     put_long_date(p,get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn))));
1255     p += 8;
1256     put_long_date(p,sbuf.st_atime); /* access time */
1257     p += 8;
1258     put_long_date(p,sbuf.st_mtime); /* write time */
1259     p += 8;
1260     put_long_date(p,sbuf.st_mtime); /* change time */
1261     p += 8;
1262     SIVAL(p,0,fmode); /* File Attributes. */
1263     p += 4;
1264     SOFF_T(p,0,file_len);
1265     p += 8;
1266     SOFF_T(p,0,file_len);
1267   }
1268
1269   /* Send the required number of replies */
1270   send_nt_replies(inbuf, outbuf, bufsize, 0, params, 69, *ppdata, 0);
1271
1272   return -1;
1273 }
1274
1275 /****************************************************************************
1276  Reply to a NT CANCEL request.
1277 ****************************************************************************/
1278 int reply_ntcancel(connection_struct *conn,
1279                    char *inbuf,char *outbuf,int length,int bufsize)
1280 {
1281         /*
1282          * Go through and cancel any pending change notifies.
1283          */
1284
1285         int mid = SVAL(inbuf,smb_mid);
1286         remove_pending_change_notify_requests_by_mid(mid);
1287         remove_pending_lock_requests_by_mid(mid);
1288
1289         DEBUG(3,("reply_ntcancel: cancel called on mid = %d.\n", mid));
1290
1291         return(-1);
1292 }
1293
1294 /****************************************************************************
1295  Reply to an unsolicited SMBNTtranss - just ignore it!
1296 ****************************************************************************/
1297 int reply_nttranss(connection_struct *conn,
1298                    char *inbuf,char *outbuf,int length,int bufsize)
1299 {
1300         DEBUG(4,("Ignoring nttranss of length %d\n",length));
1301         return(-1);
1302 }
1303
1304 /****************************************************************************
1305  Reply to an NT transact rename command.
1306 ****************************************************************************/
1307
1308 static int call_nt_transact_rename(connection_struct *conn,
1309                                    char *inbuf, char *outbuf, int length,
1310                                    int bufsize,
1311                                    char **ppsetup, char **ppparams, char **ppdata)
1312 {
1313   char *params = *ppparams;
1314   pstring new_name;
1315   files_struct *fsp = file_fsp(params, 0);
1316   BOOL replace_if_exists = (SVAL(params,2) & RENAME_REPLACE_IF_EXISTS) ? True : False;
1317   uint32 fname_len = MIN((((uint32)IVAL(inbuf,smb_nt_TotalParameterCount)-4)),
1318                          ((uint32)sizeof(new_name)-1));
1319   int outsize = 0;
1320
1321   CHECK_FSP(fsp, conn);
1322   StrnCpy(new_name,params+4,fname_len);
1323   new_name[fname_len] = '\0';
1324
1325   outsize = rename_internals(conn, inbuf, outbuf, fsp->fsp_name,
1326                              new_name, replace_if_exists);
1327   if(outsize == 0) {
1328     /*
1329      * Rename was successful.
1330      */
1331     send_nt_replies(inbuf, outbuf, bufsize, 0, NULL, 0, NULL, 0);
1332
1333     DEBUG(3,("nt transact rename from = %s, to = %s succeeded.\n",
1334           fsp->fsp_name, new_name));
1335
1336     outsize = -1;
1337   }
1338
1339   return(outsize);
1340 }
1341
1342 /****************************************************************************
1343  This is the structure to keep the information needed to
1344  determine if a directory has changed.
1345 *****************************************************************************/
1346
1347 typedef struct {
1348   time_t modify_time; /* Info from the directory we're monitoring. */
1349   time_t status_time; /* Info from the directory we're monitoring. */
1350   time_t total_time; /* Total time of all directory entries - don't care if it wraps. */
1351   unsigned int num_entries; /* Zero or the number of files in the directory. */
1352 } change_hash_data;
1353
1354 /****************************************************************************
1355  This is the structure to queue to implement NT change
1356  notify. It consists of smb_size bytes stored from the
1357  transact command (to keep the mid, tid etc around).
1358  Plus the fid to examine and the time to check next.
1359 *****************************************************************************/
1360
1361 typedef struct {
1362   ubi_slNode msg_next;
1363   files_struct *fsp;
1364   connection_struct *conn;
1365   uint32 flags;
1366   time_t next_check_time;
1367   change_hash_data change_data;
1368   char request_buf[smb_size];
1369 } change_notify_buf;
1370
1371 static ubi_slList change_notify_queue = { NULL, (ubi_slNodePtr)&change_notify_queue, 0};
1372
1373 /****************************************************************************
1374  Setup the common parts of the return packet and send it.
1375 *****************************************************************************/
1376
1377 static void change_notify_reply_packet(char *inbuf, int error_class, uint32 error_code)
1378 {
1379   extern int Client;
1380   char outbuf[smb_size+38];
1381
1382   memset(outbuf, '\0', sizeof(outbuf));
1383   construct_reply_common(inbuf, outbuf);
1384
1385   /*
1386    * If we're returning a 'too much in the directory changed' we need to
1387    * set this is an NT error status flags. If we don't then the (probably
1388    * untested) code in the NT redirector has a bug in that it doesn't re-issue
1389    * the change notify.... Ah - I *love* it when I get so deeply into this I
1390    * can even determine how MS failed to test stuff and why.... :-). JRA.
1391    */
1392
1393   if(error_class == 0) /* NT Error. */
1394     SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2) | FLAGS2_32_BIT_ERROR_CODES);
1395
1396   ERROR(error_class,error_code);
1397
1398   /*
1399    * Seems NT needs a transact command with an error code
1400    * in it. This is a longer packet than a simple error.
1401    */
1402   set_message(outbuf,18,0,False);
1403
1404   send_smb(Client,outbuf);
1405 }
1406
1407 /****************************************************************************
1408  Create the hash we will use to determine if the contents changed.
1409 *****************************************************************************/
1410
1411 static BOOL create_directory_notify_hash( change_notify_buf *cnbp, change_hash_data *change_data)
1412 {
1413   SMB_STRUCT_STAT st;
1414   files_struct *fsp = cnbp->fsp;
1415
1416   memset((char *)change_data, '\0', sizeof(change_data));
1417
1418   /*
1419    * Store the current timestamp on the directory we are monitoring.
1420    */
1421
1422   if(dos_stat(fsp->fsp_name, &st) < 0) {
1423     DEBUG(0,("create_directory_notify_hash: Unable to stat name = %s. \
1424 Error was %s\n", fsp->fsp_name, strerror(errno) ));
1425     return False;
1426   }
1427
1428   change_data->modify_time = st.st_mtime;
1429   change_data->status_time = st.st_ctime;
1430
1431   /*
1432    * If we are to watch for changes that are only stored
1433    * in inodes of files, not in the directory inode, we must
1434    * scan the directory and produce a unique identifier with
1435    * which we can determine if anything changed. We use the
1436    * modify and change times from all the files in the
1437    * directory, added together (ignoring wrapping if it's
1438    * larger than the max time_t value).
1439    */
1440
1441   if(cnbp->flags & (FILE_NOTIFY_CHANGE_SIZE|FILE_NOTIFY_CHANGE_LAST_WRITE)) {
1442     pstring full_name;
1443     char *p;
1444     char *fname;
1445     size_t remaining_len;
1446     size_t fullname_len;
1447     void *dp = OpenDir(cnbp->conn, fsp->fsp_name, True);
1448
1449     if(dp == NULL) {
1450       DEBUG(0,("create_directory_notify_hash: Unable to open directory = %s. \
1451 Error was %s\n", fsp->fsp_name, strerror(errno) ));
1452       return False;
1453     }
1454
1455     change_data->num_entries = 0;
1456
1457     pstrcpy(full_name, fsp->fsp_name);
1458     pstrcat(full_name, "/");
1459
1460     fullname_len = strlen(full_name);
1461     remaining_len = sizeof(full_name) - fullname_len - 1;
1462     p = &full_name[fullname_len];
1463
1464     while ((fname = ReadDirName(dp))) {
1465       if(strequal(fname, ".") || strequal(fname, ".."))
1466         continue;
1467
1468       change_data->num_entries++;
1469       safe_strcpy( p, fname, remaining_len);
1470
1471       memset(&st, '\0', sizeof(st));
1472
1473       /*
1474        * Do the stat - but ignore errors.
1475        */
1476
1477       if(dos_stat(full_name, &st) < 0) {
1478         DEBUG(5,("create_directory_notify_hash: Unable to stat content file = %s. \
1479 Error was %s\n", fsp->fsp_name, strerror(errno) ));
1480       }
1481       change_data->total_time += (st.st_mtime + st.st_ctime);
1482     }
1483
1484     CloseDir(dp);
1485   }
1486
1487   return True;
1488 }
1489
1490 /****************************************************************************
1491  Delete entries by fnum from the change notify pending queue.
1492 *****************************************************************************/
1493
1494 void remove_pending_change_notify_requests_by_fid(files_struct *fsp)
1495 {
1496   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1497   change_notify_buf *prev = NULL;
1498
1499   while(cnbp != NULL) {
1500     if(cnbp->fsp->fnum == fsp->fnum) {
1501       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1502       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1503       continue;
1504     }
1505
1506     prev = cnbp;
1507     cnbp = (change_notify_buf *)ubi_slNext(cnbp);
1508   }
1509 }
1510
1511 /****************************************************************************
1512  Delete entries by mid from the change notify pending queue. Always send reply.
1513 *****************************************************************************/
1514
1515 static void remove_pending_change_notify_requests_by_mid(int mid)
1516 {
1517   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1518   change_notify_buf *prev = NULL;
1519
1520   while(cnbp != NULL) {
1521     if(SVAL(cnbp->request_buf,smb_mid) == mid) {
1522       change_notify_reply_packet(cnbp->request_buf,0,0xC0000000 |NT_STATUS_CANCELLED);
1523       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1524       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1525       continue;
1526     }
1527
1528     prev = cnbp;
1529     cnbp = (change_notify_buf *)ubi_slNext(cnbp);
1530   }
1531 }
1532
1533 /****************************************************************************
1534  Delete entries by filename and cnum from the change notify pending queue.
1535  Always send reply.
1536 *****************************************************************************/
1537
1538 void remove_pending_change_notify_requests_by_filename(files_struct *fsp)
1539 {
1540   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1541   change_notify_buf *prev = NULL;
1542
1543   while(cnbp != NULL) {
1544     /*
1545      * We know it refers to the same directory if the connection number and
1546      * the filename are identical.
1547      */
1548     if((cnbp->fsp->conn == fsp->conn) && strequal(cnbp->fsp->fsp_name,fsp->fsp_name)) {
1549       change_notify_reply_packet(cnbp->request_buf,0,0xC0000000 |NT_STATUS_CANCELLED);
1550       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1551       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1552       continue;
1553     }
1554
1555     prev = cnbp;
1556     cnbp = (change_notify_buf *)ubi_slNext(cnbp);
1557   }
1558 }
1559
1560 /****************************************************************************
1561  Process the change notify queue. Note that this is only called as root.
1562  Returns True if there are still outstanding change notify requests on the
1563  queue.
1564 *****************************************************************************/
1565
1566 BOOL process_pending_change_notify_queue(time_t t)
1567 {
1568   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1569   change_notify_buf *prev = NULL;
1570
1571   if(cnbp == NULL)
1572     return False;
1573
1574   if(cnbp->next_check_time >= t)
1575     return True;
1576
1577   /*
1578    * It's time to check. Go through the queue and see if
1579    * the timestamps changed.
1580    */
1581
1582   while((cnbp != NULL) && (cnbp->next_check_time <= t)) {
1583     change_hash_data change_data;
1584     connection_struct *conn = cnbp->conn;
1585     uint16 vuid = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID :
1586                   SVAL(cnbp->request_buf,smb_uid);
1587
1588     /*
1589      * Ensure we don't have any old chain_fsp values
1590      * sitting around....
1591      */
1592     chain_size = 0;
1593     file_chain_reset();
1594
1595     if(!become_user(conn,vuid)) {
1596       DEBUG(0,("process_pending_change_notify_queue: Unable to become user vuid=%d.\n",
1597             vuid ));
1598       /*
1599        * Remove the entry and return an error to the client.
1600        */
1601       change_notify_reply_packet(cnbp->request_buf,ERRSRV,ERRaccess);
1602       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1603       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1604       continue;
1605     }
1606
1607     if(!become_service(conn,True)) {
1608             DEBUG(0,("process_pending_change_notify_queue: Unable to become service Error was %s.\n", strerror(errno) ));
1609       /*
1610        * Remove the entry and return an error to the client.
1611        */
1612       change_notify_reply_packet(cnbp->request_buf,ERRSRV,ERRaccess);
1613       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1614       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1615       unbecome_user();
1616       continue;
1617     }
1618
1619     if(!create_directory_notify_hash( cnbp, &change_data)) {
1620       DEBUG(0,("process_pending_change_notify_queue: Unable to create change data for \
1621 directory %s\n", cnbp->fsp->fsp_name ));
1622       /*
1623        * Remove the entry and return an error to the client.
1624        */
1625       change_notify_reply_packet(cnbp->request_buf,ERRSRV,ERRaccess);
1626       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1627       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1628       unbecome_user();
1629       continue;
1630     }
1631
1632     if(memcmp( (char *)&cnbp->change_data, (char *)&change_data, sizeof(change_data))) {
1633       /*
1634        * Remove the entry and return a change notify to the client.
1635        */
1636       DEBUG(5,("process_pending_change_notify_queue: directory name = %s changed.\n",
1637             cnbp->fsp->fsp_name ));
1638       change_notify_reply_packet(cnbp->request_buf,0,NT_STATUS_NOTIFY_ENUM_DIR);
1639       free((char *)ubi_slRemNext( &change_notify_queue, prev));
1640       cnbp = (change_notify_buf *)(prev ? ubi_slNext(prev) : ubi_slFirst(&change_notify_queue));
1641       unbecome_user();
1642       continue;
1643     }
1644
1645     unbecome_user();
1646
1647     /*
1648      * Move to the next in the list.
1649      */
1650     prev = cnbp;
1651     cnbp = (change_notify_buf *)ubi_slNext(cnbp);
1652   }
1653
1654   return (cnbp != NULL);
1655 }
1656
1657 /****************************************************************************
1658  Return true if there are pending change notifies.
1659 ****************************************************************************/
1660
1661 BOOL change_notifies_pending(void)
1662 {
1663   change_notify_buf *cnbp = (change_notify_buf *)ubi_slFirst( &change_notify_queue );
1664   return (cnbp != NULL);
1665 }
1666
1667 /****************************************************************************
1668  Reply to a notify change - queue the request and
1669  don't allow a directory to be opened.
1670 ****************************************************************************/
1671
1672 static int call_nt_transact_notify_change(connection_struct *conn,
1673                                           char *inbuf, char *outbuf, int length,
1674                                           int bufsize,
1675                                           char **ppsetup,
1676                                           char **ppparams, char **ppdata)
1677 {
1678   char *setup = *ppsetup;
1679   files_struct *fsp;
1680   change_notify_buf *cnbp;
1681
1682   fsp = file_fsp(setup,4);
1683
1684   DEBUG(3,("call_nt_transact_notify_change\n"));
1685
1686   if(!fsp)
1687     return(ERROR(ERRDOS,ERRbadfid));
1688
1689   if((!fsp->open) || (!fsp->is_directory) || (conn != fsp->conn))
1690     return(ERROR(ERRDOS,ERRbadfid));
1691
1692   /*
1693    * Now queue an entry on the notify change stack. We timestamp
1694    * the entry we are adding so that we know when to scan next.
1695    * We only need to save smb_size bytes from this incoming packet
1696    * as we will always by returning a 'read the directory yourself'
1697    * error.
1698    */
1699
1700   if((cnbp = (change_notify_buf *)malloc(sizeof(change_notify_buf))) == NULL) {
1701     DEBUG(0,("call_nt_transact_notify_change: malloc fail !\n" ));
1702     return -1;
1703   }
1704
1705   memset((char *)cnbp, '\0', sizeof(change_notify_buf));
1706
1707   memcpy(cnbp->request_buf, inbuf, smb_size);
1708   cnbp->fsp = fsp;
1709   cnbp->conn = conn;
1710   cnbp->next_check_time = time(NULL) + lp_change_notify_timeout();
1711   cnbp->flags = IVAL(setup, 0);
1712
1713   if(!create_directory_notify_hash( cnbp, &cnbp->change_data )) {
1714     free((char *)cnbp);
1715     return(UNIXERROR(ERRDOS,ERRbadfid));
1716   }
1717
1718   /*
1719    * Adding to the tail enables us to check only
1720    * the head when scanning for change, as this entry
1721    * is forced to have the first timeout expiration.
1722    */
1723
1724   ubi_slAddTail(&change_notify_queue, cnbp);
1725
1726   DEBUG(3,("call_nt_transact_notify_change: notify change called on directory \
1727 name = %s\n", fsp->fsp_name ));
1728
1729   return -1;
1730 }
1731
1732 /****************************************************************************
1733  Map unix perms to NT.
1734 ****************************************************************************/
1735
1736 static SEC_ACCESS map_unix_perms( int *pacl_type, mode_t perm, int r_mask, int w_mask, int x_mask, BOOL is_directory)
1737 {
1738         SEC_ACCESS sa;
1739         uint32 nt_mask = 0;
1740
1741         *pacl_type = SEC_ACE_TYPE_ACCESS_ALLOWED;
1742
1743         if((perm & (r_mask|w_mask|x_mask)) == (r_mask|w_mask|x_mask)) {
1744                 nt_mask = UNIX_ACCESS_RWX;
1745         } else if((perm & (r_mask|w_mask|x_mask)) == 0) {
1746                 nt_mask = UNIX_ACCESS_NONE;
1747         } else {
1748                 nt_mask |= (perm & r_mask) ? UNIX_ACCESS_R : 0;
1749                 if(is_directory)
1750                         nt_mask |= (perm & w_mask) ? UNIX_ACCESS_W : 0;
1751                 else
1752                         nt_mask |= (perm & w_mask) ? UNIX_ACCESS_W : 0;
1753                 nt_mask |= (perm & x_mask) ? UNIX_ACCESS_X : 0;
1754         }
1755         init_sec_access(&sa,nt_mask);
1756         return sa;
1757 }
1758
1759 /****************************************************************************
1760  Reply to query a security descriptor from an fsp. If it succeeds it allocates
1761  the space for the return elements and returns True.
1762 ****************************************************************************/
1763
1764 static size_t get_nt_acl(files_struct *fsp, SEC_DESC **ppdesc)
1765 {
1766   extern DOM_SID global_sam_sid;
1767   extern DOM_SID global_sid_World;
1768   SMB_STRUCT_STAT sbuf;
1769   SEC_ACE ace_list[6];
1770   DOM_SID owner_sid;
1771   DOM_SID group_sid;
1772   size_t sec_desc_size;
1773   SEC_ACL *psa = NULL;
1774   SEC_ACCESS owner_access;
1775   int owner_acl_type;
1776   SEC_ACCESS group_access;
1777   int grp_acl_type;
1778   SEC_ACCESS other_access;
1779   int other_acl_type;
1780   int num_acls = 0;
1781
1782   *ppdesc = NULL;
1783
1784   if(!lp_nt_acl_support()) {
1785     sid_copy( &owner_sid, &global_sid_World);
1786     sid_copy( &group_sid, &global_sid_World);
1787   } else {
1788
1789     if(fsp->is_directory || fsp->fd_ptr == NULL) {
1790       if(dos_stat(fsp->fsp_name, &sbuf) != 0) {
1791         return 0;
1792       }
1793     } else {
1794       if(sys_fstat(fsp->fd_ptr->fd,&sbuf) != 0) {
1795         return 0;
1796       }
1797     }
1798
1799     /*
1800      * Get the owner, group and world SIDs.
1801      */
1802
1803     sid_copy(&owner_sid, &global_sam_sid);
1804     sid_copy(&group_sid, &global_sam_sid);
1805     sid_append_rid(&owner_sid, pdb_uid_to_user_rid(sbuf.st_uid));
1806     sid_append_rid(&group_sid, pdb_gid_to_group_rid(sbuf.st_gid));
1807
1808     /*
1809      * Create the generic 3 element UNIX acl.
1810      */
1811
1812     owner_access = map_unix_perms(&owner_acl_type, sbuf.st_mode,
1813                                                         S_IRUSR, S_IWUSR, S_IXUSR, fsp->is_directory);
1814     group_access = map_unix_perms(&grp_acl_type, sbuf.st_mode,
1815                                                         S_IRGRP, S_IWGRP, S_IXGRP, fsp->is_directory);
1816     other_access = map_unix_perms(&other_acl_type, sbuf.st_mode,
1817                                                         S_IROTH, S_IWOTH, S_IXOTH, fsp->is_directory);
1818
1819     if(owner_access.mask)
1820       init_sec_ace(&ace_list[num_acls++], &owner_sid, owner_acl_type,
1821                    owner_access, 0);
1822
1823     if(group_access.mask)
1824       init_sec_ace(&ace_list[num_acls++], &group_sid, grp_acl_type,
1825                    group_access, 0);
1826
1827     if(other_access.mask)
1828       init_sec_ace(&ace_list[num_acls++], &global_sid_World, other_acl_type,
1829                    other_access, 0);
1830
1831     if(fsp->is_directory) {
1832       /*
1833        * For directory ACLs we also add in the inherited permissions
1834        * ACE entries. These are the permissions a file would get when
1835        * being created in the directory.
1836        */
1837       mode_t mode = unix_mode( fsp->conn, FILE_ATTRIBUTE_ARCHIVE);
1838
1839       owner_access = map_unix_perms(&owner_acl_type, mode,
1840                             S_IRUSR, S_IWUSR, S_IXUSR, fsp->is_directory);
1841       group_access = map_unix_perms(&grp_acl_type, mode,
1842                             S_IRGRP, S_IWGRP, S_IXGRP, fsp->is_directory);
1843       other_access = map_unix_perms(&other_acl_type, mode,
1844                             S_IROTH, S_IWOTH, S_IXOTH, fsp->is_directory);
1845
1846       if(owner_access.mask)
1847         init_sec_ace(&ace_list[num_acls++], &owner_sid, owner_acl_type,
1848                      owner_access, SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_INHERIT_ONLY);
1849
1850       if(group_access.mask)
1851         init_sec_ace(&ace_list[num_acls++], &group_sid, grp_acl_type,
1852                      group_access, SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_INHERIT_ONLY);
1853
1854       if(other_access.mask)
1855         init_sec_ace(&ace_list[num_acls++], &global_sid_World, other_acl_type,
1856                      other_access, SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_INHERIT_ONLY);
1857     }
1858
1859     if(num_acls)
1860       if((psa = make_sec_acl( 3, num_acls, ace_list)) == NULL) {
1861         DEBUG(0,("get_nt_acl: Unable to malloc space for acl.\n"));
1862         return 0;
1863       }
1864   }
1865
1866   *ppdesc = make_standard_sec_desc( &owner_sid, &group_sid, psa, &sec_desc_size);
1867
1868   if(!*ppdesc) {
1869     DEBUG(0,("get_nt_acl: Unable to malloc space for security descriptor.\n"));
1870     sec_desc_size = 0;
1871   }
1872
1873   free_sec_acl(&psa);
1874
1875   return sec_desc_size;
1876 }
1877
1878 /****************************************************************************
1879  Reply to query a security descriptor - currently this is not implemented (it
1880  is planned to be though). Right now it just returns the same thing NT would
1881  when queried on a FAT filesystem. JRA.
1882 ****************************************************************************/
1883
1884 static int call_nt_transact_query_security_desc(connection_struct *conn,
1885                                                 char *inbuf, char *outbuf,
1886                                                 int length, int bufsize,
1887                                                 char **ppsetup, char **ppparams, char **ppdata)
1888 {
1889   uint32 max_data_count = IVAL(inbuf,smb_nt_MaxDataCount);
1890   char *params = *ppparams;
1891   char *data = *ppdata;
1892   prs_struct pd;
1893   SEC_DESC *psd;
1894   size_t sec_desc_size;
1895
1896   files_struct *fsp = file_fsp(params,0);
1897
1898   if(!fsp)
1899     return(ERROR(ERRDOS,ERRbadfid));
1900
1901   DEBUG(3,("call_nt_transact_query_security_desc: file = %s\n", fsp->fsp_name ));
1902
1903   params = *ppparams = Realloc(*ppparams, 4);
1904   if(params == NULL)
1905     return(ERROR(ERRDOS,ERRnomem));
1906
1907   /*
1908    * Get the permissions to return.
1909    */
1910
1911   if((sec_desc_size = get_nt_acl(fsp, &psd)) == 0)
1912     return(UNIXERROR(ERRDOS,ERRnoaccess));
1913
1914   DEBUG(3,("call_nt_transact_query_security_desc: sec_desc_size = %d.\n",(int)sec_desc_size));
1915
1916   SIVAL(params,0,(uint32)sec_desc_size);
1917
1918   if(max_data_count < sec_desc_size) {
1919
1920     free_sec_desc(&psd);
1921
1922     send_nt_replies(inbuf, outbuf, bufsize, 0xC0000000|NT_STATUS_BUFFER_TOO_SMALL,
1923                     params, 4, *ppdata, 0);
1924     return -1;
1925   }
1926
1927   /*
1928    * Allocate the data we will point this at.
1929    */
1930
1931   data = *ppdata = Realloc(*ppdata, sec_desc_size);
1932   if(data == NULL) {
1933     free_sec_desc(&psd);
1934     return(ERROR(ERRDOS,ERRnomem));
1935   }
1936
1937   memset(data, '\0', sec_desc_size);
1938
1939   /*
1940    * Init the parse struct we will marshall into.
1941    */
1942
1943   prs_init(&pd, 0, 4, MARSHALL);
1944
1945   /*
1946    * Setup the prs_struct to point at the memory we just
1947    * allocated.
1948    */
1949
1950   prs_give_memory( &pd, data, (uint32)sec_desc_size, False);
1951
1952   /*
1953    * Finally, linearize into the outgoing buffer.
1954    */
1955
1956   if(!sec_io_desc( "sd data", &psd, &pd, 1)) {
1957     free_sec_desc(&psd);
1958     DEBUG(0,("call_nt_transact_query_security_desc: Error in marshalling \
1959 security descriptor.\n"));
1960     /*
1961      * Return access denied for want of a better error message..
1962      */
1963     return(UNIXERROR(ERRDOS,ERRnoaccess));
1964   }
1965
1966   /*
1967    * Now we can delete the security descriptor.
1968    */
1969
1970   free_sec_desc(&psd);
1971
1972   send_nt_replies(inbuf, outbuf, bufsize, 0, params, 4, data, (int)sec_desc_size);
1973   return -1;
1974 }
1975
1976 /****************************************************************************
1977  Validate a SID.
1978 ****************************************************************************/
1979
1980 static BOOL validate_unix_sid( DOM_SID *psid, uint32 *prid, DOM_SID *sd_sid)
1981 {
1982   extern DOM_SID global_sam_sid;
1983   DOM_SID sid;
1984
1985   if(!sd_sid) {
1986     DEBUG(5,("validate_unix_sid: sid missing.\n"));
1987     return False;
1988   }
1989
1990   sid_copy(psid, sd_sid);
1991   sid_copy(&sid, sd_sid);
1992
1993   if(!sid_split_rid(&sid, prid)) {
1994     DEBUG(5,("validate_unix_sid: cannot get RID from sid.\n"));
1995     return False;
1996   }
1997
1998   if(!sid_equal( &sid, &global_sam_sid)) {
1999     DEBUG(5,("validate_unix_sid: sid is not ours.\n"));
2000     return False;
2001   }
2002
2003   return True;
2004 }
2005
2006 /****************************************************************************
2007  Map NT perms to UNIX.
2008 ****************************************************************************/
2009
2010 #define FILE_SPECIFIC_READ_BITS (FILE_READ_DATA|FILE_READ_EA|FILE_READ_ATTRIBUTES)
2011 #define FILE_SPECIFIC_WRITE_BITS (FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_WRITE_EA|FILE_WRITE_ATTRIBUTES)
2012 #define FILE_SPECIFIC_EXECUTE_BITS (FILE_EXECUTE)
2013
2014 static mode_t map_nt_perms( SEC_ACCESS sec_access, int type)
2015 {
2016   mode_t mode = 0;
2017
2018   switch(type) {
2019   case S_IRUSR:
2020     if(sec_access.mask & GENERIC_ALL_ACCESS)
2021       mode = S_IRUSR|S_IWUSR|S_IXUSR;
2022     else {
2023       mode |= (sec_access.mask & (GENERIC_READ_ACCESS|FILE_SPECIFIC_READ_BITS)) ? S_IRUSR : 0;
2024       mode |= (sec_access.mask & (GENERIC_WRITE_ACCESS|FILE_SPECIFIC_WRITE_BITS)) ? S_IWUSR : 0;
2025       mode |= (sec_access.mask & (GENERIC_EXECUTE_ACCESS|FILE_SPECIFIC_EXECUTE_BITS)) ? S_IXUSR : 0;
2026     }
2027     break;
2028   case S_IRGRP:
2029     if(sec_access.mask & GENERIC_ALL_ACCESS)
2030       mode = S_IRGRP|S_IWGRP|S_IXGRP;
2031     else {
2032       mode |= (sec_access.mask & (GENERIC_READ_ACCESS|FILE_SPECIFIC_READ_BITS)) ? S_IRGRP : 0;
2033       mode |= (sec_access.mask & (GENERIC_WRITE_ACCESS|FILE_SPECIFIC_WRITE_BITS)) ? S_IWGRP : 0;
2034       mode |= (sec_access.mask & (GENERIC_EXECUTE_ACCESS|FILE_SPECIFIC_EXECUTE_BITS)) ? S_IXGRP : 0;
2035     }
2036     break;
2037   case S_IROTH:
2038     if(sec_access.mask & GENERIC_ALL_ACCESS)
2039       mode = S_IROTH|S_IWOTH|S_IXOTH;
2040     else {
2041       mode |= (sec_access.mask & (GENERIC_READ_ACCESS|FILE_SPECIFIC_READ_BITS)) ? S_IROTH : 0;
2042       mode |= (sec_access.mask & (GENERIC_WRITE_ACCESS|FILE_SPECIFIC_WRITE_BITS)) ? S_IWOTH : 0;
2043       mode |= (sec_access.mask & (GENERIC_EXECUTE_ACCESS|FILE_SPECIFIC_EXECUTE_BITS)) ? S_IXOTH : 0;
2044     }
2045     break;
2046   }
2047
2048   return mode;
2049 }
2050
2051 /****************************************************************************
2052  Unpack a SEC_DESC into a owner, group and set of UNIX permissions.
2053 ****************************************************************************/
2054
2055 static BOOL unpack_nt_permissions(uid_t *puser, gid_t *pgrp, mode_t *pmode, uint32 security_info_sent,
2056                                   SEC_DESC *psd, BOOL is_directory)
2057 {
2058   extern DOM_SID global_sid_World;
2059   DOM_SID owner_sid;
2060   DOM_SID grp_sid;
2061   uint32 owner_rid;
2062   uint32 grp_rid;
2063   SEC_ACL *dacl = psd->dacl;
2064   int i;
2065
2066   *pmode = 0;
2067   *puser = (uid_t)-1;
2068   *pgrp = (gid_t)-1;
2069
2070   if(security_info_sent == 0) {
2071     DEBUG(0,("unpack_unix_permissions: no security info sent !\n"));
2072     return False;
2073   }
2074
2075   /*
2076    * Validate the owner and group SID's.
2077    */
2078
2079   memset(&owner_sid, '\0', sizeof(owner_sid));
2080   memset(&grp_sid, '\0', sizeof(grp_sid));
2081
2082   DEBUG(5,("unpack_unix_permissions: validating owner_sid.\n"));
2083
2084   /*
2085    * Don't immediately fail if the owner sid cannot be validated.
2086    * This may be a group chown only set.
2087    */
2088
2089   if(!validate_unix_sid( &owner_sid, &owner_rid, psd->owner_sid))
2090     DEBUG(3,("unpack_unix_permissions: unable to validate owner sid.\n"));
2091   else if(security_info_sent & OWNER_SECURITY_INFORMATION)
2092     *puser = pdb_user_rid_to_uid(owner_rid);
2093
2094   /*
2095    * Don't immediately fail if the group sid cannot be validated.
2096    * This may be an owner chown only set.
2097    */
2098
2099   if(!validate_unix_sid( &grp_sid, &grp_rid, psd->grp_sid))
2100     DEBUG(3,("unpack_unix_permissions: unable to validate group sid.\n"));
2101   else if(security_info_sent & GROUP_SECURITY_INFORMATION)
2102     *pgrp = pdb_user_rid_to_gid(grp_rid);
2103
2104   /*
2105    * If no DACL then this is a chown only security descriptor.
2106    */
2107
2108   if(!(security_info_sent & DACL_SECURITY_INFORMATION) || !dacl) {
2109     *pmode = 0;
2110     return True;
2111   }
2112
2113   /*
2114    * Now go through the DACL and ensure that
2115    * any owner/group sids match.
2116    */
2117
2118   for(i = 0; i < dacl->num_aces; i++) {
2119     DOM_SID ace_sid;
2120     SEC_ACE *psa = &dacl->ace_list[i];
2121
2122     if((psa->type != SEC_ACE_TYPE_ACCESS_ALLOWED) &&
2123        (psa->type != SEC_ACE_TYPE_ACCESS_DENIED)) {
2124       DEBUG(3,("unpack_unix_permissions: unable to set anything but an ALLOW or DENY ACE.\n"));
2125       return False;
2126     }
2127
2128     /*
2129      * Ignore or remove bits we don't care about on a directory ACE.
2130      */
2131
2132     if(is_directory) {
2133       if(psa->flags & SEC_ACE_FLAG_INHERIT_ONLY) {
2134         DEBUG(3,("unpack_unix_permissions: ignoring inherit only ACE.\n"));
2135         continue;
2136       }
2137
2138       psa->flags &= ~(SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT);
2139     }
2140
2141     if(psa->flags != 0) {
2142       DEBUG(1,("unpack_unix_permissions: unable to set ACE flags (%x).\n",
2143             (unsigned int)psa->flags));
2144       return False;
2145     }
2146
2147     /*
2148      * The security mask may be UNIX_ACCESS_NONE which should map into
2149      * no permissions (we overload the WRITE_OWNER bit for this) or it
2150      * should be one of the ALL/EXECUTE/READ/WRITE bits. Arrange for this
2151      * to be so. Any other bits override the UNIX_ACCESS_NONE bit.
2152      */
2153
2154     psa->info.mask &= (GENERIC_ALL_ACCESS|GENERIC_EXECUTE_ACCESS|GENERIC_WRITE_ACCESS|
2155                      GENERIC_READ_ACCESS|UNIX_ACCESS_NONE|FILE_ALL_ATTRIBUTES);
2156
2157     if(psa->info.mask != UNIX_ACCESS_NONE)
2158       psa->info.mask &= ~UNIX_ACCESS_NONE;
2159
2160     sid_copy(&ace_sid, &psa->sid);
2161
2162     if(sid_equal(&ace_sid, &owner_sid)) {
2163       /*
2164        * Map the desired permissions into owner perms.
2165        */
2166
2167       if(psa->type == SEC_ACE_TYPE_ACCESS_ALLOWED)
2168         *pmode |= map_nt_perms( psa->info, S_IRUSR);
2169       else
2170         *pmode &= ~(map_nt_perms( psa->info, S_IRUSR));
2171
2172     } else if( sid_equal(&ace_sid, &grp_sid)) {
2173       /*
2174        * Map the desired permissions into group perms.
2175        */
2176
2177       if(psa->type == SEC_ACE_TYPE_ACCESS_ALLOWED)
2178         *pmode |= map_nt_perms( psa->info, S_IRGRP);
2179       else
2180         *pmode &= ~(map_nt_perms( psa->info, S_IRGRP));
2181
2182     } else if( sid_equal(&ace_sid, &global_sid_World)) {
2183       /*
2184        * Map the desired permissions into other perms.
2185        */
2186
2187       if(psa->type == SEC_ACE_TYPE_ACCESS_ALLOWED)
2188         *pmode |= map_nt_perms( psa->info, S_IROTH);
2189       else
2190         *pmode &= ~(map_nt_perms( psa->info, S_IROTH));
2191
2192     } else {
2193       DEBUG(0,("unpack_unix_permissions: unknown SID used in ACL.\n"));
2194       return False;
2195     }
2196   }
2197
2198   return True;
2199 }
2200
2201 /****************************************************************************
2202  Reply to set a security descriptor. Map to UNIX perms.
2203 ****************************************************************************/
2204
2205 static int call_nt_transact_set_security_desc(connection_struct *conn,
2206                                                                         char *inbuf, char *outbuf, int length,
2207                                                                         int bufsize, char **ppsetup,
2208                                                                         char **ppparams, char **ppdata)
2209 {
2210   uint32 total_parameter_count = IVAL(inbuf, smb_nts_TotalParameterCount);
2211   char *params= *ppparams;
2212   char *data = *ppdata;
2213   prs_struct pd;
2214   SEC_DESC *psd = NULL;
2215   uint32 total_data_count = (uint32)IVAL(inbuf, smb_nts_TotalDataCount);
2216   uid_t user = (uid_t)-1;
2217   gid_t grp = (gid_t)-1;
2218   mode_t perms = 0;
2219   SMB_STRUCT_STAT sbuf;
2220   files_struct *fsp = NULL;
2221   uint32 security_info_sent = 0;
2222   BOOL got_dacl = False;
2223
2224   if(!lp_nt_acl_support())
2225     return(UNIXERROR(ERRDOS,ERRnoaccess));
2226
2227   if(total_parameter_count < 8)
2228     return(ERROR(ERRDOS,ERRbadfunc));
2229
2230   if((fsp = file_fsp(params,0)) == NULL)
2231     return(ERROR(ERRDOS,ERRbadfid));
2232
2233   security_info_sent = IVAL(params,4);
2234
2235   DEBUG(3,("call_nt_transact_set_security_desc: file = %s, sent 0x%x\n", fsp->fsp_name,
2236        (unsigned int)security_info_sent ));
2237
2238   /*
2239    * Init the parse struct we will unmarshall from.
2240    */
2241
2242   prs_init(&pd, 0, 4, UNMARSHALL);
2243
2244   /*
2245    * Setup the prs_struct to point at the memory we just
2246    * allocated.
2247    */
2248
2249   prs_give_memory( &pd, data, total_data_count, False);
2250
2251   /*
2252    * Finally, unmarshall from the data buffer.
2253    */
2254
2255   if(!sec_io_desc( "sd data", &psd, &pd, 1)) {
2256     free_sec_desc(&psd);
2257     DEBUG(0,("call_nt_transact_set_security_desc: Error in unmarshalling \
2258 security descriptor.\n"));
2259     /*
2260      * Return access denied for want of a better error message..
2261      */
2262     return(UNIXERROR(ERRDOS,ERRnoaccess));
2263   }
2264
2265   /*
2266    * Unpack the user/group/world id's and permissions.
2267    */
2268
2269   if(!unpack_nt_permissions( &user, &grp, &perms, security_info_sent, psd, fsp->is_directory)) {
2270     free_sec_desc(&psd);
2271     return(UNIXERROR(ERRDOS,ERRnoaccess));
2272   }
2273
2274   if (psd->dacl != NULL)
2275     got_dacl = True;
2276
2277   free_sec_desc(&psd);
2278
2279   /*
2280    * Get the current state of the file.
2281    */
2282
2283   if(fsp->is_directory) {
2284     if(dos_stat(fsp->fsp_name, &sbuf) != 0) {
2285       return(UNIXERROR(ERRDOS,ERRnoaccess));
2286     }
2287   } else {
2288
2289     int ret;
2290
2291     if(fsp->fd_ptr == NULL)
2292       ret = dos_stat(fsp->fsp_name, &sbuf);
2293     else
2294       ret = sys_fstat(fsp->fd_ptr->fd,&sbuf);
2295
2296     if(ret != 0) {
2297       return(UNIXERROR(ERRDOS,ERRnoaccess));
2298     }
2299   }
2300
2301   /*
2302    * Do we need to chown ?
2303    */
2304
2305   if((user != (uid_t)-1 || grp != (uid_t)-1) && (sbuf.st_uid != user || sbuf.st_gid != grp)) {
2306
2307     DEBUG(3,("call_nt_transact_set_security_desc: chown %s. uid = %u, gid = %u.\n",
2308           fsp->fsp_name, (unsigned int)user, (unsigned int)grp ));
2309
2310     if(dos_chown( fsp->fsp_name, user, grp) == -1) {
2311       DEBUG(3,("call_nt_transact_set_security_desc: chown %s, %u, %u failed. Error = %s.\n",
2312             fsp->fsp_name, (unsigned int)user, (unsigned int)grp, strerror(errno) ));
2313       return(UNIXERROR(ERRDOS,ERRnoaccess));
2314     }
2315
2316     /*
2317      * Recheck the current state of the file, which may have changed.
2318      * (suid/sgid bits, for instance)
2319      */
2320
2321     if(fsp->is_directory) {
2322       if(dos_stat(fsp->fsp_name, &sbuf) != 0) {
2323         return(UNIXERROR(ERRDOS,ERRnoaccess));
2324       }
2325     } else {
2326
2327       int ret;
2328
2329       if(fsp->fd_ptr == NULL)
2330         ret = dos_stat(fsp->fsp_name, &sbuf);
2331       else
2332         ret = sys_fstat(fsp->fd_ptr->fd,&sbuf);
2333
2334       if(ret != 0)
2335         return(UNIXERROR(ERRDOS,ERRnoaccess));
2336     }
2337   }
2338
2339   /*
2340    * Only change security if we got a DACL.
2341    */
2342
2343   if((security_info_sent & DACL_SECURITY_INFORMATION) && got_dacl) {
2344
2345     /*
2346      * Check to see if we need to change anything.
2347      * Enforce limits on modified bits *only*. Don't enforce masks
2348          * on bits not changed by the user.
2349      */
2350
2351     if(fsp->is_directory) {
2352
2353       perms &= (lp_dir_security_mask(SNUM(conn)) | sbuf.st_mode);
2354       perms |= (lp_force_dir_security_mode(SNUM(conn)) & ( perms ^ sbuf.st_mode ));
2355
2356     } else {
2357
2358       perms &= (lp_security_mask(SNUM(conn)) | sbuf.st_mode);
2359       perms |= (lp_force_security_mode(SNUM(conn)) & ( perms ^ sbuf.st_mode ));
2360
2361     }
2362
2363     /*
2364      * Preserve special bits.
2365      */
2366
2367     perms |= (sbuf.st_mode & ~0777);
2368
2369     /*
2370      * Do we need to chmod ?
2371      */
2372
2373     if(sbuf.st_mode != perms) {
2374
2375       DEBUG(3,("call_nt_transact_set_security_desc: chmod %s. perms = 0%o.\n",
2376             fsp->fsp_name, (unsigned int)perms ));
2377
2378       if(dos_chmod( fsp->fsp_name, perms) == -1) {
2379         DEBUG(3,("call_nt_transact_set_security_desc: chmod %s, 0%o failed. Error = %s.\n",
2380               fsp->fsp_name, (unsigned int)perms, strerror(errno) ));
2381         return(UNIXERROR(ERRDOS,ERRnoaccess));
2382       }
2383     }
2384   }
2385
2386   send_nt_replies(inbuf, outbuf, bufsize, 0, NULL, 0, NULL, 0);
2387   return -1;
2388 }
2389
2390 /****************************************************************************
2391  Reply to IOCTL - not implemented - no plans.
2392 ****************************************************************************/
2393 static int call_nt_transact_ioctl(connection_struct *conn,
2394                                   char *inbuf, char *outbuf, int length,
2395                                   int bufsize,
2396                                   char **ppsetup, char **ppparams, char **ppdata)
2397 {
2398   static BOOL logged_message = False;
2399
2400   if(!logged_message) {
2401     DEBUG(0,("call_nt_transact_ioctl: Currently not implemented.\n"));
2402     logged_message = True; /* Only print this once... */
2403   }
2404   return(ERROR(ERRSRV,ERRnosupport));
2405 }
2406
2407 /****************************************************************************
2408  Reply to a SMBNTtrans.
2409 ****************************************************************************/
2410 int reply_nttrans(connection_struct *conn,
2411                   char *inbuf,char *outbuf,int length,int bufsize)
2412 {
2413   int  outsize = 0;
2414 #if 0 /* Not used. */
2415   uint16 max_setup_count = CVAL(inbuf, smb_nt_MaxSetupCount);
2416   uint32 max_parameter_count = IVAL(inbuf, smb_nt_MaxParameterCount);
2417   uint32 max_data_count = IVAL(inbuf,smb_nt_MaxDataCount);
2418 #endif /* Not used. */
2419   uint32 total_parameter_count = IVAL(inbuf, smb_nt_TotalParameterCount);
2420   uint32 total_data_count = IVAL(inbuf, smb_nt_TotalDataCount);
2421   uint32 parameter_count = IVAL(inbuf,smb_nt_ParameterCount);
2422   uint32 parameter_offset = IVAL(inbuf,smb_nt_ParameterOffset);
2423   uint32 data_count = IVAL(inbuf,smb_nt_DataCount);
2424   uint32 data_offset = IVAL(inbuf,smb_nt_DataOffset);
2425   uint16 setup_count = 2*CVAL(inbuf,smb_nt_SetupCount); /* setup count is in *words* */
2426   uint16 function_code = SVAL( inbuf, smb_nt_Function);
2427   char *params = NULL, *data = NULL, *setup = NULL;
2428   uint32 num_params_sofar, num_data_sofar;
2429
2430   if(global_oplock_break && (function_code == NT_TRANSACT_CREATE)) {
2431     /*
2432      * Queue this open message as we are the process of an oplock break.
2433      */
2434
2435     DEBUG(2,("reply_nttrans: queueing message NT_TRANSACT_CREATE \
2436 due to being in oplock break state.\n" ));
2437
2438     push_oplock_pending_smb_message( inbuf, length);
2439     return -1;
2440   }
2441
2442   outsize = set_message(outbuf,0,0,True);
2443
2444   /*
2445    * All nttrans messages we handle have smb_wct == 19 + setup_count.
2446    * Ensure this is so as a sanity check.
2447    */
2448
2449   if(CVAL(inbuf, smb_wct) != 19 + (setup_count/2)) {
2450     DEBUG(2,("Invalid smb_wct %d in nttrans call (should be %d)\n",
2451           CVAL(inbuf, smb_wct), 19 + (setup_count/2)));
2452     return(ERROR(ERRSRV,ERRerror));
2453   }
2454
2455   /* Allocate the space for the setup, the maximum needed parameters and data */
2456
2457   if(setup_count > 0)
2458     setup = (char *)malloc(setup_count);
2459   if (total_parameter_count > 0)
2460     params = (char *)malloc(total_parameter_count);
2461   if (total_data_count > 0)
2462     data = (char *)malloc(total_data_count);
2463
2464   if ((total_parameter_count && !params)  || (total_data_count && !data) ||
2465       (setup_count && !setup)) {
2466     DEBUG(0,("reply_nttrans : Out of memory\n"));
2467     return(ERROR(ERRDOS,ERRnomem));
2468   }
2469
2470   /* Copy the param and data bytes sent with this request into
2471      the params buffer */
2472   num_params_sofar = parameter_count;
2473   num_data_sofar = data_count;
2474
2475   if (parameter_count > total_parameter_count || data_count > total_data_count)
2476     exit_server("reply_nttrans: invalid sizes in packet.\n");
2477
2478   if(setup) {
2479     memcpy( setup, &inbuf[smb_nt_SetupStart], setup_count);
2480     DEBUG(10,("reply_nttrans: setup_count = %d\n", setup_count));
2481     dump_data(10, setup, setup_count);
2482   }
2483   if(params) {
2484     memcpy( params, smb_base(inbuf) + parameter_offset, parameter_count);
2485     DEBUG(10,("reply_nttrans: parameter_count = %d\n", parameter_count));
2486     dump_data(10, params, parameter_count);
2487   }
2488   if(data) {
2489     memcpy( data, smb_base(inbuf) + data_offset, data_count);
2490     DEBUG(10,("reply_nttrans: data_count = %d\n",data_count));
2491     dump_data(10, data, data_count);
2492   }
2493
2494   if(num_data_sofar < total_data_count || num_params_sofar < total_parameter_count) {
2495     /* We need to send an interim response then receive the rest
2496        of the parameter/data bytes */
2497     outsize = set_message(outbuf,0,0,True);
2498     send_smb(Client,outbuf);
2499
2500     while( num_data_sofar < total_data_count || num_params_sofar < total_parameter_count) {
2501       BOOL ret;
2502
2503       ret = receive_next_smb(inbuf,bufsize,SMB_SECONDARY_WAIT);
2504
2505       if((ret && (CVAL(inbuf, smb_com) != SMBnttranss)) || !ret) {
2506         outsize = set_message(outbuf,0,0,True);
2507         if(ret) {
2508                 DEBUG(0,("reply_nttrans: Invalid secondary nttrans packet\n"));
2509         } else {
2510                 DEBUG(0,("reply_nttrans: %s in getting secondary nttrans response.\n",
2511                          (smb_read_error == READ_ERROR) ? "error" : "timeout" ));
2512         }
2513         if(params)
2514           free(params);
2515         if(data)
2516           free(data);
2517         if(setup)
2518           free(setup);
2519         return(ERROR(ERRSRV,ERRerror));
2520       }
2521
2522       /* Revise total_params and total_data in case they have changed downwards */
2523       total_parameter_count = IVAL(inbuf, smb_nts_TotalParameterCount);
2524       total_data_count = IVAL(inbuf, smb_nts_TotalDataCount);
2525       num_params_sofar += (parameter_count = IVAL(inbuf,smb_nts_ParameterCount));
2526       num_data_sofar += ( data_count = IVAL(inbuf, smb_nts_DataCount));
2527       if (num_params_sofar > total_parameter_count || num_data_sofar > total_data_count)
2528         exit_server("reply_nttrans2: data overflow in secondary nttrans packet\n");
2529
2530       memcpy( &params[ IVAL(inbuf, smb_nts_ParameterDisplacement)],
2531               smb_base(inbuf) + IVAL(inbuf, smb_nts_ParameterOffset), parameter_count);
2532       memcpy( &data[IVAL(inbuf, smb_nts_DataDisplacement)],
2533               smb_base(inbuf)+ IVAL(inbuf, smb_nts_DataOffset), data_count);
2534     }
2535   }
2536
2537   if (Protocol >= PROTOCOL_NT1) {
2538     uint16 flg2 = SVAL(outbuf,smb_flg2);
2539     SSVAL(outbuf,smb_flg2,flg2 | 0x40); /* IS_LONG_NAME */
2540   }
2541
2542   /* Now we must call the relevant NT_TRANS function */
2543   switch(function_code) {
2544     case NT_TRANSACT_CREATE:
2545       outsize = call_nt_transact_create(conn, inbuf, outbuf, length, bufsize,
2546                                         &setup, &params, &data);
2547       break;
2548     case NT_TRANSACT_IOCTL:
2549       outsize = call_nt_transact_ioctl(conn,
2550                                        inbuf, outbuf, length, bufsize,
2551                                        &setup, &params, &data);
2552       break;
2553     case NT_TRANSACT_SET_SECURITY_DESC:
2554       outsize = call_nt_transact_set_security_desc(conn, inbuf, outbuf,
2555                                                    length, bufsize,
2556                                                    &setup, &params, &data);
2557       break;
2558     case NT_TRANSACT_NOTIFY_CHANGE:
2559       outsize = call_nt_transact_notify_change(conn, inbuf, outbuf,
2560                                                length, bufsize,
2561                                                &setup, &params, &data);
2562       break;
2563     case NT_TRANSACT_RENAME:
2564       outsize = call_nt_transact_rename(conn, inbuf, outbuf, length,
2565                                         bufsize,
2566                                         &setup, &params, &data);
2567       break;
2568
2569     case NT_TRANSACT_QUERY_SECURITY_DESC:
2570       outsize = call_nt_transact_query_security_desc(conn, inbuf, outbuf,
2571                                                      length, bufsize,
2572                                                      &setup, &params, &data);
2573       break;
2574   default:
2575           /* Error in request */
2576           DEBUG(0,("reply_nttrans: Unknown request %d in nttrans call\n", function_code));
2577           if(setup)
2578                   free(setup);
2579           if(params)
2580                   free(params);
2581           if(data)
2582                   free(data);
2583           return (ERROR(ERRSRV,ERRerror));
2584   }
2585
2586   /* As we do not know how many data packets will need to be
2587      returned here the various call_nt_transact_xxxx calls
2588      must send their own. Thus a call_nt_transact_xxxx routine only
2589      returns a value other than -1 when it wants to send
2590      an error packet.
2591   */
2592
2593   if(setup)
2594     free(setup);
2595   if(params)
2596     free(params);
2597   if(data)
2598     free(data);
2599   return outsize; /* If a correct response was needed the call_nt_transact_xxxx
2600                      calls have already sent it. If outsize != -1 then it is
2601                      returning an error packet. */
2602 }