source/smbd/trans2.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB transaction2 handling
   4    Copyright (C) Jeremy Allison                 1994-2001
   5    Copyright (C) Stefan (metze) Metzmacher      2003
   6
   7    Extensively modified by Andrew Tridgell, 1995
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25
  26 extern int Protocol;
  27 extern BOOL case_sensitive;
  28 extern int smb_read_error;
  29 extern fstring local_machine;
  30 extern int global_oplock_break;
  31 extern uint32 global_client_caps;
  32 extern struct current_user current_user;
  33
  34 #define get_file_size(sbuf) ((sbuf).st_size)
  35
  36 /* given a stat buffer return the allocated size on disk, taking into
  37    account sparse files */
  38 SMB_BIG_UINT get_allocation_size(files_struct *fsp, SMB_STRUCT_STAT *sbuf)
  39 {
  40         SMB_BIG_UINT ret;
  41 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
  42         ret = (SMB_BIG_UINT)STAT_ST_BLOCKSIZE * (SMB_BIG_UINT)sbuf->st_blocks;
  43 #else
  44         ret = (SMB_BIG_UINT)get_file_size(*sbuf);
  45 #endif
  46         if (!ret && fsp && fsp->initial_allocation_size)
  47                 ret = fsp->initial_allocation_size;
  48         ret = SMB_ROUNDUP(ret,SMB_ROUNDUP_ALLOCATION_SIZE);
  49         return ret;
  50 }
  51
  52 /****************************************************************************
  53   Send the required number of replies back.
  54   We assume all fields other than the data fields are
  55   set correctly for the type of call.
  56   HACK ! Always assumes smb_setup field is zero.
  57 ****************************************************************************/
  58
  59 static int send_trans2_replies(char *outbuf,
  60                         int bufsize,
  61                         char *params,
  62                         int paramsize,
  63                         char *pdata,
  64                         int datasize)
  65 {
  66         /* As we are using a protocol > LANMAN1 then the max_send
  67          variable must have been set in the sessetupX call.
  68          This takes precedence over the max_xmit field in the
  69          global struct. These different max_xmit variables should
  70          be merged as this is now too confusing */
  71
  72         extern int max_send;
  73         int data_to_send = datasize;
  74         int params_to_send = paramsize;
  75         int useable_space;
  76         char *pp = params;
  77         char *pd = pdata;
  78         int params_sent_thistime, data_sent_thistime, total_sent_thistime;
  79         int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
  80         int data_alignment_offset = 0;
  81
  82         /* Initially set the wcnt area to be 10 - this is true for all trans2 replies */
  83
  84         set_message(outbuf,10,0,True);
  85
  86         /* If there genuinely are no parameters or data to send just send the empty packet */
  87
  88         if(params_to_send == 0 && data_to_send == 0) {
  89                 if (!send_smb(smbd_server_fd(),outbuf))
  90                         exit_server("send_trans2_replies: send_smb failed.");
  91                 return 0;
  92         }
  93
  94         /* When sending params and data ensure that both are nicely aligned */
  95         /* Only do this alignment when there is also data to send - else
  96                 can cause NT redirector problems. */
  97
  98         if (((params_to_send % 4) != 0) && (data_to_send != 0))
  99                 data_alignment_offset = 4 - (params_to_send % 4);
 100
 101         /* Space is bufsize minus Netbios over TCP header minus SMB header */
 102         /* The alignment_offset is to align the param bytes on an even byte
 103                 boundary. NT 4.0 Beta needs this to work correctly. */
 104
 105         useable_space = bufsize - ((smb_buf(outbuf)+ alignment_offset+data_alignment_offset) - outbuf);
 106
 107         /* useable_space can never be more than max_send minus the alignment offset. */
 108
 109         useable_space = MIN(useable_space, max_send - (alignment_offset+data_alignment_offset));
 110
 111         while (params_to_send || data_to_send) {
 112                 /* Calculate whether we will totally or partially fill this packet */
 113
 114                 total_sent_thistime = params_to_send + data_to_send + alignment_offset + data_alignment_offset;
 115
 116                 /* We can never send more than useable_space */
 117                 /*
 118                  * Note that 'useable_space' does not include the alignment offsets,
 119                  * but we must include the alignment offsets in the calculation of
 120                  * the length of the data we send over the wire, as the alignment offsets
 121                  * are sent here. Fix from Marc_Jacobsen@hp.com.
 122                  */
 123
 124                 total_sent_thistime = MIN(total_sent_thistime, useable_space+ alignment_offset + data_alignment_offset);
 125
 126                 set_message(outbuf, 10, total_sent_thistime, True);
 127
 128                 /* Set total params and data to be sent */
 129                 SSVAL(outbuf,smb_tprcnt,paramsize);
 130                 SSVAL(outbuf,smb_tdrcnt,datasize);
 131
 132                 /* Calculate how many parameters and data we can fit into
 133                  * this packet. Parameters get precedence
 134                  */
 135
 136                 params_sent_thistime = MIN(params_to_send,useable_space);
 137                 data_sent_thistime = useable_space - params_sent_thistime;
 138                 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
 139
 140                 SSVAL(outbuf,smb_prcnt, params_sent_thistime);
 141
 142                 /* smb_proff is the offset from the start of the SMB header to the
 143                         parameter bytes, however the first 4 bytes of outbuf are
 144                         the Netbios over TCP header. Thus use smb_base() to subtract
 145                         them from the calculation */
 146
 147                 SSVAL(outbuf,smb_proff,((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
 148
 149                 if(params_sent_thistime == 0)
 150                         SSVAL(outbuf,smb_prdisp,0);
 151                 else
 152                         /* Absolute displacement of param bytes sent in this packet */
 153                         SSVAL(outbuf,smb_prdisp,pp - params);
 154
 155                 SSVAL(outbuf,smb_drcnt, data_sent_thistime);
 156                 if(data_sent_thistime == 0) {
 157                         SSVAL(outbuf,smb_droff,0);
 158                         SSVAL(outbuf,smb_drdisp, 0);
 159                 } else {
 160                         /* The offset of the data bytes is the offset of the
 161                                 parameter bytes plus the number of parameters being sent this time */
 162                         SSVAL(outbuf,smb_droff,((smb_buf(outbuf)+alignment_offset) -
 163                                 smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
 164                         SSVAL(outbuf,smb_drdisp, pd - pdata);
 165                 }
 166
 167                 /* Copy the param bytes into the packet */
 168
 169                 if(params_sent_thistime)
 170                         memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
 171
 172                 /* Copy in the data bytes */
 173                 if(data_sent_thistime)
 174                         memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
 175                                 data_alignment_offset,pd,data_sent_thistime);
 176
 177                 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
 178                         params_sent_thistime, data_sent_thistime, useable_space));
 179                 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
 180                         params_to_send, data_to_send, paramsize, datasize));
 181
 182                 /* Send the packet */
 183                 if (!send_smb(smbd_server_fd(),outbuf))
 184                         exit_server("send_trans2_replies: send_smb failed.");
 185
 186                 pp += params_sent_thistime;
 187                 pd += data_sent_thistime;
 188
 189                 params_to_send -= params_sent_thistime;
 190                 data_to_send -= data_sent_thistime;
 191
 192                 /* Sanity check */
 193                 if(params_to_send < 0 || data_to_send < 0) {
 194                         DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
 195                                 params_to_send, data_to_send));
 196                         return -1;
 197                 }
 198         }
 199
 200         return 0;
 201 }
 202
 203 /****************************************************************************
 204  Reply to a TRANSACT2_OPEN.
 205 ****************************************************************************/
 206
 207 static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
 208                            char **pparams, int total_params, char **ppdata, int total_data)
 209 {
 210         char *params = *pparams;
 211         int16 open_mode;
 212         int16 open_attr;
 213         BOOL oplock_request;
 214 #if 0
 215         BOOL return_additional_info;
 216         int16 open_sattr;
 217         time_t open_time;
 218 #endif
 219         int16 open_ofun;
 220         int32 open_size;
 221         char *pname;
 222         pstring fname;
 223         mode_t unixmode;
 224         SMB_OFF_T size=0;
 225         int fmode=0,mtime=0,rmode;
 226         SMB_INO_T inode = 0;
 227         SMB_STRUCT_STAT sbuf;
 228         int smb_action = 0;
 229         BOOL bad_path = False;
 230         files_struct *fsp;
 231
 232         /*
 233          * Ensure we have enough parameters to perform the operation.
 234          */
 235
 236         if (total_params < 29)
 237                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
 238
 239         open_mode = SVAL(params, 2);
 240         open_attr = SVAL(params,6);
 241         oplock_request = (((SVAL(params,0)|(1<<1))>>1) | ((SVAL(params,0)|(1<<2))>>1));
 242 #if 0
 243         return_additional_info = BITSETW(params,0);
 244         open_sattr = SVAL(params, 4);
 245         open_time = make_unix_date3(params+8);
 246 #endif
 247         open_ofun = SVAL(params,12);
 248         open_size = IVAL(params,14);
 249         pname = &params[28];
 250
 251         srvstr_pull(inbuf, fname, pname, sizeof(fname), -1, STR_TERMINATE);
 252
 253         DEBUG(3,("trans2open %s mode=%d attr=%d ofun=%d size=%d\n",
 254                 fname,open_mode, open_attr, open_ofun, open_size));
 255
 256         if (IS_IPC(conn))
 257                 return(ERROR_DOS(ERRSRV,ERRaccess));
 258
 259         /* XXXX we need to handle passed times, sattr and flags */
 260
 261         unix_convert(fname,conn,0,&bad_path,&sbuf);
 262
 263         if (!check_name(fname,conn)) {
 264                 set_bad_path_error(errno, bad_path);
 265                 return(UNIXERROR(ERRDOS,ERRnoaccess));
 266         }
 267
 268         unixmode = unix_mode(conn,open_attr | aARCH, fname);
 269
 270         fsp = open_file_shared(conn,fname,&sbuf,open_mode,open_ofun,unixmode,
 271                 oplock_request, &rmode,&smb_action);
 272
 273         if (!fsp) {
 274                 set_bad_path_error(errno, bad_path);
 275                 return(UNIXERROR(ERRDOS,ERRnoaccess));
 276         }
 277
 278         size = get_file_size(sbuf);
 279         fmode = dos_mode(conn,fname,&sbuf);
 280         mtime = sbuf.st_mtime;
 281         inode = sbuf.st_ino;
 282         if (fmode & aDIR) {
 283                 close_file(fsp,False);
 284                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
 285         }
 286
 287         /* Realloc the size of parameters and data we will return */
 288         params = Realloc(*pparams, 28);
 289         if( params == NULL )
 290                 return(ERROR_DOS(ERRDOS,ERRnomem));
 291         *pparams = params;
 292
 293         memset((char *)params,'\0',28);
 294         SSVAL(params,0,fsp->fnum);
 295         SSVAL(params,2,fmode);
 296         put_dos_date2(params,4, mtime);
 297         SIVAL(params,8, (uint32)size);
 298         SSVAL(params,12,rmode);
 299
 300         if (oplock_request && lp_fake_oplocks(SNUM(conn)))
 301                 smb_action |= EXTENDED_OPLOCK_GRANTED;
 302
 303         SSVAL(params,18,smb_action);
 304
 305         /*
 306          * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
 307          */
 308         SIVAL(params,20,inode);
 309
 310         /* Send the required number of replies */
 311         send_trans2_replies(outbuf, bufsize, params, 28, *ppdata, 0);
 312
 313         return -1;
 314 }
 315
 316 /*********************************************************
 317  Routine to check if a given string matches exactly.
 318  as a special case a mask of "." does NOT match. That
 319  is required for correct wildcard semantics
 320  Case can be significant or not.
 321 **********************************************************/
 322
 323 static BOOL exact_match(char *str,char *mask, BOOL case_sig)
 324 {
 325         if (mask[0] == '.' && mask[1] == 0)
 326                 return False;
 327         if (case_sig)
 328                 return strcmp(str,mask)==0;
 329         return strcasecmp(str,mask) == 0;
 330 }
 331
 332 /****************************************************************************
 333  Return the filetype for UNIX extensions.
 334 ****************************************************************************/
 335
 336 static uint32 unix_filetype(mode_t mode)
 337 {
 338         if(S_ISREG(mode))
 339                 return UNIX_TYPE_FILE;
 340         else if(S_ISDIR(mode))
 341                 return UNIX_TYPE_DIR;
 342 #ifdef S_ISLNK
 343         else if(S_ISLNK(mode))
 344                 return UNIX_TYPE_SYMLINK;
 345 #endif
 346 #ifdef S_ISCHR
 347         else if(S_ISCHR(mode))
 348                 return UNIX_TYPE_CHARDEV;
 349 #endif
 350 #ifdef S_ISBLK
 351         else if(S_ISBLK(mode))
 352                 return UNIX_TYPE_BLKDEV;
 353 #endif
 354 #ifdef S_ISFIFO
 355         else if(S_ISFIFO(mode))
 356                 return UNIX_TYPE_FIFO;
 357 #endif
 358 #ifdef S_ISSOCK
 359         else if(S_ISSOCK(mode))
 360                 return UNIX_TYPE_SOCKET;
 361 #endif
 362
 363         DEBUG(0,("unix_filetype: unknown filetype %u", (unsigned)mode));
 364         return UNIX_TYPE_UNKNOWN;
 365 }
 366
 367 /****************************************************************************
 368  Return the major devicenumber for UNIX extensions.
 369 ****************************************************************************/
 370
 371 static uint32 unix_dev_major(SMB_DEV_T dev)
 372 {
 373 #if defined(HAVE_DEVICE_MAJOR_FN)
 374         return (uint32)major(dev);
 375 #else
 376         return (uint32)(dev >> 8);
 377 #endif
 378 }
 379
 380 /****************************************************************************
 381  Return the minor devicenumber for UNIX extensions.
 382 ****************************************************************************/
 383
 384 static uint32 unix_dev_minor(SMB_DEV_T dev)
 385 {
 386 #if defined(HAVE_DEVICE_MINOR_FN)
 387         return (uint32)minor(dev);
 388 #else
 389         return (uint32)(dev & 0xff);
 390 #endif
 391 }
 392
 393 /****************************************************************************
 394  Map wire perms onto standard UNIX permissions. Obey share restrictions.
 395 ****************************************************************************/
 396
 397 static mode_t unix_perms_from_wire( connection_struct *conn, SMB_STRUCT_STAT *pst, uint32 perms)
 398 {
 399         mode_t ret = 0;
 400
 401         if (perms == SMB_MODE_NO_CHANGE)
 402                 return pst->st_mode;
 403
 404         ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
 405         ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
 406         ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
 407         ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
 408         ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
 409         ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
 410         ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
 411         ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
 412         ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
 413 #ifdef S_ISVTX
 414         ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
 415 #endif
 416 #ifdef S_ISGID
 417         ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
 418 #endif
 419 #ifdef S_ISUID
 420         ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
 421 #endif
 422
 423         if (VALID_STAT(*pst) && S_ISDIR(pst->st_mode)) {
 424                 ret &= lp_dir_mask(SNUM(conn));
 425                 /* Add in force bits */
 426                 ret |= lp_force_dir_mode(SNUM(conn));
 427         } else {
 428                 /* Apply mode mask */
 429                 ret &= lp_create_mask(SNUM(conn));
 430                 /* Add in force bits */
 431                 ret |= lp_force_create_mode(SNUM(conn));
 432         }
 433
 434         return ret;
 435 }
 436
 437 /****************************************************************************
 438 checks for SMB_TIME_NO_CHANGE and if not found
 439 calls interpret_long_date
 440 ****************************************************************************/
 441 time_t interpret_long_unix_date(char *p)
 442 {
 443         DEBUG(1,("interpret_long_unix_date\n"));
 444         if(IVAL(p,0) == SMB_TIME_NO_CHANGE_LO &&
 445            IVAL(p,4) == SMB_TIME_NO_CHANGE_HI) {
 446                 return -1;
 447         } else {
 448                 return interpret_long_date(p);
 449         }
 450 }
 451
 452 /****************************************************************************
 453  Get a level dependent lanman2 dir entry.
 454 ****************************************************************************/
 455
 456 static BOOL get_lanman2_dir_entry(connection_struct *conn,
 457                                   void *inbuf, void *outbuf,
 458                                  char *path_mask,int dirtype,int info_level,
 459                                  int requires_resume_key,
 460                                  BOOL dont_descend,char **ppdata,
 461                                  char *base_data, int space_remaining,
 462                                  BOOL *out_of_space, BOOL *got_exact_match,
 463                                  int *last_name_off)
 464 {
 465         const char *dname;
 466         BOOL found = False;
 467         SMB_STRUCT_STAT sbuf;
 468         pstring mask;
 469         pstring pathreal;
 470         pstring fname;
 471         char *p, *q, *pdata = *ppdata;
 472         uint32 reskey=0;
 473         int prev_dirpos=0;
 474         int mode=0;
 475         SMB_OFF_T file_size = 0;
 476         SMB_BIG_UINT allocation_size = 0;
 477         uint32 len;
 478         time_t mdate=0, adate=0, cdate=0;
 479         char *nameptr;
 480         BOOL was_8_3;
 481         int nt_extmode; /* Used for NT connections instead of mode */
 482         BOOL needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
 483
 484         *fname = 0;
 485         *out_of_space = False;
 486         *got_exact_match = False;
 487
 488         if (!conn->dirptr)
 489                 return(False);
 490
 491         p = strrchr_m(path_mask,'/');
 492         if(p != NULL) {
 493                 if(p[1] == '\0')
 494                         pstrcpy(mask,"*.*");
 495                 else
 496                         pstrcpy(mask, p+1);
 497         } else
 498                 pstrcpy(mask, path_mask);
 499
 500         while (!found) {
 501                 BOOL got_match;
 502
 503                 /* Needed if we run out of space */
 504                 prev_dirpos = TellDir(conn->dirptr);
 505                 dname = ReadDirName(conn->dirptr);
 506
 507                 /*
 508                  * Due to bugs in NT client redirectors we are not using
 509                  * resume keys any more - set them to zero.
 510                  * Check out the related comments in findfirst/findnext.
 511                  * JRA.
 512                  */
 513
 514                 reskey = 0;
 515
 516                 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %d\n",
 517                         (long)conn->dirptr,TellDir(conn->dirptr)));
 518
 519                 if (!dname)
 520                         return(False);
 521
 522                 pstrcpy(fname,dname);
 523
 524                 if(!(got_match = *got_exact_match = exact_match(fname, mask, case_sensitive)))
 525                         got_match = mask_match(fname, mask, case_sensitive);
 526
 527                 if(!got_match && !mangle_is_8_3(fname, False)) {
 528
 529                         /*
 530                          * It turns out that NT matches wildcards against
 531                          * both long *and* short names. This may explain some
 532                          * of the wildcard wierdness from old DOS clients
 533                          * that some people have been seeing.... JRA.
 534                          */
 535
 536                         pstring newname;
 537                         pstrcpy( newname, fname);
 538                         mangle_map( newname, True, False, SNUM(conn));
 539                         if(!(got_match = *got_exact_match = exact_match(newname, mask, case_sensitive)))
 540                                 got_match = mask_match(newname, mask, case_sensitive);
 541                 }
 542
 543                 if(got_match) {
 544                         BOOL isdots = (strequal(fname,"..") || strequal(fname,"."));
 545                         if (dont_descend && !isdots)
 546                                 continue;
 547
 548                         pstrcpy(pathreal,conn->dirpath);
 549                         if(needslash)
 550                                 pstrcat(pathreal,"/");
 551                         pstrcat(pathreal,dname);
 552
 553                         if (INFO_LEVEL_IS_UNIX(info_level)) {
 554                                 if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
 555                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
 556                                                 pathreal,strerror(errno)));
 557                                         continue;
 558                                 }
 559                         } else if (SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
 560
 561                                 /* Needed to show the msdfs symlinks as
 562                                  * directories */
 563
 564                                 if(lp_host_msdfs() &&
 565                                    lp_msdfs_root(SNUM(conn)) &&
 566                                    is_msdfs_link(conn, pathreal, NULL, NULL,
 567                                                  &sbuf)) {
 568
 569                                         DEBUG(5,("get_lanman2_dir_entry: Masquerading msdfs link %s as a directory\n", pathreal));
 570                                         sbuf.st_mode = (sbuf.st_mode & 0xFFF) | S_IFDIR;
 571
 572                                 } else {
 573
 574                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
 575                                                 pathreal,strerror(errno)));
 576                                         continue;
 577                                 }
 578                         }
 579
 580                         mode = dos_mode(conn,pathreal,&sbuf);
 581
 582                         if (!dir_check_ftype(conn,mode,&sbuf,dirtype)) {
 583                                 DEBUG(5,("[%s] attribs didn't match %x\n",fname,dirtype));
 584                                 continue;
 585                         }
 586
 587                         file_size = get_file_size(sbuf);
 588                         allocation_size = get_allocation_size(NULL,&sbuf);
 589                         mdate = sbuf.st_mtime;
 590                         adate = sbuf.st_atime;
 591                         cdate = get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
 592
 593                         if (lp_dos_filetime_resolution(SNUM(conn))) {
 594                                 cdate &= ~1;
 595                                 mdate &= ~1;
 596                                 adate &= ~1;
 597                         }
 598
 599                         if(mode & aDIR)
 600                                 file_size = 0;
 601
 602                         DEBUG(5,("get_lanman2_dir_entry found %s fname=%s\n",pathreal,fname));
 603
 604                         found = True;
 605                 }
 606         }
 607
 608         mangle_map(fname,False,True,SNUM(conn));
 609
 610         p = pdata;
 611         nameptr = p;
 612
 613         nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
 614
 615         switch (info_level) {
 616                 case SMB_INFO_STANDARD:
 617                         if(requires_resume_key) {
 618                                 SIVAL(p,0,reskey);
 619                                 p += 4;
 620                         }
 621                         put_dos_date2(p,l1_fdateCreation,cdate);
 622                         put_dos_date2(p,l1_fdateLastAccess,adate);
 623                         put_dos_date2(p,l1_fdateLastWrite,mdate);
 624                         SIVAL(p,l1_cbFile,(uint32)file_size);
 625                         SIVAL(p,l1_cbFileAlloc,(uint32)allocation_size);
 626                         SSVAL(p,l1_attrFile,mode);
 627                         p += l1_achName;
 628                         nameptr = p;
 629                         p += align_string(outbuf, p, 0);
 630                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
 631                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS)
 632                                 SCVAL(nameptr, -1, len-2);
 633                         else
 634                                 SCVAL(nameptr, -1, len-1);
 635                         p += len;
 636                         break;
 637
 638                 case SMB_INFO_QUERY_EA_SIZE:
 639                         if(requires_resume_key) {
 640                                 SIVAL(p,0,reskey);
 641                                 p += 4;
 642                         }
 643                         put_dos_date2(p,l2_fdateCreation,cdate);
 644                         put_dos_date2(p,l2_fdateLastAccess,adate);
 645                         put_dos_date2(p,l2_fdateLastWrite,mdate);
 646                         SIVAL(p,l2_cbFile,(uint32)file_size);
 647                         SIVAL(p,l2_cbFileAlloc,(uint32)allocation_size);
 648                         SSVAL(p,l2_attrFile,mode);
 649                         SIVAL(p,l2_cbList,0); /* No extended attributes */
 650                         p += l2_achName;
 651                         nameptr = p;
 652                         p += align_string(outbuf, p, 0);
 653                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
 654                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS)
 655                                 SCVAL(nameptr, -1, len-2);
 656                         else
 657                                 SCVAL(nameptr, -1, len-1);
 658                         p += len;
 659                         break;
 660
 661                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
 662                         was_8_3 = mangle_is_8_3(fname, True);
 663                         p += 4;
 664                         SIVAL(p,0,reskey); p += 4;
 665                         put_long_date(p,cdate); p += 8;
 666                         put_long_date(p,adate); p += 8;
 667                         put_long_date(p,mdate); p += 8;
 668                         put_long_date(p,mdate); p += 8;
 669                         SOFF_T(p,0,file_size);
 670                         SOFF_T(p,8,allocation_size);
 671                         p += 16;
 672                         SIVAL(p,0,nt_extmode); p += 4;
 673                         q = p; p += 4;
 674                         SIVAL(p,0,0); p += 4;
 675                         /* Clear the short name buffer. This is
 676                          * IMPORTANT as not doing so will trigger
 677                          * a Win2k client bug. JRA.
 678                          */
 679                         memset(p,'\0',26);
 680                         if (!was_8_3) {
 681                                 pstring mangled_name;
 682                                 pstrcpy(mangled_name, fname);
 683                                 mangle_map(mangled_name,True,True,SNUM(conn));
 684                                 mangled_name[12] = 0;
 685                                 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER);
 686                                 SSVAL(p, 0, len);
 687                         } else {
 688                                 SSVAL(p,0,0);
 689                                 *(p+2) = 0;
 690                         }
 691                         p += 2 + 24;
 692                         len = srvstr_push(outbuf, p, fname, -1, 0);
 693                         SIVAL(q,0,len);
 694                         p += len;
 695                         len = PTR_DIFF(p, pdata);
 696                         len = (len + 3) & ~3;
 697                         SIVAL(pdata,0,len);
 698                         p = pdata + len;
 699                         break;
 700
 701                 case SMB_FIND_FILE_DIRECTORY_INFO:
 702                         p += 4;
 703                         SIVAL(p,0,reskey); p += 4;
 704                         put_long_date(p,cdate); p += 8;
 705                         put_long_date(p,adate); p += 8;
 706                         put_long_date(p,mdate); p += 8;
 707                         put_long_date(p,mdate); p += 8;
 708                         SOFF_T(p,0,file_size);
 709                         SOFF_T(p,8,allocation_size);
 710                         p += 16;
 711                         SIVAL(p,0,nt_extmode); p += 4;
 712                         p += 4;
 713                         len = srvstr_push(outbuf, p, fname, -1, 0);
 714                         SIVAL(p, -4, len);
 715                         p += len;
 716                         len = PTR_DIFF(p, pdata);
 717                         len = (len + 3) & ~3;
 718                         SIVAL(pdata,0,len);
 719                         p = pdata + len;
 720                         break;
 721
 722                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
 723                         p += 4;
 724                         SIVAL(p,0,reskey); p += 4;
 725                         put_long_date(p,cdate); p += 8;
 726                         put_long_date(p,adate); p += 8;
 727                         put_long_date(p,mdate); p += 8;
 728                         put_long_date(p,mdate); p += 8;
 729                         SOFF_T(p,0,file_size);
 730                         SOFF_T(p,8,allocation_size);
 731                         p += 16;
 732                         SIVAL(p,0,nt_extmode); p += 4;
 733                         p += 4;
 734                         SIVAL(p,0,0); p += 4;
 735
 736                         len = srvstr_push(outbuf, p, fname, -1, 0);
 737                         SIVAL(p, -4, len);
 738                         p += len;
 739
 740                         len = PTR_DIFF(p, pdata);
 741                         len = (len + 3) & ~3;
 742                         SIVAL(pdata,0,len);
 743                         p = pdata + len;
 744                         break;
 745
 746                 case SMB_FIND_FILE_NAMES_INFO:
 747                         p += 4;
 748                         SIVAL(p,0,reskey); p += 4;
 749                         p += 4;
 750                         /* this must *not* be null terminated or w2k gets in a loop trying to set an
 751                            acl on a dir (tridge) */
 752                         len = srvstr_push(outbuf, p, fname, -1, 0);
 753                         SIVAL(p, -4, len);
 754                         p += len;
 755                         len = PTR_DIFF(p, pdata);
 756                         len = (len + 3) & ~3;
 757                         SIVAL(pdata,0,len);
 758                         p = pdata + len;
 759                         break;
 760
 761                 /* CIFS UNIX Extension. */
 762
 763                 case SMB_FIND_FILE_UNIX:
 764                         p+= 4;
 765                         SIVAL(p,0,reskey); p+= 4;    /* Used for continuing search. */
 766
 767                         /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
 768                         SOFF_T(p,0,get_file_size(sbuf));             /* File size 64 Bit */
 769                         p+= 8;
 770
 771                         SOFF_T(p,0,get_allocation_size(NULL,&sbuf)); /* Number of bytes used on disk - 64 Bit */
 772                         p+= 8;
 773
 774                         put_long_date(p,sbuf.st_ctime);       /* Creation Time 64 Bit */
 775                         put_long_date(p+8,sbuf.st_atime);     /* Last access time 64 Bit */
 776                         put_long_date(p+16,sbuf.st_mtime);    /* Last modification time 64 Bit */
 777                         p+= 24;
 778
 779                         SIVAL(p,0,sbuf.st_uid);               /* user id for the owner */
 780                         SIVAL(p,4,0);
 781                         p+= 8;
 782
 783                         SIVAL(p,0,sbuf.st_gid);               /* group id of owner */
 784                         SIVAL(p,4,0);
 785                         p+= 8;
 786
 787                         SIVAL(p,0,unix_filetype(sbuf.st_mode));
 788                         p+= 4;
 789
 790                         SIVAL(p,0,unix_dev_major(sbuf.st_rdev));   /* Major device number if type is device */
 791                         SIVAL(p,4,0);
 792                         p+= 8;
 793
 794                         SIVAL(p,0,unix_dev_minor(sbuf.st_rdev));   /* Minor device number if type is device */
 795                         SIVAL(p,4,0);
 796                         p+= 8;
 797
 798                         SINO_T(p,0,(SMB_INO_T)sbuf.st_ino);   /* inode number */
 799                         p+= 8;
 800
 801                         SIVAL(p,0, unix_perms_to_wire(sbuf.st_mode));     /* Standard UNIX file permissions */
 802                         SIVAL(p,4,0);
 803                         p+= 8;
 804
 805                         SIVAL(p,0,sbuf.st_nlink);             /* number of hard links */
 806                         SIVAL(p,4,0);
 807                         p+= 8;
 808
 809                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
 810                         p += len;
 811
 812                         len = PTR_DIFF(p, pdata);
 813                         len = (len + 3) & ~3;
 814                         SIVAL(pdata,0,len);     /* Offset from this structure to the beginning of the next one */
 815                         p = pdata + len;
 816                         /* End of SMB_QUERY_FILE_UNIX_BASIC */
 817
 818                         break;
 819
 820                 default:
 821                         return(False);
 822         }
 823
 824
 825         if (PTR_DIFF(p,pdata) > space_remaining) {
 826                 /* Move the dirptr back to prev_dirpos */
 827                 SeekDir(conn->dirptr, prev_dirpos);
 828                 *out_of_space = True;
 829                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
 830                 return False; /* Not finished - just out of space */
 831         }
 832
 833         /* Setup the last_filename pointer, as an offset from base_data */
 834         *last_name_off = PTR_DIFF(nameptr,base_data);
 835         /* Advance the data pointer to the next slot */
 836         *ppdata = p;
 837
 838         return(found);
 839 }
 840
 841 /****************************************************************************
 842  Reply to a TRANS2_FINDFIRST.
 843 ****************************************************************************/
 844
 845 static int call_trans2findfirst(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
 846                                 char **pparams, int total_params, char **ppdata, int total_data)
 847 {
 848         /* We must be careful here that we don't return more than the
 849                 allowed number of data bytes. If this means returning fewer than
 850                 maxentries then so be it. We assume that the redirector has
 851                 enough room for the fixed number of parameter bytes it has
 852                 requested. */
 853         uint32 max_data_bytes = SVAL(inbuf, smb_mdrcnt);
 854         char *params = *pparams;
 855         char *pdata = *ppdata;
 856         int dirtype = SVAL(params,0);
 857         int maxentries = SVAL(params,2);
 858         BOOL close_after_first = BITSETW(params+4,0);
 859         BOOL close_if_end = BITSETW(params+4,1);
 860         BOOL requires_resume_key = BITSETW(params+4,2);
 861         int info_level = SVAL(params,6);
 862         pstring directory;
 863         pstring mask;
 864         char *p, *wcard;
 865         int last_name_off=0;
 866         int dptr_num = -1;
 867         int numentries = 0;
 868         int i;
 869         BOOL finished = False;
 870         BOOL dont_descend = False;
 871         BOOL out_of_space = False;
 872         int space_remaining;
 873         BOOL bad_path = False;
 874         SMB_STRUCT_STAT sbuf;
 875
 876         if (total_params < 12)
 877                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
 878
 879         *directory = *mask = 0;
 880
 881         DEBUG(3,("call_trans2findfirst: dirtype = %d, maxentries = %d, close_after_first=%d, \
 882 close_if_end = %d requires_resume_key = %d level = %d, max_data_bytes = %d\n",
 883                 dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
 884                 info_level, max_data_bytes));
 885
 886         switch (info_level) {
 887                 case SMB_INFO_STANDARD:
 888                 case SMB_INFO_QUERY_EA_SIZE:
 889                 case SMB_FIND_FILE_DIRECTORY_INFO:
 890                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
 891                 case SMB_FIND_FILE_NAMES_INFO:
 892                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
 893                         break;
 894                 case SMB_FIND_FILE_UNIX:
 895                         if (!lp_unix_extensions())
 896                                 return(ERROR_DOS(ERRDOS,ERRunknownlevel));
 897                         break;
 898                 default:
 899                         return(ERROR_DOS(ERRDOS,ERRunknownlevel));
 900         }
 901
 902         srvstr_pull(inbuf, directory, params+12, sizeof(directory), -1, STR_TERMINATE);
 903
 904         RESOLVE_FINDFIRST_DFSPATH(directory, conn, inbuf, outbuf);
 905
 906         unix_convert(directory,conn,0,&bad_path,&sbuf);
 907         if(!check_name(directory,conn)) {
 908                 set_bad_path_error(errno, bad_path);
 909                 return(UNIXERROR(ERRDOS,ERRbadpath));
 910         }
 911
 912         p = strrchr_m(directory,'/');
 913         if(p == NULL) {
 914                 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
 915                 if((directory[0] == '.') && (directory[1] == '\0'))
 916                         pstrcpy(mask,"*");
 917                 else
 918                         pstrcpy(mask,directory);
 919                 pstrcpy(directory,"./");
 920         } else {
 921                 pstrcpy(mask,p+1);
 922                 *p = 0;
 923         }
 924
 925         DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
 926
 927         pdata = Realloc(*ppdata, max_data_bytes + 1024);
 928         if( pdata == NULL )
 929                 return(ERROR_DOS(ERRDOS,ERRnomem));
 930
 931         *ppdata = pdata;
 932         memset((char *)pdata,'\0',max_data_bytes + 1024);
 933
 934         /* Realloc the params space */
 935         params = Realloc(*pparams, 10);
 936         if (params == NULL)
 937                 return ERROR_DOS(ERRDOS,ERRnomem);
 938         *pparams = params;
 939
 940         dptr_num = dptr_create(conn,directory, False, True ,SVAL(inbuf,smb_pid));
 941         if (dptr_num < 0)
 942                 return(UNIXERROR(ERRDOS,ERRbadfile));
 943
 944         /* Save the wildcard match and attribs we are using on this directory -
 945                 needed as lanman2 assumes these are being saved between calls */
 946
 947         if(!(wcard = strdup(mask))) {
 948                 dptr_close(&dptr_num);
 949                 return ERROR_DOS(ERRDOS,ERRnomem);
 950         }
 951
 952         dptr_set_wcard(dptr_num, wcard);
 953         dptr_set_attr(dptr_num, dirtype);
 954
 955         DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n",dptr_num, wcard, dirtype));
 956
 957         /* We don't need to check for VOL here as this is returned by
 958                 a different TRANS2 call. */
 959
 960         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn->dirpath,lp_dontdescend(SNUM(conn))));
 961         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),case_sensitive))
 962                 dont_descend = True;
 963
 964         p = pdata;
 965         space_remaining = max_data_bytes;
 966         out_of_space = False;
 967
 968         for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
 969                 BOOL got_exact_match = False;
 970
 971                 /* this is a heuristic to avoid seeking the dirptr except when
 972                         absolutely necessary. It allows for a filename of about 40 chars */
 973                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
 974                         out_of_space = True;
 975                         finished = False;
 976                 } else {
 977                         finished = !get_lanman2_dir_entry(conn,
 978                                         inbuf, outbuf,
 979                                         mask,dirtype,info_level,
 980                                         requires_resume_key,dont_descend,
 981                                         &p,pdata,space_remaining, &out_of_space, &got_exact_match,
 982                                         &last_name_off);
 983                 }
 984
 985                 if (finished && out_of_space)
 986                         finished = False;
 987
 988                 if (!finished && !out_of_space)
 989                         numentries++;
 990
 991                 /*
 992                  * As an optimisation if we know we aren't looking
 993                  * for a wildcard name (ie. the name matches the wildcard exactly)
 994                  * then we can finish on any (first) match.
 995                  * This speeds up large directory searches. JRA.
 996                  */
 997
 998                 if(got_exact_match)
 999                         finished = True;
1000
1001                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1002         }
1003
1004         /* Check if we can close the dirptr */
1005         if(close_after_first || (finished && close_if_end)) {
1006                 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
1007                 dptr_close(&dptr_num);
1008         }
1009
1010         /*
1011          * If there are no matching entries we must return ERRDOS/ERRbadfile -
1012          * from observation of NT.
1013          */
1014
1015         if(numentries == 0) {
1016                 dptr_close(&dptr_num);
1017                 return ERROR_DOS(ERRDOS,ERRbadfile);
1018         }
1019
1020         /* At this point pdata points to numentries directory entries. */
1021
1022         /* Set up the return parameter block */
1023         SSVAL(params,0,dptr_num);
1024         SSVAL(params,2,numentries);
1025         SSVAL(params,4,finished);
1026         SSVAL(params,6,0); /* Never an EA error */
1027         SSVAL(params,8,last_name_off);
1028
1029         send_trans2_replies( outbuf, bufsize, params, 10, pdata, PTR_DIFF(p,pdata));
1030
1031         if ((! *directory) && dptr_path(dptr_num))
1032                 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1033
1034         DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1035                 smb_fn_name(CVAL(inbuf,smb_com)),
1036                 mask, directory, dirtype, numentries ) );
1037
1038         /*
1039          * Force a name mangle here to ensure that the
1040          * mask as an 8.3 name is top of the mangled cache.
1041          * The reasons for this are subtle. Don't remove
1042          * this code unless you know what you are doing
1043          * (see PR#13758). JRA.
1044          */
1045
1046         if(!mangle_is_8_3_wildcards( mask, False))
1047                 mangle_map(mask, True, True, SNUM(conn));
1048
1049         return(-1);
1050 }
1051
1052 /****************************************************************************
1053  Reply to a TRANS2_FINDNEXT.
1054 ****************************************************************************/
1055
1056 static int call_trans2findnext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
1057                                         char **pparams, int total_params, char **ppdata, int total_data)
1058 {
1059         /* We must be careful here that we don't return more than the
1060                 allowed number of data bytes. If this means returning fewer than
1061                 maxentries then so be it. We assume that the redirector has
1062                 enough room for the fixed number of parameter bytes it has
1063                 requested. */
1064         int max_data_bytes = SVAL(inbuf, smb_mdrcnt);
1065         char *params = *pparams;
1066         char *pdata = *ppdata;
1067         int dptr_num = SVAL(params,0);
1068         int maxentries = SVAL(params,2);
1069         uint16 info_level = SVAL(params,4);
1070         uint32 resume_key = IVAL(params,6);
1071         BOOL close_after_request = BITSETW(params+10,0);
1072         BOOL close_if_end = BITSETW(params+10,1);
1073         BOOL requires_resume_key = BITSETW(params+10,2);
1074         BOOL continue_bit = BITSETW(params+10,3);
1075         pstring resume_name;
1076         pstring mask;
1077         pstring directory;
1078         char *p;
1079         uint16 dirtype;
1080         int numentries = 0;
1081         int i, last_name_off=0;
1082         BOOL finished = False;
1083         BOOL dont_descend = False;
1084         BOOL out_of_space = False;
1085         int space_remaining;
1086
1087         if (total_params < 12)
1088                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
1089
1090         *mask = *directory = *resume_name = 0;
1091
1092         srvstr_pull(inbuf, resume_name, params+12, sizeof(resume_name), -1, STR_TERMINATE);
1093
1094         DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
1095 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
1096 resume_key = %d resume name = %s continue=%d level = %d\n",
1097                 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
1098                 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
1099
1100         switch (info_level) {
1101                 case SMB_INFO_STANDARD:
1102                 case SMB_INFO_QUERY_EA_SIZE:
1103                 case SMB_FIND_FILE_DIRECTORY_INFO:
1104                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1105                 case SMB_FIND_FILE_NAMES_INFO:
1106                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1107                         break;
1108                 case SMB_FIND_FILE_UNIX:
1109                         if (!lp_unix_extensions())
1110                                 return(ERROR_DOS(ERRDOS,ERRunknownlevel));
1111                         break;
1112                 default:
1113                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
1114         }
1115
1116         pdata = Realloc( *ppdata, max_data_bytes + 1024);
1117         if(pdata == NULL)
1118                 return ERROR_DOS(ERRDOS,ERRnomem);
1119
1120         *ppdata = pdata;
1121         memset((char *)pdata,'\0',max_data_bytes + 1024);
1122
1123         /* Realloc the params space */
1124         params = Realloc(*pparams, 6*SIZEOFWORD);
1125         if( params == NULL )
1126                 return ERROR_DOS(ERRDOS,ERRnomem);
1127
1128         *pparams = params;
1129
1130         /* Check that the dptr is valid */
1131         if(!(conn->dirptr = dptr_fetch_lanman2(dptr_num)))
1132                 return ERROR_DOS(ERRDOS,ERRnofiles);
1133
1134         string_set(&conn->dirpath,dptr_path(dptr_num));
1135
1136         /* Get the wildcard mask from the dptr */
1137         if((p = dptr_wcard(dptr_num))== NULL) {
1138                 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
1139                 return ERROR_DOS(ERRDOS,ERRnofiles);
1140         }
1141
1142         pstrcpy(mask, p);
1143         pstrcpy(directory,conn->dirpath);
1144
1145         /* Get the attr mask from the dptr */
1146         dirtype = dptr_attr(dptr_num);
1147
1148         DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%d)\n",
1149                 dptr_num, mask, dirtype,
1150                 (long)conn->dirptr,
1151                 TellDir(conn->dirptr)));
1152
1153         /* We don't need to check for VOL here as this is returned by
1154                 a different TRANS2 call. */
1155
1156         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn->dirpath,lp_dontdescend(SNUM(conn))));
1157         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),case_sensitive))
1158                 dont_descend = True;
1159
1160         p = pdata;
1161         space_remaining = max_data_bytes;
1162         out_of_space = False;
1163
1164         /*
1165          * Seek to the correct position. We no longer use the resume key but
1166          * depend on the last file name instead.
1167          */
1168
1169         if(requires_resume_key && *resume_name && !continue_bit) {
1170
1171                 /*
1172                  * Fix for NT redirector problem triggered by resume key indexes
1173                  * changing between directory scans. We now return a resume key of 0
1174                  * and instead look for the filename to continue from (also given
1175                  * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
1176                  * findfirst/findnext (as is usual) then the directory pointer
1177                  * should already be at the correct place. Check this by scanning
1178                  * backwards looking for an exact (ie. case sensitive) filename match.
1179                  * If we get to the beginning of the directory and haven't found it then scan
1180                  * forwards again looking for a match. JRA.
1181                  */
1182
1183                 int current_pos, start_pos;
1184                 const char *dname = NULL;
1185                 pstring dname_pstring;
1186                 void *dirptr = conn->dirptr;
1187                 start_pos = TellDir(dirptr);
1188                 for(current_pos = start_pos; current_pos >= 0; current_pos--) {
1189                         DEBUG(7,("call_trans2findnext: seeking to pos %d\n", current_pos));
1190
1191                         SeekDir(dirptr, current_pos);
1192                         dname = ReadDirName(dirptr);
1193                         if (dname) {
1194                                 /*
1195                                  * Remember, mangle_map is called by
1196                                  * get_lanman2_dir_entry(), so the resume name
1197                                  * could be mangled. Ensure we do the same
1198                                  * here.
1199                                  */
1200
1201                                 /* make sure we get a copy that mangle_map can modify */
1202
1203                                 pstrcpy(dname_pstring, dname);
1204                                 mangle_map( dname_pstring, False, True, SNUM(conn));
1205
1206                                 if(strcsequal( resume_name, dname_pstring)) {
1207                                         SeekDir(dirptr, current_pos+1);
1208                                         DEBUG(7,("call_trans2findnext: got match at pos %d\n", current_pos+1 ));
1209                                         break;
1210                                 }
1211                         }
1212                 }
1213
1214                 /*
1215                  * Scan forward from start if not found going backwards.
1216                  */
1217
1218                 if(current_pos < 0) {
1219                         DEBUG(7,("call_trans2findnext: notfound: seeking to pos %d\n", start_pos));
1220                         SeekDir(dirptr, start_pos);
1221                         for(current_pos = start_pos; (dname = ReadDirName(dirptr)) != NULL; SeekDir(dirptr,++current_pos)) {
1222
1223                                 /*
1224                                  * Remember, mangle_map is called by
1225                                  * get_lanman2_dir_entry(), so the resume name
1226                                  * could be mangled. Ensure we do the same
1227                                  * here.
1228                                  */
1229
1230                                 if(dname) {
1231                                         /* make sure we get a copy that mangle_map can modify */
1232
1233                                         pstrcpy(dname_pstring, dname);
1234                                         mangle_map(dname_pstring, False, True, SNUM(conn));
1235
1236                                         if(strcsequal( resume_name, dname_pstring)) {
1237                                                 SeekDir(dirptr, current_pos+1);
1238                                                 DEBUG(7,("call_trans2findnext: got match at pos %d\n", current_pos+1 ));
1239                                                 break;
1240                                         }
1241                                 }
1242                         } /* end for */
1243                 } /* end if current_pos */
1244         } /* end if requires_resume_key && !continue_bit */
1245
1246         for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
1247                 BOOL got_exact_match = False;
1248
1249                 /* this is a heuristic to avoid seeking the dirptr except when
1250                         absolutely necessary. It allows for a filename of about 40 chars */
1251                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
1252                         out_of_space = True;
1253                         finished = False;
1254                 } else {
1255                         finished = !get_lanman2_dir_entry(conn,
1256                                                 inbuf, outbuf,
1257                                                 mask,dirtype,info_level,
1258                                                 requires_resume_key,dont_descend,
1259                                                 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
1260                                                 &last_name_off);
1261                 }
1262
1263                 if (finished && out_of_space)
1264                         finished = False;
1265
1266                 if (!finished && !out_of_space)
1267                         numentries++;
1268
1269                 /*
1270                  * As an optimisation if we know we aren't looking
1271                  * for a wildcard name (ie. the name matches the wildcard exactly)
1272                  * then we can finish on any (first) match.
1273                  * This speeds up large directory searches. JRA.
1274                  */
1275
1276                 if(got_exact_match)
1277                         finished = True;
1278
1279                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1280         }
1281
1282         /* Check if we can close the dirptr */
1283         if(close_after_request || (finished && close_if_end)) {
1284                 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
1285                 dptr_close(&dptr_num); /* This frees up the saved mask */
1286         }
1287
1288         /* Set up the return parameter block */
1289         SSVAL(params,0,numentries);
1290         SSVAL(params,2,finished);
1291         SSVAL(params,4,0); /* Never an EA error */
1292         SSVAL(params,6,last_name_off);
1293
1294         send_trans2_replies( outbuf, bufsize, params, 8, pdata, PTR_DIFF(p,pdata));
1295
1296         if ((! *directory) && dptr_path(dptr_num))
1297                 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1298
1299         DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1300                 smb_fn_name(CVAL(inbuf,smb_com)),
1301                 mask, directory, dirtype, numentries ) );
1302
1303         return(-1);
1304 }
1305
1306 /****************************************************************************
1307  Reply to a TRANS2_QFSINFO (query filesystem info).
1308 ****************************************************************************/
1309
1310 static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf,
1311                         int length, int bufsize,
1312                         char **pparams, int total_params, char **ppdata, int total_data)
1313 {
1314         int max_data_bytes = SVAL(inbuf, smb_mdrcnt);
1315         char *pdata = *ppdata;
1316         char *params = *pparams;
1317         uint16 info_level = SVAL(params,0);
1318         int data_len, len;
1319         SMB_STRUCT_STAT st;
1320         char *vname = volume_label(SNUM(conn));
1321         int snum = SNUM(conn);
1322         char *fstype = lp_fstype(SNUM(conn));
1323         int quota_flag = 0;
1324
1325         DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
1326
1327         if(SMB_VFS_STAT(conn,".",&st)!=0) {
1328                 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
1329                 return ERROR_DOS(ERRSRV,ERRinvdevice);
1330         }
1331
1332         pdata = Realloc(*ppdata, max_data_bytes + 1024);
1333         if ( pdata == NULL )
1334                 return ERROR_DOS(ERRDOS,ERRnomem);
1335
1336         *ppdata = pdata;
1337         memset((char *)pdata,'\0',max_data_bytes + 1024);
1338
1339         switch (info_level) {
1340                 case SMB_INFO_ALLOCATION:
1341                 {
1342                         SMB_BIG_UINT dfree,dsize,bsize;
1343                         data_len = 18;
1344                         SMB_VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
1345                         SIVAL(pdata,l1_idFileSystem,st.st_dev);
1346                         SIVAL(pdata,l1_cSectorUnit,bsize/512);
1347                         SIVAL(pdata,l1_cUnit,dsize);
1348                         SIVAL(pdata,l1_cUnitAvail,dfree);
1349                         SSVAL(pdata,l1_cbSector,512);
1350                         DEBUG(5,("call_trans2qfsinfo : bsize=%u, id=%x, cSectorUnit=%u, cUnit=%u, cUnitAvail=%u, cbSector=%d\n",
1351                                 (unsigned int)bsize, (unsigned int)st.st_dev, ((unsigned int)bsize)/512, (unsigned int)dsize,
1352                                 (unsigned int)dfree, 512));
1353                         break;
1354                 }
1355
1356                 case SMB_INFO_VOLUME:
1357                         /* Return volume name */
1358                         /*
1359                          * Add volume serial number - hash of a combination of
1360                          * the called hostname and the service name.
1361                          */
1362                         SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(local_machine)<<16) );
1363                         len = srvstr_push(outbuf, pdata+l2_vol_szVolLabel, vname, -1, STR_TERMINATE);
1364                         SCVAL(pdata,l2_vol_cch,len);
1365                         data_len = l2_vol_szVolLabel + len;
1366                         DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
1367                                 (unsigned)st.st_ctime, len, vname));
1368                         break;
1369
1370                 case SMB_QUERY_FS_ATTRIBUTE_INFO:
1371                 case SMB_FS_ATTRIBUTE_INFORMATION:
1372
1373
1374 #if defined(HAVE_SYS_QUOTAS)
1375                         quota_flag = FILE_VOLUME_QUOTAS;
1376 #endif
1377
1378                         SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
1379                                 (lp_nt_acl_support(SNUM(conn)) ? FILE_PERSISTENT_ACLS : 0)|
1380                                 quota_flag); /* FS ATTRIBUTES */
1381
1382                         SIVAL(pdata,4,255); /* Max filename component length */
1383                         /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
1384                                 and will think we can't do long filenames */
1385                         len = srvstr_push(outbuf, pdata+12, fstype, -1, 0);
1386                         SIVAL(pdata,8,len);
1387                         data_len = 12 + len;
1388                         break;
1389
1390                 case SMB_QUERY_FS_LABEL_INFO:
1391                 case SMB_FS_LABEL_INFORMATION:
1392                         len = srvstr_push(outbuf, pdata+4, vname, -1, STR_TERMINATE);
1393                         data_len = 4 + len;
1394                         SIVAL(pdata,0,len);
1395                         break;
1396
1397                 case SMB_QUERY_FS_VOLUME_INFO:
1398                 case SMB_FS_VOLUME_INFORMATION:
1399
1400                         /*
1401                          * Add volume serial number - hash of a combination of
1402                          * the called hostname and the service name.
1403                          */
1404                         SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
1405                                 (str_checksum(local_machine)<<16));
1406
1407                         len = srvstr_push(outbuf, pdata+18, vname, -1, STR_TERMINATE);
1408                         SIVAL(pdata,12,len);
1409                         data_len = 18+len;
1410                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
1411                                 (int)strlen(vname),vname, lp_servicename(snum)));
1412                         break;
1413
1414                 case SMB_QUERY_FS_SIZE_INFO:
1415                 case SMB_FS_SIZE_INFORMATION:
1416                 {
1417                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
1418                         data_len = 24;
1419                         SMB_VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
1420                         block_size = lp_block_size(snum);
1421                         if (bsize < block_size) {
1422                                 SMB_BIG_UINT factor = block_size/bsize;
1423                                 bsize = block_size;
1424                                 dsize /= factor;
1425                                 dfree /= factor;
1426                         }
1427                         if (bsize > block_size) {
1428                                 SMB_BIG_UINT factor = bsize/block_size;
1429                                 bsize = block_size;
1430                                 dsize *= factor;
1431                                 dfree *= factor;
1432                         }
1433                         bytes_per_sector = 512;
1434                         sectors_per_unit = bsize/bytes_per_sector;
1435                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
1436 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
1437                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
1438                         SBIG_UINT(pdata,0,dsize);
1439                         SBIG_UINT(pdata,8,dfree);
1440                         SIVAL(pdata,16,sectors_per_unit);
1441                         SIVAL(pdata,20,bytes_per_sector);
1442                         break;
1443                 }
1444
1445                 case SMB_FS_FULL_SIZE_INFORMATION:
1446                 {
1447                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
1448                         data_len = 32;
1449                         SMB_VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
1450                         block_size = lp_block_size(snum);
1451                         if (bsize < block_size) {
1452                                 SMB_BIG_UINT factor = block_size/bsize;
1453                                 bsize = block_size;
1454                                 dsize /= factor;
1455                                 dfree /= factor;
1456                         }
1457                         if (bsize > block_size) {
1458                                 SMB_BIG_UINT factor = bsize/block_size;
1459                                 bsize = block_size;
1460                                 dsize *= factor;
1461                                 dfree *= factor;
1462                         }
1463                         bytes_per_sector = 512;
1464                         sectors_per_unit = bsize/bytes_per_sector;
1465                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
1466 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
1467                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
1468                         SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
1469                         SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
1470                         SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
1471                         SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
1472                         SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
1473                         break;
1474                 }
1475
1476                 case SMB_QUERY_FS_DEVICE_INFO:
1477                 case SMB_FS_DEVICE_INFORMATION:
1478                         data_len = 8;
1479                         SIVAL(pdata,0,0); /* dev type */
1480                         SIVAL(pdata,4,0); /* characteristics */
1481                         break;
1482
1483 #ifdef WITH_QUOTAS
1484                 case SMB_FS_QUOTA_INFORMATION:
1485                 /*
1486                  * what we have to send --metze:
1487                  *
1488                  * Unknown1:            24 NULL bytes
1489                  * Soft Quota Treshold: 8 bytes seems like SMB_BIG_UINT or so
1490                  * Hard Quota Limit:    8 bytes seems like SMB_BIG_UINT or so
1491                  * Quota Flags:         2 byte :
1492                  * Unknown3:            6 NULL bytes
1493                  *
1494                  * 48 bytes total
1495                  *
1496                  * details for Quota Flags:
1497                  *
1498                  * 0x0020 Log Limit: log if the user exceeds his Hard Quota
1499                  * 0x0010 Log Warn:  log if the user exceeds his Soft Quota
1500                  * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
1501                  * 0x0001 Enable Quotas: enable quota for this fs
1502                  *
1503                  */
1504                 {
1505                         /* we need to fake up a fsp here,
1506                          * because its not send in this call
1507                          */
1508                         files_struct fsp;
1509                         SMB_NTQUOTA_STRUCT quotas;
1510
1511                         ZERO_STRUCT(fsp);
1512                         ZERO_STRUCT(quotas);
1513
1514                         fsp.conn = conn;
1515                         fsp.fnum = -1;
1516                         fsp.fd = -1;
1517
1518                         /* access check */
1519                         if (conn->admin_user != True) {
1520                                 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
1521                                         lp_servicename(SNUM(conn)),conn->user));
1522                                 return ERROR_DOS(ERRDOS,ERRnoaccess);
1523                         }
1524
1525                         if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
1526                                 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
1527                                 return ERROR_DOS(ERRSRV,ERRerror);
1528                         }
1529
1530                         data_len = 48;
1531
1532                         DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn))));
1533
1534                         /* Unknown1 24 NULL bytes*/
1535                         SBIG_UINT(pdata,0,(SMB_BIG_UINT)0);
1536                         SBIG_UINT(pdata,8,(SMB_BIG_UINT)0);
1537                         SBIG_UINT(pdata,16,(SMB_BIG_UINT)0);
1538
1539                         /* Default Soft Quota 8 bytes */
1540                         SBIG_UINT(pdata,24,quotas.softlim);
1541
1542                         /* Default Hard Quota 8 bytes */
1543                         SBIG_UINT(pdata,32,quotas.hardlim);
1544
1545                         /* Quota flag 2 bytes */
1546                         SSVAL(pdata,40,quotas.qflags);
1547
1548                         /* Unknown3 6 NULL bytes */
1549                         SSVAL(pdata,42,0);
1550                         SIVAL(pdata,44,0);
1551
1552                         break;
1553                 }
1554 #endif /* WITH_QUOTAS */
1555                 case SMB_FS_OBJECTID_INFORMATION:
1556                         data_len = 64;
1557                         break;
1558
1559                 /*
1560                  * Query the version and capabilities of the CIFS UNIX extensions
1561                  * in use.
1562                  */
1563
1564                 case SMB_QUERY_CIFS_UNIX_INFO:
1565                         if (!lp_unix_extensions())
1566                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1567                         data_len = 12;
1568                         SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
1569                         SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
1570                         SBIG_UINT(pdata,4,((SMB_BIG_UINT)0)); /* No capabilities for now... */
1571                         break;
1572
1573                 case SMB_MAC_QUERY_FS_INFO:
1574                         /*
1575                          * Thursby MAC extension... ONLY on NTFS filesystems
1576                          * once we do streams then we don't need this
1577                          */
1578                         if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
1579                                 data_len = 88;
1580                                 SIVAL(pdata,84,0x100); /* Don't support mac... */
1581                                 break;
1582                         }
1583                         /* drop through */
1584                 default:
1585                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
1586         }
1587
1588
1589         send_trans2_replies( outbuf, bufsize, params, 0, pdata, data_len);
1590
1591         DEBUG( 4, ( "%s info_level = %d\n", smb_fn_name(CVAL(inbuf,smb_com)), info_level) );
1592
1593         return -1;
1594 }
1595
1596 #ifdef WITH_QUOTAS
1597 /****************************************************************************
1598  Reply to a TRANS2_SETFSINFO (set filesystem info).
1599 ****************************************************************************/
1600
1601 static int call_trans2setfsinfo(connection_struct *conn,
1602                                 char *inbuf, char *outbuf, int length, int bufsize,
1603                                 char **pparams, int total_params, char **ppdata, int total_data)
1604 {
1605         char *pdata = *ppdata;
1606         char *params = *pparams;
1607         files_struct *fsp = NULL;
1608         uint16 info_level;
1609         int outsize;
1610         SMB_NTQUOTA_STRUCT quotas;
1611
1612         ZERO_STRUCT(quotas);
1613
1614         DEBUG(10,("call_trans2setfsinfo: SET_FS_QUOTA: for service [%s]\n",lp_servicename(SNUM(conn))));
1615
1616         /* access check */
1617         if ((conn->admin_user != True)||!CAN_WRITE(conn)) {
1618                 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
1619                         lp_servicename(SNUM(conn)),conn->user));
1620                 return ERROR_DOS(ERRSRV,ERRaccess);
1621         }
1622
1623         /*  */
1624         if (total_params < 4) {
1625                 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
1626                         total_params));
1627                 return ERROR_DOS(ERRDOS,ERRinvalidparam);
1628         }
1629
1630         fsp = file_fsp(params,0);
1631
1632         if (!CHECK_NTQUOTA_HANDLE_OK(fsp,conn)) {
1633                 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
1634                 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
1635         }
1636
1637         info_level = SVAL(params,2);
1638
1639         switch(info_level) {
1640                 case SMB_FS_QUOTA_INFORMATION:
1641                         /* note: normaly there're 48 bytes,
1642                          * but we didn't use the last 6 bytes for now
1643                          * --metze
1644                          */
1645                         if (total_data < 42) {
1646                                 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
1647                                         total_data));
1648                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1649                         }
1650
1651                         /* unknown_1 24 NULL bytes in pdata*/
1652
1653                         /* the soft quotas 8 bytes (SMB_BIG_UINT)*/
1654                         quotas.softlim = (SMB_BIG_UINT)IVAL(pdata,24);
1655 #ifdef LARGE_SMB_OFF_T
1656                         quotas.softlim |= (((SMB_BIG_UINT)IVAL(pdata,28)) << 32);
1657 #else /* LARGE_SMB_OFF_T */
1658                         if ((IVAL(pdata,28) != 0)&&
1659                                 ((quotas.softlim != 0xFFFFFFFF)||
1660                                 (IVAL(pdata,28)!=0xFFFFFFFF)))) {
1661                                 /* more than 32 bits? */
1662                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1663                         }
1664 #endif /* LARGE_SMB_OFF_T */
1665
1666                         /* the hard quotas 8 bytes (SMB_BIG_UINT)*/
1667                         quotas.hardlim = (SMB_BIG_UINT)IVAL(pdata,32);
1668 #ifdef LARGE_SMB_OFF_T
1669                         quotas.hardlim |= (((SMB_BIG_UINT)IVAL(pdata,36)) << 32);
1670 #else /* LARGE_SMB_OFF_T */
1671                         if ((IVAL(pdata,36) != 0)&&
1672                                 ((quotas.hardlim != 0xFFFFFFFF)||
1673                                 (IVAL(pdata,36)!=0xFFFFFFFF)))) {
1674                                 /* more than 32 bits? */
1675                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1676                         }
1677 #endif /* LARGE_SMB_OFF_T */
1678
1679                         /* quota_flags 2 bytes **/
1680                         quotas.qflags = SVAL(pdata,40);
1681
1682                         /* unknown_2 6 NULL bytes follow*/
1683
1684                         /* now set the quotas */
1685                         if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
1686                                 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
1687                                 return ERROR_DOS(ERRSRV,ERRerror);
1688                         }
1689
1690                         break;
1691                 default:
1692                         DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
1693                                 info_level));
1694                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
1695                         break;
1696         }
1697
1698         /*
1699          * sending this reply works fine,
1700          * but I'm not sure it's the same
1701          * like windows do...
1702          * --metze
1703          */
1704         outsize = set_message(outbuf,10,0,True);
1705
1706         return outsize;
1707 }
1708 #endif /* WITH_QUOTAS */
1709
1710 /****************************************************************************
1711  *  Utility function to set bad path error.
1712  ****************************************************************************/
1713
1714 NTSTATUS set_bad_path_error(int err, BOOL bad_path)
1715 {
1716         if((err == ENOENT) && bad_path) {
1717                 unix_ERR_class = ERRDOS;
1718                 unix_ERR_code = ERRbadpath;
1719                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
1720         }
1721         return NT_STATUS_OK;
1722 }
1723
1724 /****************************************************************************
1725  Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
1726  file name or file id).
1727 ****************************************************************************/
1728
1729 static int call_trans2qfilepathinfo(connection_struct *conn,
1730                                     char *inbuf, char *outbuf, int length,
1731                                     int bufsize,
1732                                         char **pparams, int total_params, char **ppdata, int total_data)
1733 {
1734         int max_data_bytes = SVAL(inbuf, smb_mdrcnt);
1735         char *params = *pparams;
1736         char *pdata = *ppdata;
1737         uint16 tran_call = SVAL(inbuf, smb_setup0);
1738         uint16 info_level;
1739         int mode=0;
1740         SMB_OFF_T file_size=0;
1741         SMB_BIG_UINT allocation_size=0;
1742         unsigned int data_size;
1743         SMB_STRUCT_STAT sbuf;
1744         pstring fname, dos_fname;
1745         char *fullpathname;
1746         char *base_name;
1747         char *p;
1748         SMB_OFF_T pos = 0;
1749         BOOL bad_path = False;
1750         BOOL delete_pending = False;
1751         int len;
1752         time_t c_time;
1753         files_struct *fsp = NULL;
1754
1755         if (!params)
1756                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1757
1758         if (tran_call == TRANSACT2_QFILEINFO) {
1759                 if (total_params < 4)
1760                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
1761
1762                 fsp = file_fsp(params,0);
1763                 info_level = SVAL(params,2);
1764
1765                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
1766
1767                 if(fsp && (fsp->fake_file_handle)) {
1768                         /*
1769                          * This is actually for the QUOTA_FAKE_FILE --metze
1770                          */
1771
1772                         pstrcpy(fname, fsp->fsp_name);
1773                         unix_convert(fname,conn,0,&bad_path,&sbuf);
1774                         if (!check_name(fname,conn)) {
1775                                 DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed for fake_file(%s)\n",fname,strerror(errno)));
1776                                 set_bad_path_error(errno, bad_path);
1777                                 return(UNIXERROR(ERRDOS,ERRbadpath));
1778                         }
1779
1780                 } else if(fsp && (fsp->is_directory || fsp->fd == -1)) {
1781                         /*
1782                          * This is actually a QFILEINFO on a directory
1783                          * handle (returned from an NT SMB). NT5.0 seems
1784                          * to do this call. JRA.
1785                          */
1786                         pstrcpy(fname, fsp->fsp_name);
1787                         unix_convert(fname,conn,0,&bad_path,&sbuf);
1788                         if (!check_name(fname,conn)) {
1789                                 DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
1790                                 set_bad_path_error(errno, bad_path);
1791                                 return(UNIXERROR(ERRDOS,ERRbadpath));
1792                         }
1793
1794                         if (INFO_LEVEL_IS_UNIX(info_level)) {
1795                                 /* Always do lstat for UNIX calls. */
1796                                 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
1797                                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
1798                                         set_bad_path_error(errno, bad_path);
1799                                         return(UNIXERROR(ERRDOS,ERRbadpath));
1800                                 }
1801                         } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf)) {
1802                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
1803                                 set_bad_path_error(errno, bad_path);
1804                                 return(UNIXERROR(ERRDOS,ERRbadpath));
1805                         }
1806
1807                         delete_pending = fsp->directory_delete_on_close;
1808                 } else {
1809                         /*
1810                          * Original code - this is an open file.
1811                          */
1812                         CHECK_FSP(fsp,conn);
1813
1814                         pstrcpy(fname, fsp->fsp_name);
1815                         if (SMB_VFS_FSTAT(fsp,fsp->fd,&sbuf) != 0) {
1816                                 DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
1817                                 return(UNIXERROR(ERRDOS,ERRbadfid));
1818                         }
1819                         if((pos = SMB_VFS_LSEEK(fsp,fsp->fd,0,SEEK_CUR)) == -1)
1820                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
1821
1822                         delete_pending = fsp->delete_on_close;
1823                 }
1824         } else {
1825                 /* qpathinfo */
1826                 if (total_params < 6)
1827                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
1828
1829                 info_level = SVAL(params,0);
1830
1831                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
1832
1833                 srvstr_pull(inbuf, fname, &params[6], sizeof(fname), -1, STR_TERMINATE);
1834
1835                 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
1836
1837                 unix_convert(fname,conn,0,&bad_path,&sbuf);
1838                 if (!check_name(fname,conn)) {
1839                         DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
1840                         set_bad_path_error(errno, bad_path);
1841                         return(UNIXERROR(ERRDOS,ERRbadpath));
1842                 }
1843
1844                 if (INFO_LEVEL_IS_UNIX(info_level)) {
1845                         /* Always do lstat for UNIX calls. */
1846                         if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
1847                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
1848                                 set_bad_path_error(errno, bad_path);
1849                                 return(UNIXERROR(ERRDOS,ERRbadpath));
1850                         }
1851                 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf)) {
1852                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
1853                         set_bad_path_error(errno, bad_path);
1854                         return(UNIXERROR(ERRDOS,ERRbadpath));
1855                 }
1856         }
1857
1858         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions())
1859                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
1860
1861         DEBUG(3,("call_trans2qfilepathinfo %s level=%d call=%d total_data=%d\n",
1862                 fname,info_level,tran_call,total_data));
1863
1864         p = strrchr_m(fname,'/');
1865         if (!p)
1866                 base_name = fname;
1867         else
1868                 base_name = p+1;
1869
1870         mode = dos_mode(conn,fname,&sbuf);
1871         fullpathname = fname;
1872         file_size = get_file_size(sbuf);
1873         allocation_size = get_allocation_size(fsp,&sbuf);
1874         if (mode & aDIR)
1875                 file_size = 0;
1876
1877         params = Realloc(*pparams,2);
1878         if (params == NULL)
1879           return ERROR_DOS(ERRDOS,ERRnomem);
1880         *pparams = params;
1881         memset((char *)params,'\0',2);
1882         data_size = max_data_bytes + 1024;
1883         pdata = Realloc(*ppdata, data_size);
1884         if ( pdata == NULL )
1885                 return ERROR_DOS(ERRDOS,ERRnomem);
1886         *ppdata = pdata;
1887
1888         if (total_data > 0 && IVAL(pdata,0) == total_data) {
1889                 /* uggh, EAs for OS2 */
1890                 DEBUG(4,("Rejecting EA request with total_data=%d\n",total_data));
1891                 return ERROR_DOS(ERRDOS,ERReasnotsupported);
1892         }
1893
1894         memset((char *)pdata,'\0',data_size);
1895
1896         c_time = get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
1897
1898         if (lp_dos_filetime_resolution(SNUM(conn))) {
1899                 c_time &= ~1;
1900                 sbuf.st_atime &= ~1;
1901                 sbuf.st_mtime &= ~1;
1902                 sbuf.st_mtime &= ~1;
1903         }
1904
1905         /* NT expects the name to be in an exact form of the *full*
1906            filename. See the trans2 torture test */
1907         if (strequal(base_name,".")) {
1908                 pstrcpy(dos_fname, "\\");
1909         } else {
1910                 snprintf(dos_fname, sizeof(dos_fname), "\\%s", fname);
1911                 string_replace(dos_fname, '/', '\\');
1912         }
1913
1914         switch (info_level) {
1915                 case SMB_INFO_STANDARD:
1916                 case SMB_INFO_QUERY_EA_SIZE:
1917                         data_size = (info_level==1?22:26);
1918                         put_dos_date2(pdata,l1_fdateCreation,c_time);
1919                         put_dos_date2(pdata,l1_fdateLastAccess,sbuf.st_atime);
1920                         put_dos_date2(pdata,l1_fdateLastWrite,sbuf.st_mtime); /* write time */
1921                         SIVAL(pdata,l1_cbFile,(uint32)file_size);
1922                         SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
1923                         SSVAL(pdata,l1_attrFile,mode);
1924                         SIVAL(pdata,l1_attrFile+2,4); /* this is what OS2 does */
1925                         break;
1926
1927                 case SMB_INFO_QUERY_EAS_FROM_LIST:
1928                         data_size = 24;
1929                         put_dos_date2(pdata,0,c_time);
1930                         put_dos_date2(pdata,4,sbuf.st_atime);
1931                         put_dos_date2(pdata,8,sbuf.st_mtime);
1932                         SIVAL(pdata,12,(uint32)file_size);
1933                         SIVAL(pdata,16,(uint32)allocation_size);
1934                         SIVAL(pdata,20,mode);
1935                         break;
1936
1937                 case SMB_INFO_QUERY_ALL_EAS:
1938                         data_size = 4;
1939                         SIVAL(pdata,0,data_size);
1940                         break;
1941
1942                 case 6:
1943                         return ERROR_DOS(ERRDOS,ERRbadfunc); /* os/2 needs this */
1944
1945                 case SMB_FILE_BASIC_INFORMATION:
1946                 case SMB_QUERY_FILE_BASIC_INFO:
1947
1948                         if (info_level == SMB_QUERY_FILE_BASIC_INFO)
1949                                 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
1950                         else {
1951                                 data_size = 40;
1952                                 SIVAL(pdata,36,0);
1953                         }
1954                         put_long_date(pdata,c_time);
1955                         put_long_date(pdata+8,sbuf.st_atime);
1956                         put_long_date(pdata+16,sbuf.st_mtime); /* write time */
1957                         put_long_date(pdata+24,sbuf.st_mtime); /* change time */
1958                         SIVAL(pdata,32,mode);
1959
1960                         DEBUG(5,("SMB_QFBI - "));
1961                         {
1962                                 time_t create_time = c_time;
1963                                 DEBUG(5,("create: %s ", ctime(&create_time)));
1964                         }
1965                         DEBUG(5,("access: %s ", ctime(&sbuf.st_atime)));
1966                         DEBUG(5,("write: %s ", ctime(&sbuf.st_mtime)));
1967                         DEBUG(5,("change: %s ", ctime(&sbuf.st_mtime)));
1968                         DEBUG(5,("mode: %x\n", mode));
1969
1970                         break;
1971
1972                 case SMB_FILE_STANDARD_INFORMATION:
1973                 case SMB_QUERY_FILE_STANDARD_INFO:
1974
1975                         data_size = 24;
1976                         SOFF_T(pdata,0,allocation_size);
1977                         SOFF_T(pdata,8,file_size);
1978                         SIVAL(pdata,16,sbuf.st_nlink);
1979                         SCVAL(pdata,20,0);
1980                         SCVAL(pdata,21,(mode&aDIR)?1:0);
1981                         break;
1982
1983                 case SMB_FILE_EA_INFORMATION:
1984                 case SMB_QUERY_FILE_EA_INFO:
1985                         data_size = 4;
1986                         break;
1987
1988                 /* Get the 8.3 name - used if NT SMB was negotiated. */
1989                 case SMB_QUERY_FILE_ALT_NAME_INFO:
1990                 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
1991                 {
1992                         pstring short_name;
1993
1994                         pstrcpy(short_name,base_name);
1995                         /* Mangle if not already 8.3 */
1996                         if(!mangle_is_8_3(short_name, True)) {
1997                                 mangle_map(short_name,True,True,SNUM(conn));
1998                         }
1999                         len = srvstr_push(outbuf, pdata+4, short_name, -1, STR_UNICODE);
2000                         data_size = 4 + len;
2001                         SIVAL(pdata,0,len);
2002                         break;
2003                 }
2004
2005                 case SMB_QUERY_FILE_NAME_INFO:
2006                         /*
2007                           this must be *exactly* right for ACLs on mapped drives to work
2008                          */
2009                         len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
2010                         data_size = 4 + len;
2011                         SIVAL(pdata,0,len);
2012                         break;
2013
2014                 case SMB_FILE_ALLOCATION_INFORMATION:
2015                 case SMB_QUERY_FILE_ALLOCATION_INFO:
2016                         data_size = 8;
2017                         SOFF_T(pdata,0,allocation_size);
2018                         break;
2019
2020                 case SMB_FILE_END_OF_FILE_INFORMATION:
2021                 case SMB_QUERY_FILE_END_OF_FILEINFO:
2022                         data_size = 8;
2023                         SOFF_T(pdata,0,file_size);
2024                         break;
2025
2026                 case SMB_QUERY_FILE_ALL_INFO:
2027                         put_long_date(pdata,c_time);
2028                         put_long_date(pdata+8,sbuf.st_atime);
2029                         put_long_date(pdata+16,sbuf.st_mtime); /* write time */
2030                         put_long_date(pdata+24,sbuf.st_mtime); /* change time */
2031                         SIVAL(pdata,32,mode);
2032                         pdata += 40;
2033                         SOFF_T(pdata,0,allocation_size);
2034                         SOFF_T(pdata,8,file_size);
2035                         SIVAL(pdata,16,sbuf.st_nlink);
2036                         SCVAL(pdata,20,delete_pending);
2037                         SCVAL(pdata,21,(mode&aDIR)?1:0);
2038                         pdata += 24;
2039                         SINO_T(pdata,0,(SMB_INO_T)sbuf.st_ino);
2040                         pdata += 8; /* index number */
2041                         pdata += 4; /* EA info */
2042                         if (mode & aRONLY)
2043                                 SIVAL(pdata,0,0xA9);
2044                         else
2045                                 SIVAL(pdata,0,0xd01BF);
2046                         pdata += 4;
2047                         SOFF_T(pdata,0,pos); /* current offset */
2048                         pdata += 8;
2049                         SIVAL(pdata,0,mode); /* is this the right sort of mode info? */
2050                         pdata += 4;
2051                         pdata += 4; /* alignment */
2052                         len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_TERMINATE);
2053                         SIVAL(pdata,0,len);
2054                         pdata += 4 + len;
2055                         data_size = PTR_DIFF(pdata,(*ppdata));
2056                         break;
2057
2058                 case SMB_FILE_INTERNAL_INFORMATION:
2059                         /* This should be an index number - looks like
2060                            dev/ino to me :-)
2061
2062                            I think this causes us to fail the IFSKIT
2063                            BasicFileInformationTest. -tpot */
2064
2065                         SIVAL(pdata,0,sbuf.st_dev);
2066                         SIVAL(pdata,4,sbuf.st_ino);
2067                         data_size = 8;
2068                         break;
2069
2070                 case SMB_FILE_ACCESS_INFORMATION:
2071                         SIVAL(pdata,0,0x12019F); /* ??? */
2072                         data_size = 4;
2073                         break;
2074
2075                 case SMB_FILE_NAME_INFORMATION:
2076                         /* Pathname with leading '\'. */
2077                         {
2078                                 size_t byte_len;
2079                                 byte_len = dos_PutUniCode(pdata+4,dos_fname,max_data_bytes,False);
2080                                 SIVAL(pdata,0,byte_len);
2081                                 data_size = 4 + byte_len;
2082                                 break;
2083                         }
2084
2085                 case SMB_FILE_DISPOSITION_INFORMATION:
2086                         data_size = 1;
2087                         SCVAL(pdata,0,delete_pending);
2088                         break;
2089
2090                 case SMB_FILE_POSITION_INFORMATION:
2091                         data_size = 8;
2092                         SOFF_T(pdata,0,pos);
2093                         break;
2094
2095                 case SMB_FILE_MODE_INFORMATION:
2096                         SIVAL(pdata,0,mode);
2097                         data_size = 4;
2098                         break;
2099
2100                 case SMB_FILE_ALIGNMENT_INFORMATION:
2101                         SIVAL(pdata,0,0); /* No alignment needed. */
2102                         data_size = 4;
2103                         break;
2104
2105 #if 0
2106         /* Not yet finished... JRA */
2107         case 1018:
2108                 {
2109                         put_long_date(pdata,c_time);
2110                         put_long_date(pdata+8,sbuf.st_atime);
2111                         put_long_date(pdata+16,sbuf.st_mtime); /* write time */
2112                         put_long_date(pdata+24,sbuf.st_mtime); /* change time */
2113                         SIVAL(pdata,32,mode);
2114                         SIVAL(pdata,36,0); /* ??? */
2115                         SIVAL(pdata,40,0x20); /* ??? */
2116                         SIVAL(pdata,44,0); /* ??? */
2117                         SOFF_T(pdata,48,size);
2118                         SIVAL(pdata,56,0x1); /* ??? */
2119                         SIVAL(pdata,60,0); /* ??? */
2120                         SIVAL(pdata,64,0); /* ??? */
2121                         SIVAL(pdata,68,length); /* Following string length in bytes. */
2122                         dos_PutUniCode(pdata+72,,False);
2123                         break;
2124                 }
2125 #endif
2126
2127 #if 0
2128                 /*
2129                  * NT4 server just returns "invalid query" to this - if we try to answer
2130                  * it then NTws gets a BSOD! (tridge).
2131                  * W2K seems to want this. JRA.
2132                  */
2133                 case SMB_QUERY_FILE_STREAM_INFO:
2134 #endif
2135                 case SMB_FILE_STREAM_INFORMATION:
2136                         if (mode & aDIR) {
2137                                 data_size = 0;
2138                         } else {
2139                                 size_t byte_len = dos_PutUniCode(pdata+24,"::$DATA", 0xE, False);
2140                                 SIVAL(pdata,0,0); /* ??? */
2141                                 SIVAL(pdata,4,byte_len); /* Byte length of unicode string ::$DATA */
2142                                 SOFF_T(pdata,8,file_size);
2143                                 SIVAL(pdata,16,allocation_size);
2144                                 SIVAL(pdata,20,0); /* ??? */
2145                                 data_size = 24 + byte_len;
2146                         }
2147                         break;
2148
2149                 case SMB_FILE_COMPRESSION_INFORMATION:
2150                         SOFF_T(pdata,0,allocation_size);
2151                         SIVAL(pdata,8,0); /* ??? */
2152                         SIVAL(pdata,12,0); /* ??? */
2153                         data_size = 16;
2154                         break;
2155
2156                 case SMB_FILE_NETWORK_OPEN_INFORMATION:
2157                         put_long_date(pdata,c_time);
2158                         put_long_date(pdata+8,sbuf.st_atime);
2159                         put_long_date(pdata+16,sbuf.st_mtime); /* write time */
2160                         put_long_date(pdata+24,sbuf.st_mtime); /* change time */
2161                         SIVAL(pdata,32,allocation_size);
2162                         SOFF_T(pdata,40,file_size);
2163                         SIVAL(pdata,48,mode);
2164                         SIVAL(pdata,52,0); /* ??? */
2165                         data_size = 56;
2166                         break;
2167
2168                 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
2169                         SIVAL(pdata,0,mode);
2170                         SIVAL(pdata,4,0);
2171                         data_size = 8;
2172                         break;
2173
2174                 /*
2175                  * CIFS UNIX Extensions.
2176                  */
2177
2178                 case SMB_QUERY_FILE_UNIX_BASIC:
2179
2180                         DEBUG(4,("call_trans2qfilepathinfo: st_mode=%o\n",(int)sbuf.st_mode));
2181
2182                         SOFF_T(pdata,0,get_file_size(sbuf));             /* File size 64 Bit */
2183                         pdata += 8;
2184
2185                         SOFF_T(pdata,0,get_allocation_size(fsp,&sbuf)); /* Number of bytes used on disk - 64 Bit */
2186                         pdata += 8;
2187
2188                         put_long_date(pdata,sbuf.st_ctime);       /* Creation Time 64 Bit */
2189                         put_long_date(pdata+8,sbuf.st_atime);     /* Last access time 64 Bit */
2190                         put_long_date(pdata+16,sbuf.st_mtime);    /* Last modification time 64 Bit */
2191                         pdata += 24;
2192
2193                         SIVAL(pdata,0,sbuf.st_uid);               /* user id for the owner */
2194                         SIVAL(pdata,4,0);
2195                         pdata += 8;
2196
2197                         SIVAL(pdata,0,sbuf.st_gid);               /* group id of owner */
2198                         SIVAL(pdata,4,0);
2199                         pdata += 8;
2200
2201                         SIVAL(pdata,0,unix_filetype(sbuf.st_mode));
2202                         pdata += 4;
2203
2204                         SIVAL(pdata,0,unix_dev_major(sbuf.st_rdev));   /* Major device number if type is device */
2205                         SIVAL(pdata,4,0);
2206                         pdata += 8;
2207
2208                         SIVAL(pdata,0,unix_dev_minor(sbuf.st_rdev));   /* Minor device number if type is device */
2209                         SIVAL(pdata,4,0);
2210                         pdata += 8;
2211
2212                         SINO_T(pdata,0,(SMB_INO_T)sbuf.st_ino);   /* inode number */
2213                         pdata += 8;
2214
2215                         SIVAL(pdata,0, unix_perms_to_wire(sbuf.st_mode));     /* Standard UNIX file permissions */
2216                         SIVAL(pdata,4,0);
2217                         pdata += 8;
2218
2219                         SIVAL(pdata,0,sbuf.st_nlink);             /* number of hard links */
2220                         SIVAL(pdata,4,0);
2221                         pdata += 8+1;
2222                         data_size = PTR_DIFF(pdata,(*ppdata));
2223
2224                         {
2225                                 int i;
2226                                 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC"));
2227
2228                                 for (i=0; i<100; i++)
2229                                         DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
2230                                 DEBUG(4,("\n"));
2231                         }
2232
2233                         break;
2234
2235                 case SMB_QUERY_FILE_UNIX_LINK:
2236                         {
2237                                 pstring buffer;
2238
2239 #ifdef S_ISLNK
2240                                 if(!S_ISLNK(sbuf.st_mode))
2241                                         return(UNIXERROR(ERRSRV,ERRbadlink));
2242 #else
2243                                 return(UNIXERROR(ERRDOS,ERRbadlink));
2244 #endif
2245                                 len = SMB_VFS_READLINK(conn,fullpathname, buffer, sizeof(pstring)-1);     /* read link */
2246                                 if (len == -1)
2247                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
2248                                 buffer[len] = 0;
2249                                 len = srvstr_push(outbuf, pdata, buffer, -1, STR_TERMINATE);
2250                                 pdata += len;
2251                                 data_size = PTR_DIFF(pdata,(*ppdata));
2252
2253                                 break;
2254                         }
2255
2256                 default:
2257                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
2258         }
2259
2260         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, data_size);
2261
2262         return(-1);
2263 }
2264
2265 /****************************************************************************
2266  Deal with the internal needs of setting the delete on close flag. Note that
2267  as the tdb locking is recursive, it is safe to call this from within
2268  open_file_shared. JRA.
2269 ****************************************************************************/
2270
2271 NTSTATUS set_delete_on_close_internal(files_struct *fsp, BOOL delete_on_close)
2272 {
2273         /*
2274          * Only allow delete on close for writable shares.
2275          */
2276
2277         if (delete_on_close && !CAN_WRITE(fsp->conn)) {
2278                 DEBUG(10,("set_delete_on_close_internal: file %s delete on close flag set but write access denied on share.\n",
2279                                 fsp->fsp_name ));
2280                                 return NT_STATUS_ACCESS_DENIED;
2281         }
2282         /*
2283          * Only allow delete on close for files/directories opened with delete intent.
2284          */
2285
2286         if (delete_on_close && !(fsp->desired_access & DELETE_ACCESS)) {
2287                 DEBUG(10,("set_delete_on_close_internal: file %s delete on close flag set but delete access denied.\n",
2288                                 fsp->fsp_name ));
2289                                 return NT_STATUS_ACCESS_DENIED;
2290         }
2291
2292         if(fsp->is_directory) {
2293                 fsp->directory_delete_on_close = delete_on_close;
2294                 DEBUG(10, ("set_delete_on_close_internal: %s delete on close flag for fnum = %d, directory %s\n",
2295                         delete_on_close ? "Added" : "Removed", fsp->fnum, fsp->fsp_name ));
2296         } else {
2297                 fsp->delete_on_close = delete_on_close;
2298                 DEBUG(10, ("set_delete_on_close_internal: %s delete on close flag for fnum = %d, file %s\n",
2299                         delete_on_close ? "Added" : "Removed", fsp->fnum, fsp->fsp_name ));
2300         }
2301
2302         return NT_STATUS_OK;
2303 }
2304
2305 /****************************************************************************
2306  Sets the delete on close flag over all share modes on this file.
2307  Modify the share mode entry for all files open
2308  on this device and inode to tell other smbds we have
2309  changed the delete on close flag. This will be noticed
2310  in the close code, the last closer will delete the file
2311  if flag is set.
2312 ****************************************************************************/
2313
2314 NTSTATUS set_delete_on_close_over_all(files_struct *fsp, BOOL delete_on_close)
2315 {
2316         DEBUG(10,("set_delete_on_close_over_all: %s delete on close flag for fnum = %d, file %s\n",
2317                 delete_on_close ? "Adding" : "Removing", fsp->fnum, fsp->fsp_name ));
2318
2319         if (fsp->is_directory || fsp->is_stat)
2320                 return NT_STATUS_OK;
2321
2322         if (lock_share_entry_fsp(fsp) == False)
2323                 return NT_STATUS_ACCESS_DENIED;
2324
2325         if (!modify_delete_flag(fsp->dev, fsp->inode, delete_on_close)) {
2326                 DEBUG(0,("set_delete_on_close_internal: failed to change delete on close flag for file %s\n",
2327                         fsp->fsp_name ));
2328                 unlock_share_entry_fsp(fsp);
2329                 return NT_STATUS_ACCESS_DENIED;
2330         }
2331
2332         unlock_share_entry_fsp(fsp);
2333         return NT_STATUS_OK;
2334 }
2335
2336 /****************************************************************************
2337  Returns true if this pathname is within the share, and thus safe.
2338 ****************************************************************************/
2339
2340 static int ensure_link_is_safe(connection_struct *conn, const char *link_dest_in, char *link_dest_out)
2341 {
2342 #ifdef PATH_MAX
2343         char resolved_name[PATH_MAX+1];
2344 #else
2345         pstring resolved_name;
2346 #endif
2347         fstring last_component;
2348         pstring link_dest;
2349         pstring link_test;
2350         char *p;
2351         BOOL bad_path = False;
2352         SMB_STRUCT_STAT sbuf;
2353
2354         pstrcpy(link_dest, link_dest_in);
2355         unix_convert(link_dest,conn,0,&bad_path,&sbuf);
2356
2357         /* Store the UNIX converted path. */
2358         pstrcpy(link_dest_out, link_dest);
2359
2360         p = strrchr(link_dest, '/');
2361         if (p) {
2362                 fstrcpy(last_component, p+1);
2363                 *p = '\0';
2364         } else {
2365                 fstrcpy(last_component, link_dest);
2366                 pstrcpy(link_dest, "./");
2367         }
2368
2369         if (SMB_VFS_REALPATH(conn,link_dest,resolved_name) == NULL)
2370                 return -1;
2371
2372         pstrcpy(link_dest, resolved_name);
2373         pstrcat(link_dest, "/");
2374         pstrcat(link_dest, last_component);
2375
2376         if (*link_dest != '/') {
2377                 /* Relative path. */
2378                 pstrcpy(link_test, conn->connectpath);
2379                 pstrcat(link_test, "/");
2380                 pstrcat(link_test, link_dest);
2381         } else {
2382                 pstrcpy(link_test, link_dest);
2383         }
2384
2385         /*
2386          * Check if the link is within the share.
2387          */
2388
2389         if (strncmp(conn->connectpath, link_test, strlen(conn->connectpath))) {
2390                 errno = EACCES;
2391                 return -1;
2392         }
2393         return 0;
2394 }
2395
2396 /****************************************************************************
2397  Reply to a TRANS2_SETFILEINFO (set file info by fileid).
2398 ****************************************************************************/
2399
2400 static int call_trans2setfilepathinfo(connection_struct *conn,
2401                                         char *inbuf, char *outbuf, int length, int bufsize,
2402                                         char **pparams, int total_params, char **ppdata, int total_data)
2403 {
2404         char *params = *pparams;
2405         char *pdata = *ppdata;
2406         uint16 tran_call = SVAL(inbuf, smb_setup0);
2407         uint16 info_level;
2408         int dosmode=0;
2409         SMB_OFF_T size=0;
2410         struct utimbuf tvs;
2411         SMB_STRUCT_STAT sbuf;
2412         pstring fname;
2413         int fd = -1;
2414         BOOL bad_path = False;
2415         files_struct *fsp = NULL;
2416         uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
2417         gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
2418         mode_t unixmode = 0;
2419
2420         if (!params)
2421                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2422
2423         if (tran_call == TRANSACT2_SETFILEINFO) {
2424                 if (total_params < 4)
2425                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2426
2427                 fsp = file_fsp(params,0);
2428                 info_level = SVAL(params,2);
2429
2430                 if(fsp && (fsp->is_directory || fsp->fd == -1)) {
2431                         /*
2432                          * This is actually a SETFILEINFO on a directory
2433                          * handle (returned from an NT SMB). NT5.0 seems
2434                          * to do this call. JRA.
2435                          */
2436                         pstrcpy(fname, fsp->fsp_name);
2437                         unix_convert(fname,conn,0,&bad_path,&sbuf);
2438                         if (!check_name(fname,conn) || (!VALID_STAT(sbuf))) {
2439                                 DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
2440                                 set_bad_path_error(errno, bad_path);
2441                                 return(UNIXERROR(ERRDOS,ERRbadpath));
2442                         }
2443                 } else if (fsp && fsp->print_file) {
2444                         /*
2445                          * Doing a DELETE_ON_CLOSE should cancel a print job.
2446                          */
2447                         if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
2448                                 fsp->share_mode = FILE_DELETE_ON_CLOSE;
2449
2450                                 DEBUG(3,("call_trans2setfilepathinfo: Cancelling print job (%s)\n", fsp->fsp_name ));
2451
2452                                 SSVAL(params,0,0);
2453                                 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
2454                                 return(-1);
2455                         } else
2456                                 return (UNIXERROR(ERRDOS,ERRbadpath));
2457             } else {
2458                         /*
2459                          * Original code - this is an open file.
2460                          */
2461                         CHECK_FSP(fsp,conn);
2462
2463                         pstrcpy(fname, fsp->fsp_name);
2464                         fd = fsp->fd;
2465
2466                         if (SMB_VFS_FSTAT(fsp,fd,&sbuf) != 0) {
2467                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
2468                                 return(UNIXERROR(ERRDOS,ERRbadfid));
2469                         }
2470                 }
2471         } else {
2472                 /* set path info */
2473                 if (total_params < 6)
2474                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2475
2476                 info_level = SVAL(params,0);
2477                 srvstr_pull(inbuf, fname, &params[6], sizeof(fname), -1, STR_TERMINATE);
2478                 unix_convert(fname,conn,0,&bad_path,&sbuf);
2479                 if(!check_name(fname, conn)) {
2480                         set_bad_path_error(errno, bad_path);
2481                         return(UNIXERROR(ERRDOS,ERRbadpath));
2482                 }
2483
2484                 /*
2485                  * For CIFS UNIX extensions the target name may not exist.
2486                  */
2487
2488                 if(!VALID_STAT(sbuf) && !INFO_LEVEL_IS_UNIX(info_level)) {
2489                         DEBUG(3,("call_trans2setfilepathinfo: stat of %s failed (%s)\n", fname, strerror(errno)));
2490                         set_bad_path_error(errno, bad_path);
2491                         return(UNIXERROR(ERRDOS,ERRbadpath));
2492                 }
2493         }
2494
2495         if (!CAN_WRITE(conn))
2496                 return ERROR_DOS(ERRSRV,ERRaccess);
2497
2498         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions())
2499                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2500
2501         if (VALID_STAT(sbuf))
2502                 unixmode = sbuf.st_mode;
2503
2504         DEBUG(3,("call_trans2setfilepathinfo(%d) %s info_level=%d totdata=%d\n",
2505                 tran_call,fname,info_level,total_data));
2506
2507         /* Realloc the parameter and data sizes */
2508         params = Realloc(*pparams,2);
2509         if(params == NULL)
2510                 return ERROR_DOS(ERRDOS,ERRnomem);
2511         *pparams = params;
2512
2513         SSVAL(params,0,0);
2514
2515         if (fsp) {
2516                 /* the pending modtime overrides the current modtime */
2517                 sbuf.st_mtime = fsp->pending_modtime;
2518         }
2519
2520         size = get_file_size(sbuf);
2521         tvs.modtime = sbuf.st_mtime;
2522         tvs.actime = sbuf.st_atime;
2523         dosmode = dos_mode(conn,fname,&sbuf);
2524         unixmode = sbuf.st_mode;
2525
2526         set_owner = VALID_STAT(sbuf) ? sbuf.st_uid : (uid_t)SMB_UID_NO_CHANGE;
2527         set_grp = VALID_STAT(sbuf) ? sbuf.st_gid : (gid_t)SMB_GID_NO_CHANGE;
2528
2529         switch (info_level) {
2530                 case SMB_INFO_STANDARD:
2531                 {
2532                         if (total_data < l1_cbFile+4)
2533                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2534
2535                         /* access time */
2536                         tvs.actime = make_unix_date2(pdata+l1_fdateLastAccess);
2537
2538                         /* write time */
2539                         tvs.modtime = make_unix_date2(pdata+l1_fdateLastWrite);
2540
2541                         dosmode = SVAL(pdata,l1_attrFile);
2542                         size = IVAL(pdata,l1_cbFile);
2543
2544                         break;
2545                 }
2546
2547                 case SMB_INFO_SET_EA:
2548                         return(ERROR_DOS(ERRDOS,ERReasnotsupported));
2549
2550                 /* XXXX um, i don't think this is right.
2551                         it's also not in the cifs6.txt spec.
2552                 */
2553                 case SMB_INFO_QUERY_EAS_FROM_LIST:
2554                         if (total_data < 28)
2555                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2556
2557                         tvs.actime = make_unix_date2(pdata+8);
2558                         tvs.modtime = make_unix_date2(pdata+12);
2559                         size = IVAL(pdata,16);
2560                         dosmode = IVAL(pdata,24);
2561                         break;
2562
2563                 /* XXXX nor this.  not in cifs6.txt, either. */
2564                 case SMB_INFO_QUERY_ALL_EAS:
2565                         if (total_data < 28)
2566                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2567
2568                         tvs.actime = make_unix_date2(pdata+8);
2569                         tvs.modtime = make_unix_date2(pdata+12);
2570                         size = IVAL(pdata,16);
2571                         dosmode = IVAL(pdata,24);
2572                         break;
2573
2574                 case SMB_SET_FILE_BASIC_INFO:
2575                 case SMB_FILE_BASIC_INFORMATION:
2576                 {
2577                         /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
2578                         time_t write_time;
2579                         time_t changed_time;
2580
2581                         if (total_data < 36)
2582                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2583
2584                         /* Ignore create time at offset pdata. */
2585
2586                         /* access time */
2587                         tvs.actime = interpret_long_date(pdata+8);
2588
2589                         write_time = interpret_long_date(pdata+16);
2590                         changed_time = interpret_long_date(pdata+24);
2591
2592                         tvs.modtime = MIN(write_time, changed_time);
2593
2594                         if (write_time > tvs.modtime && write_time != 0xffffffff) {
2595                                 tvs.modtime = write_time;
2596                         }
2597                         /* Prefer a defined time to an undefined one. */
2598                         if (tvs.modtime == (time_t)0 || tvs.modtime == (time_t)-1)
2599                                 tvs.modtime = (write_time == (time_t)0 || write_time == (time_t)-1
2600                                         ? changed_time : write_time);
2601
2602                         /* attributes */
2603                         dosmode = IVAL(pdata,32);
2604                         break;
2605                 }
2606
2607                 case SMB_FILE_ALLOCATION_INFORMATION:
2608                 case SMB_SET_FILE_ALLOCATION_INFO:
2609                 {
2610                         int ret = -1;
2611                         SMB_BIG_UINT allocation_size;
2612
2613                         if (total_data < 8)
2614                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2615
2616                         allocation_size = (SMB_BIG_UINT)IVAL(pdata,0);
2617 #ifdef LARGE_SMB_OFF_T
2618                         allocation_size |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
2619 #else /* LARGE_SMB_OFF_T */
2620                         if (IVAL(pdata,4) != 0) /* more than 32 bits? */
2621                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2622 #endif /* LARGE_SMB_OFF_T */
2623                         DEBUG(10,("call_trans2setfilepathinfo: Set file allocation info for file %s to %.0f\n",
2624                                         fname, (double)allocation_size ));
2625
2626                         if (allocation_size)
2627                                 allocation_size = SMB_ROUNDUP(allocation_size,SMB_ROUNDUP_ALLOCATION_SIZE);
2628
2629                         if(allocation_size != get_file_size(sbuf)) {
2630                                 SMB_STRUCT_STAT new_sbuf;
2631
2632                                 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting new allocation size to %.0f\n",
2633                                         fname, (double)allocation_size ));
2634
2635                                 if (fd == -1) {
2636                                         files_struct *new_fsp = NULL;
2637                                         int access_mode = 0;
2638                                         int action = 0;
2639
2640                                         if(global_oplock_break) {
2641                                                 /* Queue this file modify as we are the process of an oplock break.  */
2642
2643                                                 DEBUG(2,("call_trans2setfilepathinfo: queueing message due to being "));
2644                                                 DEBUGADD(2,( "in oplock break state.\n"));
2645
2646                                                 push_oplock_pending_smb_message(inbuf, length);
2647                                                 return -1;
2648                                         }
2649
2650                                         new_fsp = open_file_shared1(conn, fname, &sbuf,FILE_WRITE_DATA,
2651                                                                         SET_OPEN_MODE(DOS_OPEN_RDWR),
2652                                                                         (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
2653                                                                         0, 0, &access_mode, &action);
2654
2655                                         if (new_fsp == NULL)
2656                                                 return(UNIXERROR(ERRDOS,ERRbadpath));
2657                                         ret = vfs_allocate_file_space(new_fsp, allocation_size);
2658                                         if (SMB_VFS_FSTAT(new_fsp,new_fsp->fd,&new_sbuf) != 0) {
2659                                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
2660                                                                         new_fsp->fnum, strerror(errno)));
2661                                                 ret = -1;
2662                                         }
2663                                         close_file(new_fsp,True);
2664                                 } else {
2665                                         ret = vfs_allocate_file_space(fsp, allocation_size);
2666                                         if (SMB_VFS_FSTAT(fsp,fd,&new_sbuf) != 0) {
2667                                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
2668                                                                         fsp->fnum, strerror(errno)));
2669                                                 ret = -1;
2670                                         }
2671                                 }
2672                                 if (ret == -1)
2673                                         return ERROR_NT(NT_STATUS_DISK_FULL);
2674
2675                                 /* Allocate can truncate size... */
2676                                 size = get_file_size(new_sbuf);
2677                         }
2678
2679                         break;
2680                 }
2681
2682                 case SMB_FILE_END_OF_FILE_INFORMATION:
2683                 case SMB_SET_FILE_END_OF_FILE_INFO:
2684                 {
2685                         if (total_data < 8)
2686                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2687
2688                         size = IVAL(pdata,0);
2689 #ifdef LARGE_SMB_OFF_T
2690                         size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
2691 #else /* LARGE_SMB_OFF_T */
2692                         if (IVAL(pdata,4) != 0) /* more than 32 bits? */
2693                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2694 #endif /* LARGE_SMB_OFF_T */
2695                         DEBUG(10,("call_trans2setfilepathinfo: Set end of file info for file %s to %.0f\n", fname, (double)size ));
2696                         break;
2697                 }
2698
2699                 case SMB_FILE_DISPOSITION_INFORMATION:
2700                 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
2701                 {
2702                         BOOL delete_on_close = (CVAL(pdata,0) ? True : False);
2703                         NTSTATUS status;
2704
2705                         if (total_data < 1)
2706                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2707
2708                         if (tran_call != TRANSACT2_SETFILEINFO)
2709                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2710
2711                         if (fsp == NULL)
2712                                 return(UNIXERROR(ERRDOS,ERRbadfid));
2713
2714                         status = set_delete_on_close_internal(fsp, delete_on_close);
2715
2716                         if (NT_STATUS_V(status) !=  NT_STATUS_V(NT_STATUS_OK))
2717                                 return ERROR_NT(status);
2718
2719                         /* The set is across all open files on this dev/inode pair. */
2720                         status =set_delete_on_close_over_all(fsp, delete_on_close);
2721                         if (NT_STATUS_V(status) !=  NT_STATUS_V(NT_STATUS_OK))
2722                                 return ERROR_NT(status);
2723
2724                         break;
2725                 }
2726
2727                 /*
2728                  * CIFS UNIX extensions.
2729                  */
2730
2731                 case SMB_SET_FILE_UNIX_BASIC:
2732                 {
2733                         uint32 raw_unixmode;
2734
2735                         if (total_data < 100)
2736                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2737
2738                         if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
2739                            IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
2740                                 size=IVAL(pdata,0); /* first 8 Bytes are size */
2741 #ifdef LARGE_SMB_OFF_T
2742                                 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
2743 #else /* LARGE_SMB_OFF_T */
2744                                 if (IVAL(pdata,4) != 0) /* more than 32 bits? */
2745                                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
2746 #endif /* LARGE_SMB_OFF_T */
2747                         }
2748                         pdata+=24;          /* ctime & st_blocks are not changed */
2749                         tvs.actime = interpret_long_unix_date(pdata); /* access_time */
2750                         tvs.modtime = interpret_long_unix_date(pdata+8); /* modification_time */
2751                         pdata+=16;
2752                         set_owner = (uid_t)IVAL(pdata,0);
2753                         pdata += 8;
2754                         set_grp = (gid_t)IVAL(pdata,0);
2755                         pdata += 8;
2756                         raw_unixmode = IVAL(pdata,28);
2757                         unixmode = unix_perms_from_wire(conn, &sbuf, raw_unixmode);
2758                         dosmode = 0; /* Ensure dos mode change doesn't override this. */
2759
2760                         DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC: name = %s \
2761 size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
2762                                 fname, (double)size, (unsigned int)set_owner, (unsigned int)set_grp, (int)raw_unixmode));
2763
2764                         if (!VALID_STAT(sbuf)) {
2765
2766                                 /*
2767                                  * The only valid use of this is to create character and block
2768                                  * devices, and named pipes. This is deprecated (IMHO) and
2769                                  * a new info level should be used for mknod. JRA.
2770                                  */
2771
2772 #if !defined(HAVE_MAKEDEV_FN)
2773                                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
2774 #else /* HAVE_MAKEDEV_FN */
2775                                 uint32 file_type = IVAL(pdata,0);
2776                                 uint32 dev_major = IVAL(pdata,4);
2777                                 uint32 dev_minor = IVAL(pdata,12);
2778
2779                                 uid_t myuid = geteuid();
2780                                 gid_t mygid = getegid();
2781                                 SMB_DEV_T dev;
2782
2783                                 if (tran_call == TRANSACT2_SETFILEINFO)
2784                                         return(ERROR_DOS(ERRDOS,ERRnoaccess));
2785
2786                                 if (raw_unixmode == SMB_MODE_NO_CHANGE)
2787                                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2788
2789                                 dev = makedev(dev_major, dev_minor);
2790
2791                                 /* We can only create as the owner/group we are. */
2792
2793                                 if ((set_owner != myuid) && (set_owner != (uid_t)SMB_UID_NO_CHANGE))
2794                                         return(ERROR_DOS(ERRDOS,ERRnoaccess));
2795                                 if ((set_grp != mygid) && (set_grp != (gid_t)SMB_GID_NO_CHANGE))
2796                                         return(ERROR_DOS(ERRDOS,ERRnoaccess));
2797
2798                                 if (file_type != UNIX_TYPE_CHARDEV && file_type != UNIX_TYPE_BLKDEV &&
2799                                                 file_type != UNIX_TYPE_FIFO)
2800                                         return(ERROR_DOS(ERRDOS,ERRnoaccess));
2801
2802                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC doing mknod dev %.0f mode \
2803 0%o for file %s\n", (double)dev, unixmode, fname ));
2804
2805                                 /* Ok - do the mknod. */
2806                                 if (SMB_VFS_MKNOD(conn,dos_to_unix_static(fname), unixmode, dev) != 0)
2807                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
2808
2809                                 inherit_access_acl(conn, fname, unixmode);
2810
2811                                 SSVAL(params,0,0);
2812                                 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
2813                                 return(-1);
2814 #endif /* HAVE_MAKEDEV_FN */
2815
2816                         }
2817
2818                         /*
2819                          * Deal with the UNIX specific mode set.
2820                          */
2821
2822                         if (raw_unixmode != SMB_MODE_NO_CHANGE) {
2823                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
2824                                         (unsigned int)unixmode, fname ));
2825                                 if (SMB_VFS_CHMOD(conn,fname,unixmode) != 0)
2826                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
2827                         }
2828
2829                         /*
2830                          * Deal with the UNIX specific uid set.
2831                          */
2832
2833                         if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) && (sbuf.st_uid != set_owner)) {
2834                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing owner %u for file %s\n",
2835                                         (unsigned int)set_owner, fname ));
2836                                 if (SMB_VFS_CHOWN(conn,fname,set_owner, (gid_t)-1) != 0)
2837                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
2838                         }
2839
2840                         /*
2841                          * Deal with the UNIX specific gid set.
2842                          */
2843
2844                         if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) && (sbuf.st_gid != set_grp)) {
2845                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
2846                                         (unsigned int)set_owner, fname ));
2847                                 if (SMB_VFS_CHOWN(conn,fname,(uid_t)-1, set_grp) != 0)
2848                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
2849                         }
2850                         break;
2851                 }
2852
2853                 case SMB_SET_FILE_UNIX_LINK:
2854                 {
2855                         pstring link_dest;
2856                         /* Set a symbolic link. */
2857                         /* Don't allow this if follow links is false. */
2858
2859                         if (!lp_symlinks(SNUM(conn)))
2860                                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
2861
2862                         /* Disallow if already exists. */
2863                         if (VALID_STAT(sbuf))
2864                                 return(ERROR_DOS(ERRDOS,ERRbadpath));
2865
2866                         srvstr_pull(inbuf, link_dest, pdata, sizeof(link_dest), -1, STR_TERMINATE);
2867
2868                         if (ensure_link_is_safe(conn, link_dest, link_dest) != 0)
2869                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
2870
2871                         DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
2872                                 fname, link_dest ));
2873
2874                         if (SMB_VFS_SYMLINK(conn,link_dest,fname) != 0)
2875                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
2876                         SSVAL(params,0,0);
2877                         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
2878                         return(-1);
2879                 }
2880
2881                 case SMB_SET_FILE_UNIX_HLINK:
2882                 {
2883                         pstring link_dest;
2884
2885                         /* Set a hard link. */
2886
2887                         /* Disallow if already exists. */
2888                         if (VALID_STAT(sbuf))
2889                                 return(ERROR_DOS(ERRDOS,ERRbadpath));
2890
2891                         srvstr_pull(inbuf, link_dest, pdata, sizeof(link_dest), -1, STR_TERMINATE);
2892
2893                         if (ensure_link_is_safe(conn, link_dest, link_dest) != 0)
2894                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
2895
2896                         DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
2897                                 fname, link_dest ));
2898
2899                         if (SMB_VFS_LINK(conn,link_dest,fname) != 0)
2900                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
2901                         SSVAL(params,0,0);
2902                         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
2903                         return(-1);
2904                 }
2905
2906                 default:
2907                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
2908         }
2909
2910         /* get some defaults (no modifications) if any info is zero or -1. */
2911         if (tvs.actime == (time_t)0 || tvs.actime == (time_t)-1)
2912                 tvs.actime = sbuf.st_atime;
2913
2914         if (tvs.modtime == (time_t)0 || tvs.modtime == (time_t)-1)
2915                 tvs.modtime = sbuf.st_mtime;
2916
2917         DEBUG(6,("actime: %s " , ctime(&tvs.actime)));
2918         DEBUG(6,("modtime: %s ", ctime(&tvs.modtime)));
2919         DEBUG(6,("size: %.0f ", (double)size));
2920
2921         if (S_ISDIR(sbuf.st_mode))
2922                 dosmode |= aDIR;
2923         else
2924                 dosmode &= ~aDIR;
2925
2926         DEBUG(6,("dosmode: %x\n"  , dosmode));
2927
2928         if(!((info_level == SMB_SET_FILE_END_OF_FILE_INFO) ||
2929                 (info_level == SMB_SET_FILE_ALLOCATION_INFO) ||
2930                 (info_level == SMB_FILE_ALLOCATION_INFORMATION) ||
2931                 (info_level == SMB_FILE_END_OF_FILE_INFORMATION))) {
2932
2933                 /*
2934                  * Only do this test if we are not explicitly
2935                  * changing the size of a file.
2936                  */
2937                 if (!size)
2938                         size = get_file_size(sbuf);
2939         }
2940
2941         /*
2942          * Try and set the times, size and mode of this file -
2943          * if they are different from the current values
2944          */
2945         if (sbuf.st_mtime != tvs.modtime || sbuf.st_atime != tvs.actime) {
2946                 if(fsp != NULL) {
2947                         /*
2948                          * This was a setfileinfo on an open file.
2949                          * NT does this a lot. It's actually pointless
2950                          * setting the time here, as it will be overwritten
2951                          * on the next write, so we save the request
2952                          * away and will set it on file close. JRA.
2953                          */
2954
2955                         if (tvs.modtime != (time_t)0 && tvs.modtime != (time_t)-1) {
2956                                 DEBUG(10,("call_trans2setfilepathinfo: setting pending modtime to %s\n", ctime(&tvs.modtime) ));
2957                                 fsp->pending_modtime = tvs.modtime;
2958                         }
2959
2960                 } else {
2961
2962                         DEBUG(10,("call_trans2setfilepathinfo: setting utimes to modified values.\n"));
2963
2964                         if(file_utime(conn, fname, &tvs)!=0)
2965                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
2966                 }
2967         }
2968
2969         /* check the mode isn't different, before changing it */
2970         if ((dosmode != 0) && (dosmode != dos_mode(conn, fname, &sbuf))) {
2971
2972                 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting dos mode %x\n", fname, dosmode ));
2973
2974                 if(file_chmod(conn, fname, dosmode, NULL)) {
2975                         DEBUG(2,("chmod of %s failed (%s)\n", fname, strerror(errno)));
2976                         return(UNIXERROR(ERRDOS,ERRnoaccess));
2977                 }
2978         }
2979
2980         if (size != get_file_size(sbuf)) {
2981
2982                 int ret;
2983
2984                 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting new size to %.0f\n",
2985                         fname, (double)size ));
2986
2987                 if (fd == -1) {
2988                         files_struct *new_fsp = NULL;
2989                         int access_mode = 0;
2990                         int action = 0;
2991
2992                         if(global_oplock_break) {
2993                                 /* Queue this file modify as we are the process of an oplock break.  */
2994
2995                                 DEBUG(2,("call_trans2setfilepathinfo: queueing message due to being "));
2996                                 DEBUGADD(2,( "in oplock break state.\n"));
2997
2998                                 push_oplock_pending_smb_message(inbuf, length);
2999                                 return -1;
3000                         }
3001
3002                         new_fsp = open_file_shared(conn, fname, &sbuf,
3003                                                 SET_OPEN_MODE(DOS_OPEN_RDWR),
3004                                                 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
3005                                                 0, 0, &access_mode, &action);
3006
3007                         if (new_fsp == NULL)
3008                                 return(UNIXERROR(ERRDOS,ERRbadpath));
3009                         ret = vfs_set_filelen(new_fsp, size);
3010                         close_file(new_fsp,True);
3011                 } else {
3012                         ret = vfs_set_filelen(fsp, size);
3013                 }
3014
3015                 if (ret == -1)
3016                         return (UNIXERROR(ERRHRD,ERRdiskfull));
3017         }
3018
3019         SSVAL(params,0,0);
3020         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3021
3022         return(-1);
3023 }
3024
3025 /****************************************************************************
3026  Reply to a TRANS2_MKDIR (make directory with extended attributes).
3027 ****************************************************************************/
3028
3029 static int call_trans2mkdir(connection_struct *conn,
3030                             char *inbuf, char *outbuf, int length, int bufsize,
3031                                 char **pparams, int total_params, char **ppdata, int total_data)
3032 {
3033         char *params = *pparams;
3034         pstring directory;
3035         int ret = -1;
3036         SMB_STRUCT_STAT sbuf;
3037         BOOL bad_path = False;
3038
3039         if (!CAN_WRITE(conn))
3040                 return ERROR_DOS(ERRSRV,ERRaccess);
3041
3042         if (total_params < 4)
3043                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3044
3045         srvstr_pull(inbuf, directory, &params[4], sizeof(directory), -1, STR_TERMINATE);
3046
3047         DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
3048
3049         unix_convert(directory,conn,0,&bad_path,&sbuf);
3050         if (check_name(directory,conn))
3051                 ret = vfs_MkDir(conn,directory,unix_mode(conn,aDIR,directory));
3052
3053         if(ret < 0) {
3054                 DEBUG(5,("call_trans2mkdir error (%s)\n", strerror(errno)));
3055                 set_bad_path_error(errno, bad_path);
3056                 return(UNIXERROR(ERRDOS,ERRnoaccess));
3057         }
3058
3059         /* Realloc the parameter and data sizes */
3060         params = Realloc(*pparams,2);
3061         if(params == NULL)
3062                 return ERROR_DOS(ERRDOS,ERRnomem);
3063         *pparams = params;
3064
3065         SSVAL(params,0,0);
3066
3067         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3068
3069         return(-1);
3070 }
3071
3072 /****************************************************************************
3073  Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
3074  We don't actually do this - we just send a null response.
3075 ****************************************************************************/
3076
3077 static int call_trans2findnotifyfirst(connection_struct *conn,
3078                                         char *inbuf, char *outbuf, int length, int bufsize,
3079                                         char **pparams, int total_params, char **ppdata, int total_data)
3080 {
3081         static uint16 fnf_handle = 257;
3082         char *params = *pparams;
3083         uint16 info_level;
3084
3085         if (total_params < 6)
3086                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3087
3088         info_level = SVAL(params,4);
3089         DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
3090
3091         switch (info_level) {
3092                 case 1:
3093                 case 2:
3094                         break;
3095                 default:
3096                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
3097         }
3098
3099         /* Realloc the parameter and data sizes */
3100         params = Realloc(*pparams,6);
3101         if(params == NULL)
3102                 return ERROR_DOS(ERRDOS,ERRnomem);
3103         *pparams = params;
3104
3105         SSVAL(params,0,fnf_handle);
3106         SSVAL(params,2,0); /* No changes */
3107         SSVAL(params,4,0); /* No EA errors */
3108
3109         fnf_handle++;
3110
3111         if(fnf_handle == 0)
3112                 fnf_handle = 257;
3113
3114         send_trans2_replies(outbuf, bufsize, params, 6, *ppdata, 0);
3115
3116         return(-1);
3117 }
3118
3119 /****************************************************************************
3120  Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
3121  changes). Currently this does nothing.
3122 ****************************************************************************/
3123
3124 static int call_trans2findnotifynext(connection_struct *conn,
3125                                         char *inbuf, char *outbuf, int length, int bufsize,
3126                                         char **pparams, int total_params, char **ppdata, int total_data)
3127 {
3128         char *params = *pparams;
3129
3130         DEBUG(3,("call_trans2findnotifynext\n"));
3131
3132         /* Realloc the parameter and data sizes */
3133         params = Realloc(*pparams,4);
3134         if(params == NULL)
3135                 return ERROR_DOS(ERRDOS,ERRnomem);
3136         *pparams = params;
3137
3138         SSVAL(params,0,0); /* No changes */
3139         SSVAL(params,2,0); /* No EA errors */
3140
3141         send_trans2_replies(outbuf, bufsize, params, 4, *ppdata, 0);
3142
3143         return(-1);
3144 }
3145
3146 /****************************************************************************
3147  Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
3148 ****************************************************************************/
3149
3150 static int call_trans2getdfsreferral(connection_struct *conn, char* inbuf,
3151                                         char* outbuf, int length, int bufsize,
3152                                         char **pparams, int total_params, char **ppdata, int total_data)
3153 {
3154         char *params = *pparams;
3155         pstring pathname;
3156         int reply_size = 0;
3157         int max_referral_level;
3158
3159         DEBUG(10,("call_trans2getdfsreferral\n"));
3160
3161         if (total_params < 2)
3162                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3163
3164         max_referral_level = SVAL(params,0);
3165
3166         if(!lp_host_msdfs())
3167                 return ERROR_DOS(ERRDOS,ERRbadfunc);
3168
3169         srvstr_pull(inbuf, pathname, &params[2], sizeof(pathname), -1, STR_TERMINATE);
3170
3171         if((reply_size = setup_dfs_referral(pathname,max_referral_level,ppdata)) < 0)
3172                 return ERROR_DOS(ERRDOS,ERRbadfile);
3173
3174         SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
3175         send_trans2_replies(outbuf,bufsize,0,0,*ppdata,reply_size);
3176
3177         return(-1);
3178 }
3179
3180 #define LMCAT_SPL       0x53
3181 #define LMFUNC_GETJOBID 0x60
3182
3183 /****************************************************************************
3184  Reply to a TRANS2_IOCTL - used for OS/2 printing.
3185 ****************************************************************************/
3186
3187 static int call_trans2ioctl(connection_struct *conn, char* inbuf,
3188                                         char* outbuf, int length, int bufsize,
3189                                         char **pparams, int total_params, char **ppdata, int total_data)
3190 {
3191         char *pdata = *ppdata;
3192         files_struct *fsp = file_fsp(inbuf,smb_vwv15);
3193
3194         if ((SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
3195                         (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
3196                 pdata = Realloc(*ppdata, 32);
3197                 if(pdata == NULL)
3198                         return ERROR_DOS(ERRDOS,ERRnomem);
3199                 *ppdata = pdata;
3200
3201                 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
3202                         CAN ACCEPT THIS IN UNICODE. JRA. */
3203
3204                 SSVAL(pdata,0,fsp->rap_print_jobid);                     /* Job number */
3205                 srvstr_push( outbuf, pdata + 2, global_myname(), 15, STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
3206                 srvstr_push( outbuf, pdata+18, lp_servicename(SNUM(conn)), 13, STR_ASCII|STR_TERMINATE); /* Service name */
3207                 send_trans2_replies(outbuf,bufsize,*pparams,0,*ppdata,32);
3208                 return(-1);
3209         } else {
3210                 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
3211                 return ERROR_DOS(ERRSRV,ERRerror);
3212         }
3213 }
3214
3215 /****************************************************************************
3216  Reply to a SMBfindclose (stop trans2 directory search).
3217 ****************************************************************************/
3218
3219 int reply_findclose(connection_struct *conn,
3220                     char *inbuf,char *outbuf,int length,int bufsize)
3221 {
3222         int outsize = 0;
3223         int dptr_num=SVALS(inbuf,smb_vwv0);
3224         START_PROFILE(SMBfindclose);
3225
3226         DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
3227
3228         dptr_close(&dptr_num);
3229
3230         outsize = set_message(outbuf,0,0,True);
3231
3232         DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
3233
3234         END_PROFILE(SMBfindclose);
3235         return(outsize);
3236 }
3237
3238 /****************************************************************************
3239  Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
3240 ****************************************************************************/
3241
3242 int reply_findnclose(connection_struct *conn,
3243                      char *inbuf,char *outbuf,int length,int bufsize)
3244 {
3245         int outsize = 0;
3246         int dptr_num= -1;
3247         START_PROFILE(SMBfindnclose);
3248
3249         dptr_num = SVAL(inbuf,smb_vwv0);
3250
3251         DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
3252
3253         /* We never give out valid handles for a
3254            findnotifyfirst - so any dptr_num is ok here.
3255            Just ignore it. */
3256
3257         outsize = set_message(outbuf,0,0,True);
3258
3259         DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
3260
3261         END_PROFILE(SMBfindnclose);
3262         return(outsize);
3263 }
3264
3265 /****************************************************************************
3266  Reply to a SMBtranss2 - just ignore it!
3267 ****************************************************************************/
3268
3269 int reply_transs2(connection_struct *conn,
3270                   char *inbuf,char *outbuf,int length,int bufsize)
3271 {
3272         START_PROFILE(SMBtranss2);
3273         DEBUG(4,("Ignoring transs2 of length %d\n",length));
3274         END_PROFILE(SMBtranss2);
3275         return(-1);
3276 }
3277
3278 /****************************************************************************
3279  Reply to a SMBtrans2.
3280 ****************************************************************************/
3281
3282 int reply_trans2(connection_struct *conn,
3283                  char *inbuf,char *outbuf,int length,int bufsize)
3284 {
3285         int outsize = 0;
3286         unsigned int total_params = SVAL(inbuf, smb_tpscnt);
3287         unsigned int total_data =SVAL(inbuf, smb_tdscnt);
3288 #if 0
3289         unsigned int max_param_reply = SVAL(inbuf, smb_mprcnt);
3290         unsigned int max_data_reply = SVAL(inbuf, smb_mdrcnt);
3291         unsigned int max_setup_fields = SVAL(inbuf, smb_msrcnt);
3292         BOOL close_tid = BITSETW(inbuf+smb_flags,0);
3293         BOOL no_final_response = BITSETW(inbuf+smb_flags,1);
3294         int32 timeout = IVALS(inbuf,smb_timeout);
3295 #endif
3296         unsigned int suwcnt = SVAL(inbuf, smb_suwcnt);
3297         unsigned int tran_call = SVAL(inbuf, smb_setup0);
3298         char *params = NULL, *data = NULL;
3299         unsigned int num_params, num_params_sofar, num_data, num_data_sofar;
3300         START_PROFILE(SMBtrans2);
3301
3302         if(global_oplock_break && (tran_call == TRANSACT2_OPEN)) {
3303                 /* Queue this open message as we are the process of an
3304                  * oplock break.  */
3305
3306                 DEBUG(2,("reply_trans2: queueing message trans2open due to being "));
3307                 DEBUGADD(2,( "in oplock break state.\n"));
3308
3309                 push_oplock_pending_smb_message(inbuf, length);
3310                 END_PROFILE(SMBtrans2);
3311                 return -1;
3312         }
3313
3314         if (IS_IPC(conn) && (tran_call != TRANSACT2_OPEN)
3315             && (tran_call != TRANSACT2_GET_DFS_REFERRAL)) {
3316                 END_PROFILE(SMBtrans2);
3317                 return ERROR_DOS(ERRSRV,ERRaccess);
3318         }
3319
3320         outsize = set_message(outbuf,0,0,True);
3321
3322         /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
3323            is so as a sanity check */
3324         if (suwcnt != 1) {
3325                 /*
3326                  * Need to have rc=0 for ioctl to get job id for OS/2.
3327                  *  Network printing will fail if function is not successful.
3328                  *  Similar function in reply.c will be used if protocol
3329                  *  is LANMAN1.0 instead of LM1.2X002.
3330                  *  Until DosPrintSetJobInfo with PRJINFO3 is supported,
3331                  *  outbuf doesn't have to be set(only job id is used).
3332                  */
3333                 if ( (suwcnt == 4) && (tran_call == TRANSACT2_IOCTL) &&
3334                                 (SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
3335                                 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
3336                         DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
3337                 } else {
3338                         DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",suwcnt));
3339                         DEBUG(2,("Transaction is %d\n",tran_call));
3340                         END_PROFILE(SMBtrans2);
3341                         ERROR_DOS(ERRDOS,ERRinvalidparam);
3342                 }
3343         }
3344
3345         /* Allocate the space for the maximum needed parameters and data */
3346         if (total_params > 0)
3347                 params = (char *)malloc(total_params);
3348         if (total_data > 0)
3349                 data = (char *)malloc(total_data);
3350
3351         if ((total_params && !params)  || (total_data && !data)) {
3352                 DEBUG(2,("Out of memory in reply_trans2\n"));
3353                 SAFE_FREE(params);
3354                 SAFE_FREE(data);
3355                 END_PROFILE(SMBtrans2);
3356                 return ERROR_DOS(ERRDOS,ERRnomem);
3357         }
3358
3359         /* Copy the param and data bytes sent with this request into
3360            the params buffer */
3361         num_params = num_params_sofar = SVAL(inbuf,smb_pscnt);
3362         num_data = num_data_sofar = SVAL(inbuf, smb_dscnt);
3363
3364         if (num_params > total_params || num_data > total_data)
3365                 exit_server("invalid params in reply_trans2");
3366
3367         if(params) {
3368                 unsigned int psoff = SVAL(inbuf, smb_psoff);
3369                 if ((psoff + num_params < psoff) || (psoff + num_params < num_params))
3370                         goto bad_param;
3371                 if (smb_base(inbuf) + psoff + num_params > inbuf + length)
3372                         goto bad_param;
3373                 memcpy( params, smb_base(inbuf) + psoff, num_params);
3374         }
3375         if(data) {
3376                 unsigned int dsoff = SVAL(inbuf, smb_dsoff);
3377                 if ((dsoff + num_data < dsoff) || (dsoff + num_data < num_data))
3378                         goto bad_param;
3379                 if (smb_base(inbuf) + dsoff + num_data > inbuf + length)
3380                         goto bad_param;
3381                 memcpy( data, smb_base(inbuf) + dsoff, num_data);
3382         }
3383
3384         if(num_data_sofar < total_data || num_params_sofar < total_params)  {
3385                 /* We need to send an interim response then receive the rest
3386                    of the parameter/data bytes */
3387                 outsize = set_message(outbuf,0,0,True);
3388                 if (!send_smb(smbd_server_fd(),outbuf))
3389                         exit_server("reply_trans2: send_smb failed.");
3390
3391                 while (num_data_sofar < total_data ||
3392                        num_params_sofar < total_params) {
3393                         BOOL ret;
3394                         unsigned int param_disp;
3395                         unsigned int param_off;
3396                         unsigned int data_disp;
3397                         unsigned int data_off;
3398
3399                         ret = receive_next_smb(inbuf,bufsize,SMB_SECONDARY_WAIT);
3400
3401                         if ((ret &&
3402                              (CVAL(inbuf, smb_com) != SMBtranss2)) || !ret) {
3403                                 outsize = set_message(outbuf,0,0,True);
3404                                 if(ret)
3405                                         DEBUG(0,("reply_trans2: Invalid secondary trans2 packet\n"));
3406                                 else
3407                                         DEBUG(0,("reply_trans2: %s in getting secondary trans2 response.\n",
3408                                                  (smb_read_error == READ_ERROR) ? "error" : "timeout" ));
3409                                 goto bad_param;
3410                         }
3411
3412                         /* Revise total_params and total_data in case
3413                            they have changed downwards */
3414                         if (SVAL(inbuf, smb_tpscnt) < total_params)
3415                                 total_params = SVAL(inbuf, smb_tpscnt);
3416                         if (SVAL(inbuf, smb_tdscnt) < total_data)
3417                                 total_data = SVAL(inbuf, smb_tdscnt);
3418
3419                         num_params = SVAL(inbuf,smb_spscnt);
3420                         param_off = SVAL(inbuf, smb_spsoff);
3421                         param_disp = SVAL(inbuf, smb_spsdisp);
3422                         num_params_sofar += num_params;
3423
3424                         num_data = SVAL(inbuf, smb_sdscnt);
3425                         data_off = SVAL(inbuf, smb_sdsoff);
3426                         data_disp = SVAL(inbuf, smb_sdsdisp);
3427                         num_data_sofar += num_data;
3428
3429                         if (num_params_sofar > total_params || num_data_sofar > total_data)
3430                                 goto bad_param;
3431
3432                         if (num_params) {
3433                                 if (param_disp + num_params >= total_params)
3434                                         goto bad_param;
3435                                 if ((param_disp + num_params < param_disp) ||
3436                                                 (param_disp + num_params < num_params))
3437                                         goto bad_param;
3438                                 if (smb_base(inbuf) + param_off + num_params >= inbuf + bufsize)
3439                                         goto bad_param;
3440                                 if (params + param_disp < params)
3441                                         goto bad_param;
3442
3443                                 memcpy( &params[param_disp], smb_base(inbuf) + param_off, num_params);
3444                         }
3445                         if (num_data) {
3446                                 if (data_disp + num_data >= total_data)
3447                                         goto bad_param;
3448                                 if ((data_disp + num_data < data_disp) ||
3449                                                 (data_disp + num_data < num_data))
3450                                         goto bad_param;
3451                                 if (smb_base(inbuf) + data_off + num_data >= inbuf + bufsize)
3452                                         goto bad_param;
3453                                 if (data + data_disp < data)
3454                                         goto bad_param;
3455
3456                                 memcpy( &data[data_disp], smb_base(inbuf) + data_off, num_data);
3457                         }
3458                 }
3459         }
3460
3461         if (Protocol >= PROTOCOL_NT1) {
3462                 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | 0x40); /* IS_LONG_NAME */
3463         }
3464
3465         /* Now we must call the relevant TRANS2 function */
3466         switch(tran_call)  {
3467         case TRANSACT2_OPEN:
3468                 START_PROFILE_NESTED(Trans2_open);
3469                 outsize = call_trans2open(conn, inbuf, outbuf, bufsize,
3470                                           &params, total_params, &data, total_data);
3471                 END_PROFILE_NESTED(Trans2_open);
3472                 break;
3473
3474         case TRANSACT2_FINDFIRST:
3475                 START_PROFILE_NESTED(Trans2_findfirst);
3476                 outsize = call_trans2findfirst(conn, inbuf, outbuf, bufsize,
3477                                           &params, total_params, &data, total_data);
3478                 END_PROFILE_NESTED(Trans2_findfirst);
3479                 break;
3480
3481         case TRANSACT2_FINDNEXT:
3482                 START_PROFILE_NESTED(Trans2_findnext);
3483                 outsize = call_trans2findnext(conn, inbuf, outbuf, length, bufsize,
3484                                           &params, total_params, &data, total_data);
3485                 END_PROFILE_NESTED(Trans2_findnext);
3486                 break;
3487
3488         case TRANSACT2_QFSINFO:
3489                 START_PROFILE_NESTED(Trans2_qfsinfo);
3490                 outsize = call_trans2qfsinfo(conn, inbuf, outbuf, length, bufsize,
3491                                           &params, total_params, &data, total_data);
3492                 END_PROFILE_NESTED(Trans2_qfsinfo);
3493             break;
3494
3495 #ifdef WITH_QUOTAS
3496         case TRANSACT2_SETFSINFO:
3497                 START_PROFILE_NESTED(Trans2_setfsinfo);
3498                 outsize = call_trans2setfsinfo(conn, inbuf, outbuf, length, bufsize,
3499                                           &params, total_params, &data, total_data);
3500                 END_PROFILE_NESTED(Trans2_setfsinfo);
3501                 break;
3502 #endif
3503         case TRANSACT2_QPATHINFO:
3504         case TRANSACT2_QFILEINFO:
3505                 START_PROFILE_NESTED(Trans2_qpathinfo);
3506                 outsize = call_trans2qfilepathinfo(conn, inbuf, outbuf, length, bufsize,
3507                                           &params, total_params, &data, total_data);
3508                 END_PROFILE_NESTED(Trans2_qpathinfo);
3509                 break;
3510         case TRANSACT2_SETPATHINFO:
3511         case TRANSACT2_SETFILEINFO:
3512                 START_PROFILE_NESTED(Trans2_setpathinfo);
3513                 outsize = call_trans2setfilepathinfo(conn, inbuf, outbuf, length, bufsize,
3514                                           &params, total_params, &data, total_data);
3515                 END_PROFILE_NESTED(Trans2_setpathinfo);
3516                 break;
3517
3518         case TRANSACT2_FINDNOTIFYFIRST:
3519                 START_PROFILE_NESTED(Trans2_findnotifyfirst);
3520                 outsize = call_trans2findnotifyfirst(conn, inbuf, outbuf, length, bufsize,
3521                                           &params, total_params, &data, total_data);
3522                 END_PROFILE_NESTED(Trans2_findnotifyfirst);
3523                 break;
3524
3525         case TRANSACT2_FINDNOTIFYNEXT:
3526                 START_PROFILE_NESTED(Trans2_findnotifynext);
3527                 outsize = call_trans2findnotifynext(conn, inbuf, outbuf, length, bufsize,
3528                                           &params, total_params, &data, total_data);
3529                 END_PROFILE_NESTED(Trans2_findnotifynext);
3530                 break;
3531         case TRANSACT2_MKDIR:
3532                 START_PROFILE_NESTED(Trans2_mkdir);
3533                 outsize = call_trans2mkdir(conn, inbuf, outbuf, length, bufsize,
3534                                           &params, total_params, &data, total_data);
3535                 END_PROFILE_NESTED(Trans2_mkdir);
3536                 break;
3537
3538         case TRANSACT2_GET_DFS_REFERRAL:
3539                 START_PROFILE_NESTED(Trans2_get_dfs_referral);
3540                 outsize = call_trans2getdfsreferral(conn,inbuf,outbuf,length, bufsize,
3541                                           &params, total_params, &data, total_data);
3542                 END_PROFILE_NESTED(Trans2_get_dfs_referral);
3543                 break;
3544         case TRANSACT2_IOCTL:
3545                 START_PROFILE_NESTED(Trans2_ioctl);
3546                 outsize = call_trans2ioctl(conn,inbuf,outbuf,length, bufsize,
3547                                           &params, total_params, &data, total_data);
3548                 END_PROFILE_NESTED(Trans2_ioctl);
3549                 break;
3550         default:
3551                 /* Error in request */
3552                 DEBUG(2,("Unknown request %d in trans2 call\n", tran_call));
3553                 SAFE_FREE(params);
3554                 SAFE_FREE(data);
3555                 END_PROFILE(SMBtrans2);
3556                 return ERROR_DOS(ERRSRV,ERRerror);
3557         }
3558
3559         /* As we do not know how many data packets will need to be
3560            returned here the various call_trans2xxxx calls
3561            must send their own. Thus a call_trans2xxx routine only
3562            returns a value other than -1 when it wants to send
3563            an error packet.
3564         */
3565
3566         SAFE_FREE(params);
3567         SAFE_FREE(data);
3568         END_PROFILE(SMBtrans2);
3569         return outsize; /* If a correct response was needed the
3570                            call_trans2xxx calls have already sent
3571                            it. If outsize != -1 then it is returning */
3572
3573   bad_param:
3574
3575         SAFE_FREE(params);
3576         SAFE_FREE(data);
3577         END_PROFILE(SMBtrans2);
3578         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3579 }