source3/smbd/trans2.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB transaction2 handling
   4    Copyright (C) Jeremy Allison                 1994-2003
   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 enum protocol_types Protocol;
  27 extern int smb_read_error;
  28 extern fstring local_machine;
  29 extern int global_oplock_break;
  30 extern uint32 global_client_caps;
  31 extern struct current_user current_user;
  32
  33 #define get_file_size(sbuf) ((sbuf).st_size)
  34 #define DIR_ENTRY_SAFETY_MARGIN 4096
  35
  36 /********************************************************************
  37  Roundup a value to the nearest SMB_ROUNDUP_ALLOCATION_SIZE boundary.
  38  Only do this for Windows clients.
  39 ********************************************************************/
  40
  41 SMB_BIG_UINT smb_roundup(SMB_BIG_UINT val)
  42 {
  43         /* Only roundup for Windows clients. */
  44         enum remote_arch_types ra_type = get_remote_arch();
  45         if ((ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
  46                 val = SMB_ROUNDUP(val,SMB_ROUNDUP_ALLOCATION_SIZE);
  47         }
  48         return val;
  49 }
  50
  51 /********************************************************************
  52  Given a stat buffer return the allocated size on disk, taking into
  53  account sparse files.
  54 ********************************************************************/
  55
  56 SMB_BIG_UINT get_allocation_size(files_struct *fsp, SMB_STRUCT_STAT *sbuf)
  57 {
  58         SMB_BIG_UINT ret;
  59
  60 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
  61         ret = (SMB_BIG_UINT)STAT_ST_BLOCKSIZE * (SMB_BIG_UINT)sbuf->st_blocks;
  62 #else
  63         ret = (SMB_BIG_UINT)get_file_size(*sbuf);
  64 #endif
  65
  66         if (!ret && fsp && fsp->initial_allocation_size)
  67                 ret = fsp->initial_allocation_size;
  68
  69         ret = smb_roundup(ret);
  70
  71         return ret;
  72 }
  73
  74 /****************************************************************************
  75  Utility functions for dealing with extended attributes.
  76 ****************************************************************************/
  77
  78 static const char *prohibited_ea_names[] = {
  79         SAMBA_POSIX_INHERITANCE_EA_NAME,
  80         SAMBA_XATTR_DOS_ATTRIB,
  81         NULL
  82 };
  83
  84 /****************************************************************************
  85  Refuse to allow clients to overwrite our private xattrs.
  86 ****************************************************************************/
  87
  88 static BOOL samba_private_attr_name(const char *unix_ea_name)
  89 {
  90         int i;
  91
  92         for (i = 0; prohibited_ea_names[i]; i++) {
  93                 if (strequal( prohibited_ea_names[i], unix_ea_name))
  94                         return True;
  95         }
  96         return False;
  97 }
  98
  99 struct ea_list {
 100         struct ea_list *next, *prev;
 101         struct ea_struct ea;
 102 };
 103
 104 /****************************************************************************
 105  Get one EA value. Fill in a struct ea_struct.
 106 ****************************************************************************/
 107
 108 static BOOL get_ea_value(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
 109                                 const char *fname, char *ea_name, struct ea_struct *pea)
 110 {
 111         /* Get the value of this xattr. Max size is 64k. */
 112         size_t attr_size = 256;
 113         char *val = NULL;
 114         ssize_t sizeret;
 115
 116  again:
 117
 118         val = talloc_realloc(mem_ctx, val, attr_size);
 119         if (!val) {
 120                 return False;
 121         }
 122
 123         if (fsp && fsp->fd != -1) {
 124                 sizeret = SMB_VFS_FGETXATTR(fsp, fsp->fd, ea_name, val, attr_size);
 125         } else {
 126                 sizeret = SMB_VFS_GETXATTR(conn, fname, ea_name, val, attr_size);
 127         }
 128
 129         if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
 130                 attr_size = 65536;
 131                 goto again;
 132         }
 133
 134         if (sizeret == -1) {
 135                 return False;
 136         }
 137
 138         DEBUG(10,("get_ea_value: EA %s is of length %d: ", ea_name, sizeret));
 139         dump_data(10, val, sizeret);
 140
 141         pea->flags = 0;
 142         if (strnequal(ea_name, "user.", 5)) {
 143                 pea->name = &ea_name[5];
 144         } else {
 145                 pea->name = ea_name;
 146         }
 147         pea->value.data = val;
 148         pea->value.length = (size_t)sizeret;
 149         return True;
 150 }
 151
 152 /****************************************************************************
 153  Return a linked list of the total EA's. Plus the total size
 154 ****************************************************************************/
 155
 156 static struct ea_list *get_ea_list(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp, const char *fname, size_t *pea_total_len)
 157 {
 158         /* Get a list of all xattrs. Max namesize is 64k. */
 159         size_t ea_namelist_size = 1024;
 160         char *ea_namelist;
 161         char *p;
 162         ssize_t sizeret;
 163         int i;
 164         struct ea_list *ea_list_head = NULL;
 165
 166         *pea_total_len = 0;
 167
 168         if (!lp_ea_support(SNUM(conn))) {
 169                 return NULL;
 170         }
 171
 172         for (i = 0, ea_namelist = talloc(mem_ctx, ea_namelist_size); i < 6;
 173                         ea_namelist = talloc_realloc(mem_ctx, ea_namelist, ea_namelist_size), i++) {
 174                 if (fsp && fsp->fd != -1) {
 175                         sizeret = SMB_VFS_FLISTXATTR(fsp, fsp->fd, ea_namelist, ea_namelist_size);
 176                 } else {
 177                         sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist, ea_namelist_size);
 178                 }
 179
 180                 if (sizeret == -1 && errno == ERANGE) {
 181                         ea_namelist_size *= 2;
 182                 } else {
 183                         break;
 184                 }
 185         }
 186
 187         if (sizeret == -1)
 188                 return NULL;
 189
 190         DEBUG(10,("get_ea_list: ea_namelist size = %d\n", sizeret ));
 191
 192         if (sizeret) {
 193                 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p) + 1) {
 194                         struct ea_list *listp, *tmp;
 195
 196                         if (strnequal(p, "system.", 7) || samba_private_attr_name(p))
 197                                 continue;
 198
 199                         listp = talloc(mem_ctx, sizeof(struct ea_list));
 200                         if (!listp)
 201                                 return NULL;
 202
 203                         if (!get_ea_value(mem_ctx, conn, fsp, fname, p, &listp->ea)) {
 204                                 return NULL;
 205                         }
 206
 207                         {
 208                                 fstring dos_ea_name;
 209                                 push_ascii_fstring(dos_ea_name, listp->ea.name);
 210                                 *pea_total_len += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
 211                                 DEBUG(10,("get_ea_list: total_len = %u, %s, val len = %u\n",
 212                                         *pea_total_len, dos_ea_name,
 213                                         (unsigned int)listp->ea.value.length ));
 214                         }
 215                         DLIST_ADD_END(ea_list_head, listp, tmp);
 216                 }
 217                 /* Add on 4 for total length. */
 218                 if (*pea_total_len) {
 219                         *pea_total_len += 4;
 220                 }
 221         }
 222
 223         DEBUG(10,("get_ea_list: total_len = %u\n", *pea_total_len));
 224         return ea_list_head;
 225 }
 226
 227 /****************************************************************************
 228  Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
 229  that was filled.
 230 ****************************************************************************/
 231
 232 static unsigned int fill_ea_buffer(char *pdata, unsigned int total_data_size,
 233         connection_struct *conn, files_struct *fsp, const char *fname)
 234 {
 235         unsigned int ret_data_size = 4;
 236         char *p = pdata;
 237         size_t total_ea_len;
 238         TALLOC_CTX *mem_ctx;
 239         struct ea_list *ea_list;
 240
 241         SMB_ASSERT(total_data_size >= 4);
 242
 243         SIVAL(pdata,0,0);
 244         if (!lp_ea_support(SNUM(conn))) {
 245                 return 4;
 246         }
 247         mem_ctx = talloc_init("fill_ea_buffer");
 248         if (!mem_ctx) {
 249                 return 4;
 250         }
 251
 252         ea_list = get_ea_list(mem_ctx, conn, fsp, fname, &total_ea_len);
 253         if (!ea_list) {
 254                 talloc_destroy(mem_ctx);
 255                 return 4;
 256         }
 257
 258         if (total_ea_len > total_data_size) {
 259                 talloc_destroy(mem_ctx);
 260                 return 4;
 261         }
 262
 263         for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
 264                 size_t dos_namelen;
 265                 fstring dos_ea_name;
 266                 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
 267                 dos_namelen = strlen(dos_ea_name);
 268                 if (dos_namelen > 255 || dos_namelen == 0) {
 269                         break;
 270                 }
 271                 if (ea_list->ea.value.length > 65535) {
 272                         break;
 273                 }
 274                 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
 275                         break;
 276                 }
 277
 278                 /* We know we have room. */
 279                 SCVAL(p,0,ea_list->ea.flags);
 280                 SCVAL(p,1,dos_namelen);
 281                 SSVAL(p,2,ea_list->ea.value.length);
 282                 fstrcpy(p+4, dos_ea_name);
 283                 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
 284
 285                 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
 286                 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
 287         }
 288
 289         ret_data_size = PTR_DIFF(p, pdata);
 290         DEBUG(10,("fill_ea_buffer: data_size = %u, total_ea_len = %u\n",
 291                         ret_data_size, total_ea_len ));
 292         talloc_destroy(mem_ctx);
 293         SIVAL(pdata,0,ret_data_size);
 294         return ret_data_size;
 295 }
 296
 297 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
 298 {
 299         size_t total_ea_len = 0;
 300         TALLOC_CTX *mem_ctx = NULL;
 301
 302         if (!lp_ea_support(SNUM(conn))) {
 303                 return 0;
 304         }
 305         mem_ctx = talloc_init("estimate_ea_size");
 306         (void)get_ea_list(mem_ctx, conn, fsp, fname, &total_ea_len);
 307         talloc_destroy(mem_ctx);
 308         return total_ea_len;
 309 }
 310
 311 /****************************************************************************
 312  Ensure the EA name is case insensitive by matching any existing EA name.
 313 ****************************************************************************/
 314
 315 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
 316 {
 317         size_t total_ea_len;
 318         TALLOC_CTX *mem_ctx = talloc_init("canonicalize_ea_name");
 319         struct ea_list *ea_list = get_ea_list(mem_ctx, conn, fsp, fname, &total_ea_len);
 320
 321         for (; ea_list; ea_list = ea_list->next) {
 322                 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
 323                         DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
 324                                 &unix_ea_name[5], ea_list->ea.name));
 325                         safe_strcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-6);
 326                         break;
 327                 }
 328         }
 329         talloc_destroy(mem_ctx);
 330 }
 331
 332 /****************************************************************************
 333  Set or delete an extended attribute.
 334 ****************************************************************************/
 335
 336 static NTSTATUS set_ea(connection_struct *conn, files_struct *fsp, const char *fname,
 337                         char *pdata, int total_data)
 338 {
 339         unsigned int namelen;
 340         unsigned int ealen;
 341         int ret;
 342         fstring unix_ea_name;
 343
 344         if (!lp_ea_support(SNUM(conn))) {
 345                 return NT_STATUS_EAS_NOT_SUPPORTED;
 346         }
 347
 348         if (total_data < 8) {
 349                 return NT_STATUS_INVALID_PARAMETER;
 350         }
 351
 352         if (IVAL(pdata,0) > total_data) {
 353                 DEBUG(10,("set_ea: bad total data size (%u) > %u\n", IVAL(pdata,0), (unsigned int)total_data));
 354                 return NT_STATUS_INVALID_PARAMETER;
 355         }
 356
 357         pdata += 4;
 358         namelen = CVAL(pdata,1);
 359         ealen = SVAL(pdata,2);
 360         pdata += 4;
 361         if (total_data < 8 + namelen + 1 + ealen) {
 362                 DEBUG(10,("set_ea: bad total data size (%u) < 8 + namelen (%u) + 1 + ealen (%u)\n",
 363                         (unsigned int)total_data, namelen, ealen));
 364                 return NT_STATUS_INVALID_PARAMETER;
 365         }
 366
 367         if (pdata[namelen] != '\0') {
 368                 DEBUG(10,("set_ea: ea name not null terminated\n"));
 369                 return NT_STATUS_INVALID_PARAMETER;
 370         }
 371
 372         fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
 373         pull_ascii(&unix_ea_name[5], pdata, sizeof(fstring) - 5, -1, STR_TERMINATE);
 374         pdata += (namelen + 1);
 375
 376         canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
 377
 378         DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, ealen));
 379         if (ealen) {
 380                 DEBUG(10,("set_ea: data :\n"));
 381                 dump_data(10, pdata, ealen);
 382         }
 383
 384         if (samba_private_attr_name(unix_ea_name)) {
 385                 DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
 386                 return NT_STATUS_ACCESS_DENIED;
 387         }
 388
 389         if (ealen == 0) {
 390                 /* Remove the attribute. */
 391                 if (fsp && (fsp->fd != -1)) {
 392                         DEBUG(10,("set_ea: deleting ea name %s on file %s by file descriptor.\n",
 393                                 unix_ea_name, fsp->fsp_name));
 394                         ret = SMB_VFS_FREMOVEXATTR(fsp, fsp->fd, unix_ea_name);
 395                 } else {
 396                         DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
 397                                 unix_ea_name, fname));
 398                         ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
 399                 }
 400 #ifdef ENOATTR
 401                 /* Removing a non existent attribute always succeeds. */
 402                 if (ret == -1 && errno == ENOATTR) {
 403                         DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n", unix_ea_name));
 404                         ret = 0;
 405                 }
 406 #endif
 407         } else {
 408                 if (fsp && (fsp->fd != -1)) {
 409                         DEBUG(10,("set_ea: setting ea name %s on file %s by file descriptor.\n",
 410                                 unix_ea_name, fsp->fsp_name));
 411                         ret = SMB_VFS_FSETXATTR(fsp, fsp->fd, unix_ea_name, pdata, ealen, 0);
 412                 } else {
 413                         DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
 414                                 unix_ea_name, fname));
 415                         ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name, pdata, ealen, 0);
 416                 }
 417         }
 418
 419         if (ret == -1) {
 420 #ifdef ENOTSUP
 421                 if (errno == ENOTSUP) {
 422                         return NT_STATUS_EAS_NOT_SUPPORTED;
 423                 }
 424 #endif
 425                 return map_nt_error_from_unix(errno);
 426         }
 427
 428         return NT_STATUS_OK;
 429 }
 430
 431 /****************************************************************************
 432   Send the required number of replies back.
 433   We assume all fields other than the data fields are
 434   set correctly for the type of call.
 435   HACK ! Always assumes smb_setup field is zero.
 436 ****************************************************************************/
 437
 438 static int send_trans2_replies(char *outbuf,
 439                         int bufsize,
 440                         char *params,
 441                         int paramsize,
 442                         char *pdata,
 443                         int datasize)
 444 {
 445         /* As we are using a protocol > LANMAN1 then the max_send
 446          variable must have been set in the sessetupX call.
 447          This takes precedence over the max_xmit field in the
 448          global struct. These different max_xmit variables should
 449          be merged as this is now too confusing */
 450
 451         extern int max_send;
 452         int data_to_send = datasize;
 453         int params_to_send = paramsize;
 454         int useable_space;
 455         char *pp = params;
 456         char *pd = pdata;
 457         int params_sent_thistime, data_sent_thistime, total_sent_thistime;
 458         int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
 459         int data_alignment_offset = 0;
 460
 461         /* Initially set the wcnt area to be 10 - this is true for all trans2 replies */
 462
 463         set_message(outbuf,10,0,True);
 464
 465         /* If there genuinely are no parameters or data to send just send the empty packet */
 466
 467         if(params_to_send == 0 && data_to_send == 0) {
 468                 if (!send_smb(smbd_server_fd(),outbuf))
 469                         exit_server("send_trans2_replies: send_smb failed.");
 470                 return 0;
 471         }
 472
 473         /* When sending params and data ensure that both are nicely aligned */
 474         /* Only do this alignment when there is also data to send - else
 475                 can cause NT redirector problems. */
 476
 477         if (((params_to_send % 4) != 0) && (data_to_send != 0))
 478                 data_alignment_offset = 4 - (params_to_send % 4);
 479
 480         /* Space is bufsize minus Netbios over TCP header minus SMB header */
 481         /* The alignment_offset is to align the param bytes on an even byte
 482                 boundary. NT 4.0 Beta needs this to work correctly. */
 483
 484         useable_space = bufsize - ((smb_buf(outbuf)+ alignment_offset+data_alignment_offset) - outbuf);
 485
 486         /* useable_space can never be more than max_send minus the alignment offset. */
 487
 488         useable_space = MIN(useable_space, max_send - (alignment_offset+data_alignment_offset));
 489
 490         while (params_to_send || data_to_send) {
 491                 /* Calculate whether we will totally or partially fill this packet */
 492
 493                 total_sent_thistime = params_to_send + data_to_send + alignment_offset + data_alignment_offset;
 494
 495                 /* We can never send more than useable_space */
 496                 /*
 497                  * Note that 'useable_space' does not include the alignment offsets,
 498                  * but we must include the alignment offsets in the calculation of
 499                  * the length of the data we send over the wire, as the alignment offsets
 500                  * are sent here. Fix from Marc_Jacobsen@hp.com.
 501                  */
 502
 503                 total_sent_thistime = MIN(total_sent_thistime, useable_space+ alignment_offset + data_alignment_offset);
 504
 505                 set_message(outbuf, 10, total_sent_thistime, True);
 506
 507                 /* Set total params and data to be sent */
 508                 SSVAL(outbuf,smb_tprcnt,paramsize);
 509                 SSVAL(outbuf,smb_tdrcnt,datasize);
 510
 511                 /* Calculate how many parameters and data we can fit into
 512                  * this packet. Parameters get precedence
 513                  */
 514
 515                 params_sent_thistime = MIN(params_to_send,useable_space);
 516                 data_sent_thistime = useable_space - params_sent_thistime;
 517                 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
 518
 519                 SSVAL(outbuf,smb_prcnt, params_sent_thistime);
 520
 521                 /* smb_proff is the offset from the start of the SMB header to the
 522                         parameter bytes, however the first 4 bytes of outbuf are
 523                         the Netbios over TCP header. Thus use smb_base() to subtract
 524                         them from the calculation */
 525
 526                 SSVAL(outbuf,smb_proff,((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
 527
 528                 if(params_sent_thistime == 0)
 529                         SSVAL(outbuf,smb_prdisp,0);
 530                 else
 531                         /* Absolute displacement of param bytes sent in this packet */
 532                         SSVAL(outbuf,smb_prdisp,pp - params);
 533
 534                 SSVAL(outbuf,smb_drcnt, data_sent_thistime);
 535                 if(data_sent_thistime == 0) {
 536                         SSVAL(outbuf,smb_droff,0);
 537                         SSVAL(outbuf,smb_drdisp, 0);
 538                 } else {
 539                         /* The offset of the data bytes is the offset of the
 540                                 parameter bytes plus the number of parameters being sent this time */
 541                         SSVAL(outbuf,smb_droff,((smb_buf(outbuf)+alignment_offset) -
 542                                 smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
 543                         SSVAL(outbuf,smb_drdisp, pd - pdata);
 544                 }
 545
 546                 /* Copy the param bytes into the packet */
 547
 548                 if(params_sent_thistime)
 549                         memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
 550
 551                 /* Copy in the data bytes */
 552                 if(data_sent_thistime)
 553                         memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
 554                                 data_alignment_offset,pd,data_sent_thistime);
 555
 556                 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
 557                         params_sent_thistime, data_sent_thistime, useable_space));
 558                 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
 559                         params_to_send, data_to_send, paramsize, datasize));
 560
 561                 /* Send the packet */
 562                 if (!send_smb(smbd_server_fd(),outbuf))
 563                         exit_server("send_trans2_replies: send_smb failed.");
 564
 565                 pp += params_sent_thistime;
 566                 pd += data_sent_thistime;
 567
 568                 params_to_send -= params_sent_thistime;
 569                 data_to_send -= data_sent_thistime;
 570
 571                 /* Sanity check */
 572                 if(params_to_send < 0 || data_to_send < 0) {
 573                         DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
 574                                 params_to_send, data_to_send));
 575                         return -1;
 576                 }
 577         }
 578
 579         return 0;
 580 }
 581
 582 /****************************************************************************
 583  Reply to a TRANSACT2_OPEN.
 584 ****************************************************************************/
 585
 586 static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
 587                                 char **pparams, int total_params, char **ppdata, int total_data,
 588                                 unsigned int max_data_bytes)
 589 {
 590         char *params = *pparams;
 591         int16 open_mode;
 592         int16 open_attr;
 593         BOOL oplock_request;
 594 #if 0
 595         BOOL return_additional_info;
 596         int16 open_sattr;
 597         time_t open_time;
 598 #endif
 599         int16 open_ofun;
 600         int32 open_size;
 601         char *pname;
 602         pstring fname;
 603         SMB_OFF_T size=0;
 604         int fmode=0,mtime=0,rmode;
 605         SMB_INO_T inode = 0;
 606         SMB_STRUCT_STAT sbuf;
 607         int smb_action = 0;
 608         BOOL bad_path = False;
 609         files_struct *fsp;
 610         NTSTATUS status;
 611
 612         /*
 613          * Ensure we have enough parameters to perform the operation.
 614          */
 615
 616         if (total_params < 29)
 617                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
 618
 619         open_mode = SVAL(params, 2);
 620         open_attr = SVAL(params,6);
 621         oplock_request = (((SVAL(params,0)|(1<<1))>>1) | ((SVAL(params,0)|(1<<2))>>1));
 622 #if 0
 623         return_additional_info = BITSETW(params,0);
 624         open_sattr = SVAL(params, 4);
 625         open_time = make_unix_date3(params+8);
 626 #endif
 627         open_ofun = SVAL(params,12);
 628         open_size = IVAL(params,14);
 629         pname = &params[28];
 630
 631         if (IS_IPC(conn))
 632                 return(ERROR_DOS(ERRSRV,ERRaccess));
 633
 634         srvstr_get_path(inbuf, fname, pname, sizeof(fname), -1, STR_TERMINATE, &status, False);
 635         if (!NT_STATUS_IS_OK(status)) {
 636                 return ERROR_NT(status);
 637         }
 638
 639         DEBUG(3,("trans2open %s mode=%d attr=%d ofun=%d size=%d\n",
 640                 fname,open_mode, open_attr, open_ofun, open_size));
 641
 642         /* XXXX we need to handle passed times, sattr and flags */
 643
 644         unix_convert(fname,conn,0,&bad_path,&sbuf);
 645         if (bad_path) {
 646                 return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
 647         }
 648
 649         if (!check_name(fname,conn)) {
 650                 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRnoaccess);
 651         }
 652
 653         fsp = open_file_shared(conn,fname,&sbuf,open_mode,open_ofun,(uint32)open_attr,
 654                 oplock_request, &rmode,&smb_action);
 655
 656         if (!fsp) {
 657                 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
 658                         /* We have re-scheduled this call. */
 659                         clear_cached_errors();
 660                         return -1;
 661                 }
 662                 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRnoaccess);
 663         }
 664
 665         size = get_file_size(sbuf);
 666         fmode = dos_mode(conn,fname,&sbuf);
 667         mtime = sbuf.st_mtime;
 668         inode = sbuf.st_ino;
 669         if (fmode & aDIR) {
 670                 close_file(fsp,False);
 671                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
 672         }
 673
 674         /* Realloc the size of parameters and data we will return */
 675         params = Realloc(*pparams, 28);
 676         if( params == NULL )
 677                 return(ERROR_DOS(ERRDOS,ERRnomem));
 678         *pparams = params;
 679
 680         memset((char *)params,'\0',28);
 681         SSVAL(params,0,fsp->fnum);
 682         SSVAL(params,2,fmode);
 683         put_dos_date2(params,4, mtime);
 684         SIVAL(params,8, (uint32)size);
 685         SSVAL(params,12,rmode);
 686
 687         if (oplock_request && lp_fake_oplocks(SNUM(conn)))
 688                 smb_action |= EXTENDED_OPLOCK_GRANTED;
 689
 690         SSVAL(params,18,smb_action);
 691
 692         /*
 693          * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
 694          */
 695         SIVAL(params,20,inode);
 696
 697         /* Send the required number of replies */
 698         send_trans2_replies(outbuf, bufsize, params, 28, *ppdata, 0);
 699
 700         return -1;
 701 }
 702
 703 /*********************************************************
 704  Routine to check if a given string matches exactly.
 705  as a special case a mask of "." does NOT match. That
 706  is required for correct wildcard semantics
 707  Case can be significant or not.
 708 **********************************************************/
 709
 710 static BOOL exact_match(char *str,char *mask, BOOL case_sig)
 711 {
 712         if (mask[0] == '.' && mask[1] == 0)
 713                 return False;
 714         if (case_sig)
 715                 return strcmp(str,mask)==0;
 716         if (StrCaseCmp(str,mask) != 0) {
 717                 return False;
 718         }
 719         if (ms_has_wild(str)) {
 720                 return False;
 721         }
 722         return True;
 723 }
 724
 725 /****************************************************************************
 726  Return the filetype for UNIX extensions.
 727 ****************************************************************************/
 728
 729 static uint32 unix_filetype(mode_t mode)
 730 {
 731         if(S_ISREG(mode))
 732                 return UNIX_TYPE_FILE;
 733         else if(S_ISDIR(mode))
 734                 return UNIX_TYPE_DIR;
 735 #ifdef S_ISLNK
 736         else if(S_ISLNK(mode))
 737                 return UNIX_TYPE_SYMLINK;
 738 #endif
 739 #ifdef S_ISCHR
 740         else if(S_ISCHR(mode))
 741                 return UNIX_TYPE_CHARDEV;
 742 #endif
 743 #ifdef S_ISBLK
 744         else if(S_ISBLK(mode))
 745                 return UNIX_TYPE_BLKDEV;
 746 #endif
 747 #ifdef S_ISFIFO
 748         else if(S_ISFIFO(mode))
 749                 return UNIX_TYPE_FIFO;
 750 #endif
 751 #ifdef S_ISSOCK
 752         else if(S_ISSOCK(mode))
 753                 return UNIX_TYPE_SOCKET;
 754 #endif
 755
 756         DEBUG(0,("unix_filetype: unknown filetype %u", (unsigned)mode));
 757         return UNIX_TYPE_UNKNOWN;
 758 }
 759
 760 /****************************************************************************
 761  Map wire perms onto standard UNIX permissions. Obey share restrictions.
 762 ****************************************************************************/
 763
 764 static mode_t unix_perms_from_wire( connection_struct *conn, SMB_STRUCT_STAT *pst, uint32 perms)
 765 {
 766         mode_t ret = 0;
 767
 768         if (perms == SMB_MODE_NO_CHANGE)
 769                 return pst->st_mode;
 770
 771         ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
 772         ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
 773         ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
 774         ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
 775         ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
 776         ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
 777         ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
 778         ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
 779         ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
 780 #ifdef S_ISVTX
 781         ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
 782 #endif
 783 #ifdef S_ISGID
 784         ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
 785 #endif
 786 #ifdef S_ISUID
 787         ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
 788 #endif
 789
 790         if (VALID_STAT(*pst) && S_ISDIR(pst->st_mode)) {
 791                 ret &= lp_dir_mask(SNUM(conn));
 792                 /* Add in force bits */
 793                 ret |= lp_force_dir_mode(SNUM(conn));
 794         } else {
 795                 /* Apply mode mask */
 796                 ret &= lp_create_mask(SNUM(conn));
 797                 /* Add in force bits */
 798                 ret |= lp_force_create_mode(SNUM(conn));
 799         }
 800
 801         return ret;
 802 }
 803
 804 /****************************************************************************
 805  Checks for SMB_TIME_NO_CHANGE and if not found calls interpret_long_date.
 806 ****************************************************************************/
 807
 808 time_t interpret_long_unix_date(char *p)
 809 {
 810         DEBUG(10,("interpret_long_unix_date\n"));
 811         if(IVAL(p,0) == SMB_TIME_NO_CHANGE_LO &&
 812            IVAL(p,4) == SMB_TIME_NO_CHANGE_HI) {
 813                 return -1;
 814         } else {
 815                 return interpret_long_date(p);
 816         }
 817 }
 818
 819 /****************************************************************************
 820  Get a level dependent lanman2 dir entry.
 821 ****************************************************************************/
 822
 823 static BOOL get_lanman2_dir_entry(connection_struct *conn,
 824                                   void *inbuf, void *outbuf,
 825                                  char *path_mask,int dirtype,int info_level,
 826                                  int requires_resume_key,
 827                                  BOOL dont_descend,char **ppdata,
 828                                  char *base_data, int space_remaining,
 829                                  BOOL *out_of_space, BOOL *got_exact_match,
 830                                  int *last_name_off)
 831 {
 832         const char *dname;
 833         BOOL found = False;
 834         SMB_STRUCT_STAT sbuf;
 835         pstring mask;
 836         pstring pathreal;
 837         pstring fname;
 838         char *p, *q, *pdata = *ppdata;
 839         uint32 reskey=0;
 840         int prev_dirpos=0;
 841         int mode=0;
 842         SMB_OFF_T file_size = 0;
 843         SMB_BIG_UINT allocation_size = 0;
 844         uint32 len;
 845         time_t mdate=0, adate=0, cdate=0;
 846         char *nameptr;
 847         BOOL was_8_3;
 848         int nt_extmode; /* Used for NT connections instead of mode */
 849         BOOL needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
 850
 851         *fname = 0;
 852         *out_of_space = False;
 853         *got_exact_match = False;
 854
 855         if (!conn->dirptr)
 856                 return(False);
 857
 858         p = strrchr_m(path_mask,'/');
 859         if(p != NULL) {
 860                 if(p[1] == '\0')
 861                         pstrcpy(mask,"*.*");
 862                 else
 863                         pstrcpy(mask, p+1);
 864         } else
 865                 pstrcpy(mask, path_mask);
 866
 867         while (!found) {
 868                 BOOL got_match;
 869
 870                 /* Needed if we run out of space */
 871                 prev_dirpos = TellDir(conn->dirptr);
 872                 dname = ReadDirName(conn->dirptr);
 873
 874                 /*
 875                  * Due to bugs in NT client redirectors we are not using
 876                  * resume keys any more - set them to zero.
 877                  * Check out the related comments in findfirst/findnext.
 878                  * JRA.
 879                  */
 880
 881                 reskey = 0;
 882
 883                 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %d\n",
 884                         (long)conn->dirptr,TellDir(conn->dirptr)));
 885
 886                 if (!dname)
 887                         return(False);
 888
 889                 pstrcpy(fname,dname);
 890
 891                 if(!(got_match = *got_exact_match = exact_match(fname, mask, conn->case_sensitive)))
 892                         got_match = mask_match(fname, mask, conn->case_sensitive);
 893
 894                 if(!got_match && !mangle_is_8_3(fname, False)) {
 895
 896                         /*
 897                          * It turns out that NT matches wildcards against
 898                          * both long *and* short names. This may explain some
 899                          * of the wildcard wierdness from old DOS clients
 900                          * that some people have been seeing.... JRA.
 901                          */
 902
 903                         pstring newname;
 904                         pstrcpy( newname, fname);
 905                         mangle_map( newname, True, False, SNUM(conn));
 906                         if(!(got_match = *got_exact_match = exact_match(newname, mask, conn->case_sensitive)))
 907                                 got_match = mask_match(newname, mask, conn->case_sensitive);
 908                 }
 909
 910                 if(got_match) {
 911                         BOOL isdots = (strequal(fname,"..") || strequal(fname,"."));
 912                         if (dont_descend && !isdots)
 913                                 continue;
 914
 915                         pstrcpy(pathreal,conn->dirpath);
 916                         if(needslash)
 917                                 pstrcat(pathreal,"/");
 918                         pstrcat(pathreal,dname);
 919
 920                         if (INFO_LEVEL_IS_UNIX(info_level)) {
 921                                 if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
 922                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
 923                                                 pathreal,strerror(errno)));
 924                                         continue;
 925                                 }
 926                         } else if (SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
 927
 928                                 /* Needed to show the msdfs symlinks as
 929                                  * directories */
 930
 931                                 if(lp_host_msdfs() &&
 932                                    lp_msdfs_root(SNUM(conn)) &&
 933                                    is_msdfs_link(conn, pathreal, NULL, NULL,
 934                                                  &sbuf)) {
 935
 936                                         DEBUG(5,("get_lanman2_dir_entry: Masquerading msdfs link %s as a directory\n", pathreal));
 937                                         sbuf.st_mode = (sbuf.st_mode & 0xFFF) | S_IFDIR;
 938
 939                                 } else {
 940
 941                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
 942                                                 pathreal,strerror(errno)));
 943                                         continue;
 944                                 }
 945                         }
 946
 947                         mode = dos_mode(conn,pathreal,&sbuf);
 948
 949                         if (!dir_check_ftype(conn,mode,&sbuf,dirtype)) {
 950                                 DEBUG(5,("[%s] attribs didn't match %x\n",fname,dirtype));
 951                                 continue;
 952                         }
 953
 954                         file_size = get_file_size(sbuf);
 955                         allocation_size = get_allocation_size(NULL,&sbuf);
 956                         mdate = sbuf.st_mtime;
 957                         adate = sbuf.st_atime;
 958                         cdate = get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
 959
 960                         if (lp_dos_filetime_resolution(SNUM(conn))) {
 961                                 cdate &= ~1;
 962                                 mdate &= ~1;
 963                                 adate &= ~1;
 964                         }
 965
 966                         if(mode & aDIR) {
 967                                 /* This is necessary, as otherwise the
 968                                  * desktop.ini file in this folder is
 969                                  * ignored */
 970                                 mode |= (lp_profile_acls(SNUM(conn)) ? aRONLY : 0);
 971                                 file_size = 0;
 972                         }
 973
 974                         DEBUG(5,("get_lanman2_dir_entry found %s fname=%s\n",pathreal,fname));
 975
 976                         found = True;
 977                 }
 978         }
 979
 980         mangle_map(fname,False,True,SNUM(conn));
 981
 982         p = pdata;
 983         nameptr = p;
 984
 985         nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
 986
 987         switch (info_level) {
 988                 case SMB_INFO_STANDARD:
 989                         DEBUG(10,("get_lanman2_dir_entry: SMB_INFO_STANDARD\n"));
 990                         if(requires_resume_key) {
 991                                 SIVAL(p,0,reskey);
 992                                 p += 4;
 993                         }
 994                         put_dos_date2(p,l1_fdateCreation,cdate);
 995                         put_dos_date2(p,l1_fdateLastAccess,adate);
 996                         put_dos_date2(p,l1_fdateLastWrite,mdate);
 997                         SIVAL(p,l1_cbFile,(uint32)file_size);
 998                         SIVAL(p,l1_cbFileAlloc,(uint32)allocation_size);
 999                         SSVAL(p,l1_attrFile,mode);
1000                         p += l1_achName;
1001                         nameptr = p;
1002                         p += align_string(outbuf, p, 0);
1003                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1004                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1005                                 if (len > 2) {
1006                                         SCVAL(nameptr, -1, len - 2);
1007                                 } else {
1008                                         SCVAL(nameptr, -1, 0);
1009                                 }
1010                         } else {
1011                                 if (len > 1) {
1012                                         SCVAL(nameptr, -1, len - 1);
1013                                 } else {
1014                                         SCVAL(nameptr, -1, 0);
1015                                 }
1016                         }
1017                         p += len;
1018                         break;
1019
1020                 case SMB_INFO_QUERY_EA_SIZE:
1021                         DEBUG(10,("get_lanman2_dir_entry: SMB_INFO_QUERY_EA_SIZE\n"));
1022                         if(requires_resume_key) {
1023                                 SIVAL(p,0,reskey);
1024                                 p += 4;
1025                         }
1026                         put_dos_date2(p,l2_fdateCreation,cdate);
1027                         put_dos_date2(p,l2_fdateLastAccess,adate);
1028                         put_dos_date2(p,l2_fdateLastWrite,mdate);
1029                         SIVAL(p,l2_cbFile,(uint32)file_size);
1030                         SIVAL(p,l2_cbFileAlloc,(uint32)allocation_size);
1031                         SSVAL(p,l2_attrFile,mode);
1032                         {
1033                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1034                                 SIVAL(p,l2_cbList,ea_size); /* Extended attributes */
1035                         }
1036                         p += l2_achName;
1037                         nameptr = p - 1;
1038                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE | STR_NOALIGN);
1039                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1040                                 if (len > 2) {
1041                                         len -= 2;
1042                                 } else {
1043                                         len = 0;
1044                                 }
1045                         } else {
1046                                 if (len > 1) {
1047                                         len -= 1;
1048                                 } else {
1049                                         len = 0;
1050                                 }
1051                         }
1052                         SCVAL(nameptr,0,len);
1053                         p += len;
1054                         SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1055                         break;
1056
1057                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1058                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1059                         was_8_3 = mangle_is_8_3(fname, True);
1060                         p += 4;
1061                         SIVAL(p,0,reskey); p += 4;
1062                         put_long_date(p,cdate); p += 8;
1063                         put_long_date(p,adate); p += 8;
1064                         put_long_date(p,mdate); p += 8;
1065                         put_long_date(p,mdate); p += 8;
1066                         SOFF_T(p,0,file_size); p += 8;
1067                         SOFF_T(p,0,allocation_size); p += 8;
1068                         SIVAL(p,0,nt_extmode); p += 4;
1069                         q = p; p += 4; /* q is placeholder for name length. */
1070                         {
1071                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1072                                 SIVAL(p,0,ea_size); /* Extended attributes */
1073                                 p += 4;
1074                         }
1075                         /* Clear the short name buffer. This is
1076                          * IMPORTANT as not doing so will trigger
1077                          * a Win2k client bug. JRA.
1078                          */
1079                         memset(p,'\0',26);
1080                         if (!was_8_3 && lp_manglednames(SNUM(conn))) {
1081                                 pstring mangled_name;
1082                                 pstrcpy(mangled_name, fname);
1083                                 mangle_map(mangled_name,True,True,SNUM(conn));
1084                                 mangled_name[12] = 0;
1085                                 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1086                                 SSVAL(p, 0, len);
1087                         } else {
1088                                 SSVAL(p,0,0);
1089                                 *(p+2) = 0;
1090                         }
1091                         p += 2 + 24;
1092                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1093                         SIVAL(q,0,len);
1094                         p += len;
1095                         len = PTR_DIFF(p, pdata);
1096                         len = (len + 3) & ~3;
1097                         SIVAL(pdata,0,len);
1098                         p = pdata + len;
1099                         break;
1100
1101                 case SMB_FIND_FILE_DIRECTORY_INFO:
1102                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1103                         p += 4;
1104                         SIVAL(p,0,reskey); p += 4;
1105                         put_long_date(p,cdate); p += 8;
1106                         put_long_date(p,adate); p += 8;
1107                         put_long_date(p,mdate); p += 8;
1108                         put_long_date(p,mdate); p += 8;
1109                         SOFF_T(p,0,file_size); p += 8;
1110                         SOFF_T(p,0,allocation_size); p += 8;
1111                         SIVAL(p,0,nt_extmode); p += 4;
1112                         len = srvstr_push(outbuf, p + 4, fname, -1, STR_TERMINATE_ASCII);
1113                         SIVAL(p,0,len);
1114                         p += 4 + len;
1115                         len = PTR_DIFF(p, pdata);
1116                         len = (len + 3) & ~3;
1117                         SIVAL(pdata,0,len);
1118                         p = pdata + len;
1119                         break;
1120
1121                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1122                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1123                         p += 4;
1124                         SIVAL(p,0,reskey); p += 4;
1125                         put_long_date(p,cdate); p += 8;
1126                         put_long_date(p,adate); p += 8;
1127                         put_long_date(p,mdate); p += 8;
1128                         put_long_date(p,mdate); p += 8;
1129                         SOFF_T(p,0,file_size); p += 8;
1130                         SOFF_T(p,0,allocation_size); p += 8;
1131                         SIVAL(p,0,nt_extmode); p += 4;
1132                         q = p; p += 4; /* q is placeholder for name length. */
1133                         {
1134                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1135                                 SIVAL(p,0,ea_size); /* Extended attributes */
1136                                 p +=4;
1137                         }
1138                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1139                         SIVAL(q, 0, len);
1140                         p += len;
1141
1142                         len = PTR_DIFF(p, pdata);
1143                         len = (len + 3) & ~3;
1144                         SIVAL(pdata,0,len);
1145                         p = pdata + len;
1146                         break;
1147
1148                 case SMB_FIND_FILE_NAMES_INFO:
1149                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1150                         p += 4;
1151                         SIVAL(p,0,reskey); p += 4;
1152                         p += 4;
1153                         /* this must *not* be null terminated or w2k gets in a loop trying to set an
1154                            acl on a dir (tridge) */
1155                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1156                         SIVAL(p, -4, len);
1157                         p += len;
1158                         len = PTR_DIFF(p, pdata);
1159                         len = (len + 3) & ~3;
1160                         SIVAL(pdata,0,len);
1161                         p = pdata + len;
1162                         break;
1163
1164                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1165                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1166                         p += 4;
1167                         SIVAL(p,0,reskey); p += 4;
1168                         put_long_date(p,cdate); p += 8;
1169                         put_long_date(p,adate); p += 8;
1170                         put_long_date(p,mdate); p += 8;
1171                         put_long_date(p,mdate); p += 8;
1172                         SOFF_T(p,0,file_size); p += 8;
1173                         SOFF_T(p,0,allocation_size); p += 8;
1174                         SIVAL(p,0,nt_extmode); p += 4;
1175                         q = p; p += 4; /* q is placeholder for name length. */
1176                         {
1177                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1178                                 SIVAL(p,0,ea_size); /* Extended attributes */
1179                                 p +=4;
1180                         }
1181                         SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1182                         SIVAL(p,0,sbuf.st_dev); p += 4;
1183                         SIVAL(p,0,sbuf.st_ino); p += 4;
1184                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1185                         SIVAL(q, 0, len);
1186                         p += len;
1187                         len = PTR_DIFF(p, pdata);
1188                         len = (len + 3) & ~3;
1189                         SIVAL(pdata,0,len);
1190                         p = pdata + len;
1191                         break;
1192
1193                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1194                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1195                         was_8_3 = mangle_is_8_3(fname, True);
1196                         p += 4;
1197                         SIVAL(p,0,reskey); p += 4;
1198                         put_long_date(p,cdate); p += 8;
1199                         put_long_date(p,adate); p += 8;
1200                         put_long_date(p,mdate); p += 8;
1201                         put_long_date(p,mdate); p += 8;
1202                         SOFF_T(p,0,file_size); p += 8;
1203                         SOFF_T(p,0,allocation_size); p += 8;
1204                         SIVAL(p,0,nt_extmode); p += 4;
1205                         q = p; p += 4; /* q is placeholder for name length */
1206                         {
1207                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1208                                 SIVAL(p,0,ea_size); /* Extended attributes */
1209                                 p +=4;
1210                         }
1211                         /* Clear the short name buffer. This is
1212                          * IMPORTANT as not doing so will trigger
1213                          * a Win2k client bug. JRA.
1214                          */
1215                         memset(p,'\0',26);
1216                         if (!was_8_3 && lp_manglednames(SNUM(conn))) {
1217                                 pstring mangled_name;
1218                                 pstrcpy(mangled_name, fname);
1219                                 mangle_map(mangled_name,True,True,SNUM(conn));
1220                                 mangled_name[12] = 0;
1221                                 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1222                                 SSVAL(p, 0, len);
1223                         } else {
1224                                 SSVAL(p,0,0);
1225                                 *(p+2) = 0;
1226                         }
1227                         p += 26;
1228                         SSVAL(p,0,0); p += 2; /* Reserved ? */
1229                         SIVAL(p,0,sbuf.st_dev); p += 4;
1230                         SIVAL(p,0,sbuf.st_ino); p += 4;
1231                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1232                         SIVAL(q,0,len);
1233                         p += len;
1234                         len = PTR_DIFF(p, pdata);
1235                         len = (len + 3) & ~3;
1236                         SIVAL(pdata,0,len);
1237                         p = pdata + len;
1238                         break;
1239
1240                 /* CIFS UNIX Extension. */
1241
1242                 case SMB_FIND_FILE_UNIX:
1243                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX\n"));
1244                         p+= 4;
1245                         SIVAL(p,0,reskey); p+= 4;    /* Used for continuing search. */
1246
1247                         /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1248                         SOFF_T(p,0,get_file_size(sbuf));             /* File size 64 Bit */
1249                         p+= 8;
1250
1251                         SOFF_T(p,0,get_allocation_size(NULL,&sbuf)); /* Number of bytes used on disk - 64 Bit */
1252                         p+= 8;
1253
1254                         put_long_date(p,sbuf.st_ctime);       /* Inode change Time 64 Bit */
1255                         put_long_date(p+8,sbuf.st_atime);     /* Last access time 64 Bit */
1256                         put_long_date(p+16,sbuf.st_mtime);    /* Last modification time 64 Bit */
1257                         p+= 24;
1258
1259                         SIVAL(p,0,sbuf.st_uid);               /* user id for the owner */
1260                         SIVAL(p,4,0);
1261                         p+= 8;
1262
1263                         SIVAL(p,0,sbuf.st_gid);               /* group id of owner */
1264                         SIVAL(p,4,0);
1265                         p+= 8;
1266
1267                         SIVAL(p,0,unix_filetype(sbuf.st_mode));
1268                         p+= 4;
1269
1270                         SIVAL(p,0,unix_dev_major(sbuf.st_rdev));   /* Major device number if type is device */
1271                         SIVAL(p,4,0);
1272                         p+= 8;
1273
1274                         SIVAL(p,0,unix_dev_minor(sbuf.st_rdev));   /* Minor device number if type is device */
1275                         SIVAL(p,4,0);
1276                         p+= 8;
1277
1278                         SINO_T(p,0,(SMB_INO_T)sbuf.st_ino);   /* inode number */
1279                         p+= 8;
1280
1281                         SIVAL(p,0, unix_perms_to_wire(sbuf.st_mode));     /* Standard UNIX file permissions */
1282                         SIVAL(p,4,0);
1283                         p+= 8;
1284
1285                         SIVAL(p,0,sbuf.st_nlink);             /* number of hard links */
1286                         SIVAL(p,4,0);
1287                         p+= 8;
1288
1289                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1290                         p += len;
1291
1292                         len = PTR_DIFF(p, pdata);
1293                         len = (len + 3) & ~3;
1294                         SIVAL(pdata,0,len);     /* Offset from this structure to the beginning of the next one */
1295                         p = pdata + len;
1296                         /* End of SMB_QUERY_FILE_UNIX_BASIC */
1297
1298                         break;
1299
1300                 default:
1301                         return(False);
1302         }
1303
1304
1305         if (PTR_DIFF(p,pdata) > space_remaining) {
1306                 /* Move the dirptr back to prev_dirpos */
1307                 SeekDir(conn->dirptr, prev_dirpos);
1308                 *out_of_space = True;
1309                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1310                 return False; /* Not finished - just out of space */
1311         }
1312
1313         /* Setup the last_filename pointer, as an offset from base_data */
1314         *last_name_off = PTR_DIFF(nameptr,base_data);
1315         /* Advance the data pointer to the next slot */
1316         *ppdata = p;
1317
1318         return(found);
1319 }
1320
1321 /****************************************************************************
1322  Reply to a TRANS2_FINDFIRST.
1323 ****************************************************************************/
1324
1325 static int call_trans2findfirst(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
1326                                 char **pparams, int total_params, char **ppdata, int total_data,
1327                                 unsigned int max_data_bytes)
1328 {
1329         /* We must be careful here that we don't return more than the
1330                 allowed number of data bytes. If this means returning fewer than
1331                 maxentries then so be it. We assume that the redirector has
1332                 enough room for the fixed number of parameter bytes it has
1333                 requested. */
1334         char *params = *pparams;
1335         char *pdata = *ppdata;
1336         int dirtype = SVAL(params,0);
1337         int maxentries = SVAL(params,2);
1338         uint16 findfirst_flags = SVAL(params,4);
1339         BOOL close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
1340         BOOL close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1341         BOOL requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1342         int info_level = SVAL(params,6);
1343         pstring directory;
1344         pstring mask;
1345         char *p, *wcard;
1346         int last_name_off=0;
1347         int dptr_num = -1;
1348         int numentries = 0;
1349         int i;
1350         BOOL finished = False;
1351         BOOL dont_descend = False;
1352         BOOL out_of_space = False;
1353         int space_remaining;
1354         BOOL bad_path = False;
1355         SMB_STRUCT_STAT sbuf;
1356         NTSTATUS ntstatus = NT_STATUS_OK;
1357
1358         if (total_params < 12)
1359                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
1360
1361         *directory = *mask = 0;
1362
1363         DEBUG(3,("call_trans2findfirst: dirtype = %d, maxentries = %d, close_after_first=%d, \
1364 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
1365                 dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
1366                 info_level, max_data_bytes));
1367
1368         if (!maxentries) {
1369                 /* W2K3 seems to treat zero as 1. */
1370                 maxentries = 1;
1371         }
1372
1373         switch (info_level) {
1374                 case SMB_INFO_STANDARD:
1375                 case SMB_INFO_QUERY_EA_SIZE:
1376                 case SMB_FIND_FILE_DIRECTORY_INFO:
1377                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1378                 case SMB_FIND_FILE_NAMES_INFO:
1379                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1380                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1381                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1382                         break;
1383                 case SMB_FIND_FILE_UNIX:
1384                         if (!lp_unix_extensions())
1385                                 return(ERROR_DOS(ERRDOS,ERRunknownlevel));
1386                         break;
1387                 default:
1388                         return(ERROR_DOS(ERRDOS,ERRunknownlevel));
1389         }
1390
1391         srvstr_get_path(inbuf, directory, params+12, sizeof(directory), -1, STR_TERMINATE, &ntstatus, True);
1392         if (!NT_STATUS_IS_OK(ntstatus)) {
1393                 return ERROR_NT(ntstatus);
1394         }
1395
1396         RESOLVE_FINDFIRST_DFSPATH(directory, conn, inbuf, outbuf);
1397
1398         unix_convert(directory,conn,0,&bad_path,&sbuf);
1399         if (bad_path) {
1400                 return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
1401         }
1402         if(!check_name(directory,conn)) {
1403                 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadpath);
1404         }
1405
1406         p = strrchr_m(directory,'/');
1407         if(p == NULL) {
1408                 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
1409                 if((directory[0] == '.') && (directory[1] == '\0'))
1410                         pstrcpy(mask,"*");
1411                 else
1412                         pstrcpy(mask,directory);
1413                 pstrcpy(directory,"./");
1414         } else {
1415                 pstrcpy(mask,p+1);
1416                 *p = 0;
1417         }
1418
1419         DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
1420
1421         pdata = Realloc(*ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1422         if( pdata == NULL )
1423                 return(ERROR_DOS(ERRDOS,ERRnomem));
1424
1425         *ppdata = pdata;
1426         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1427
1428         /* Realloc the params space */
1429         params = Realloc(*pparams, 10);
1430         if (params == NULL)
1431                 return ERROR_DOS(ERRDOS,ERRnomem);
1432         *pparams = params;
1433
1434         dptr_num = dptr_create(conn,directory, False, True ,SVAL(inbuf,smb_pid));
1435         if (dptr_num < 0)
1436                 return(UNIXERROR(ERRDOS,ERRbadfile));
1437
1438         /* Save the wildcard match and attribs we are using on this directory -
1439                 needed as lanman2 assumes these are being saved between calls */
1440
1441         if(!(wcard = strdup(mask))) {
1442                 dptr_close(&dptr_num);
1443                 return ERROR_DOS(ERRDOS,ERRnomem);
1444         }
1445
1446         dptr_set_wcard(dptr_num, wcard);
1447         dptr_set_attr(dptr_num, dirtype);
1448
1449         DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n",dptr_num, wcard, dirtype));
1450
1451         /* We don't need to check for VOL here as this is returned by
1452                 a different TRANS2 call. */
1453
1454         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn->dirpath,lp_dontdescend(SNUM(conn))));
1455         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
1456                 dont_descend = True;
1457
1458         p = pdata;
1459         space_remaining = max_data_bytes;
1460         out_of_space = False;
1461
1462         for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
1463                 BOOL got_exact_match = False;
1464
1465                 /* this is a heuristic to avoid seeking the dirptr except when
1466                         absolutely necessary. It allows for a filename of about 40 chars */
1467                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
1468                         out_of_space = True;
1469                         finished = False;
1470                 } else {
1471                         finished = !get_lanman2_dir_entry(conn,
1472                                         inbuf, outbuf,
1473                                         mask,dirtype,info_level,
1474                                         requires_resume_key,dont_descend,
1475                                         &p,pdata,space_remaining, &out_of_space, &got_exact_match,
1476                                         &last_name_off);
1477                 }
1478
1479                 if (finished && out_of_space)
1480                         finished = False;
1481
1482                 if (!finished && !out_of_space)
1483                         numentries++;
1484
1485                 /*
1486                  * As an optimisation if we know we aren't looking
1487                  * for a wildcard name (ie. the name matches the wildcard exactly)
1488                  * then we can finish on any (first) match.
1489                  * This speeds up large directory searches. JRA.
1490                  */
1491
1492                 if(got_exact_match)
1493                         finished = True;
1494
1495                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1496         }
1497
1498         /* Check if we can close the dirptr */
1499         if(close_after_first || (finished && close_if_end)) {
1500                 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
1501                 dptr_close(&dptr_num);
1502         }
1503
1504         /*
1505          * If there are no matching entries we must return ERRDOS/ERRbadfile -
1506          * from observation of NT.
1507          */
1508
1509         if(numentries == 0) {
1510                 dptr_close(&dptr_num);
1511                 return ERROR_DOS(ERRDOS,ERRbadfile);
1512         }
1513
1514         /* At this point pdata points to numentries directory entries. */
1515
1516         /* Set up the return parameter block */
1517         SSVAL(params,0,dptr_num);
1518         SSVAL(params,2,numentries);
1519         SSVAL(params,4,finished);
1520         SSVAL(params,6,0); /* Never an EA error */
1521         SSVAL(params,8,last_name_off);
1522
1523         send_trans2_replies( outbuf, bufsize, params, 10, pdata, PTR_DIFF(p,pdata));
1524
1525         if ((! *directory) && dptr_path(dptr_num))
1526                 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1527
1528         DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1529                 smb_fn_name(CVAL(inbuf,smb_com)),
1530                 mask, directory, dirtype, numentries ) );
1531
1532         /*
1533          * Force a name mangle here to ensure that the
1534          * mask as an 8.3 name is top of the mangled cache.
1535          * The reasons for this are subtle. Don't remove
1536          * this code unless you know what you are doing
1537          * (see PR#13758). JRA.
1538          */
1539
1540         if(!mangle_is_8_3_wildcards( mask, False))
1541                 mangle_map(mask, True, True, SNUM(conn));
1542
1543         return(-1);
1544 }
1545
1546 /****************************************************************************
1547  Reply to a TRANS2_FINDNEXT.
1548 ****************************************************************************/
1549
1550 static int call_trans2findnext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
1551                                         char **pparams, int total_params, char **ppdata, int total_data,
1552                                         unsigned int max_data_bytes)
1553 {
1554         /* We must be careful here that we don't return more than the
1555                 allowed number of data bytes. If this means returning fewer than
1556                 maxentries then so be it. We assume that the redirector has
1557                 enough room for the fixed number of parameter bytes it has
1558                 requested. */
1559         char *params = *pparams;
1560         char *pdata = *ppdata;
1561         int dptr_num = SVAL(params,0);
1562         int maxentries = SVAL(params,2);
1563         uint16 info_level = SVAL(params,4);
1564         uint32 resume_key = IVAL(params,6);
1565         uint16 findnext_flags = SVAL(params,10);
1566         BOOL close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
1567         BOOL close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1568         BOOL requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1569         BOOL continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
1570         pstring resume_name;
1571         pstring mask;
1572         pstring directory;
1573         char *p;
1574         uint16 dirtype;
1575         int numentries = 0;
1576         int i, last_name_off=0;
1577         BOOL finished = False;
1578         BOOL dont_descend = False;
1579         BOOL out_of_space = False;
1580         int space_remaining;
1581         NTSTATUS ntstatus = NT_STATUS_OK;
1582
1583         if (total_params < 12)
1584                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
1585
1586         *mask = *directory = *resume_name = 0;
1587
1588         srvstr_get_path(inbuf, resume_name, params+12, sizeof(resume_name), -1, STR_TERMINATE, &ntstatus, True);
1589         if (!NT_STATUS_IS_OK(ntstatus)) {
1590                 return ERROR_NT(ntstatus);
1591         }
1592
1593         DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
1594 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
1595 resume_key = %d resume name = %s continue=%d level = %d\n",
1596                 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
1597                 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
1598
1599         if (!maxentries) {
1600                 /* W2K3 seems to treat zero as 1. */
1601                 maxentries = 1;
1602         }
1603
1604         switch (info_level) {
1605                 case SMB_INFO_STANDARD:
1606                 case SMB_INFO_QUERY_EA_SIZE:
1607                 case SMB_FIND_FILE_DIRECTORY_INFO:
1608                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1609                 case SMB_FIND_FILE_NAMES_INFO:
1610                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1611                         break;
1612                 case SMB_FIND_FILE_UNIX:
1613                         if (!lp_unix_extensions())
1614                                 return(ERROR_DOS(ERRDOS,ERRunknownlevel));
1615                         break;
1616                 default:
1617                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
1618         }
1619
1620         pdata = Realloc( *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1621         if(pdata == NULL)
1622                 return ERROR_DOS(ERRDOS,ERRnomem);
1623
1624         *ppdata = pdata;
1625         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1626
1627         /* Realloc the params space */
1628         params = Realloc(*pparams, 6*SIZEOFWORD);
1629         if( params == NULL )
1630                 return ERROR_DOS(ERRDOS,ERRnomem);
1631
1632         *pparams = params;
1633
1634         /* Check that the dptr is valid */
1635         if(!(conn->dirptr = dptr_fetch_lanman2(dptr_num)))
1636                 return ERROR_DOS(ERRDOS,ERRnofiles);
1637
1638         string_set(&conn->dirpath,dptr_path(dptr_num));
1639
1640         /* Get the wildcard mask from the dptr */
1641         if((p = dptr_wcard(dptr_num))== NULL) {
1642                 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
1643                 return ERROR_DOS(ERRDOS,ERRnofiles);
1644         }
1645
1646         pstrcpy(mask, p);
1647         pstrcpy(directory,conn->dirpath);
1648
1649         /* Get the attr mask from the dptr */
1650         dirtype = dptr_attr(dptr_num);
1651
1652         DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%d)\n",
1653                 dptr_num, mask, dirtype,
1654                 (long)conn->dirptr,
1655                 TellDir(conn->dirptr)));
1656
1657         /* We don't need to check for VOL here as this is returned by
1658                 a different TRANS2 call. */
1659
1660         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn->dirpath,lp_dontdescend(SNUM(conn))));
1661         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
1662                 dont_descend = True;
1663
1664         p = pdata;
1665         space_remaining = max_data_bytes;
1666         out_of_space = False;
1667
1668         /*
1669          * Seek to the correct position. We no longer use the resume key but
1670          * depend on the last file name instead.
1671          */
1672
1673         if(*resume_name && !continue_bit) {
1674
1675                 /*
1676                  * Fix for NT redirector problem triggered by resume key indexes
1677                  * changing between directory scans. We now return a resume key of 0
1678                  * and instead look for the filename to continue from (also given
1679                  * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
1680                  * findfirst/findnext (as is usual) then the directory pointer
1681                  * should already be at the correct place. Check this by scanning
1682                  * backwards looking for an exact (ie. case sensitive) filename match.
1683                  * If we get to the beginning of the directory and haven't found it then scan
1684                  * forwards again looking for a match. JRA.
1685                  */
1686
1687                 int current_pos, start_pos;
1688                 const char *dname = NULL;
1689                 pstring dname_pstring;
1690                 void *dirptr = conn->dirptr;
1691                 start_pos = TellDir(dirptr);
1692                 for(current_pos = start_pos; current_pos >= 0; current_pos--) {
1693                         DEBUG(7,("call_trans2findnext: seeking to pos %d\n", current_pos));
1694
1695                         SeekDir(dirptr, current_pos);
1696                         dname = ReadDirName(dirptr);
1697                         if (dname) {
1698                                 /*
1699                                  * Remember, mangle_map is called by
1700                                  * get_lanman2_dir_entry(), so the resume name
1701                                  * could be mangled. Ensure we do the same
1702                                  * here.
1703                                  */
1704
1705                                 /* make sure we get a copy that mangle_map can modify */
1706
1707                                 pstrcpy(dname_pstring, dname);
1708                                 mangle_map( dname_pstring, False, True, SNUM(conn));
1709
1710                                 if(strcsequal( resume_name, dname_pstring)) {
1711                                         SeekDir(dirptr, current_pos+1);
1712                                         DEBUG(7,("call_trans2findnext: got match at pos %d\n", current_pos+1 ));
1713                                         break;
1714                                 }
1715                         }
1716                 }
1717
1718                 /*
1719                  * Scan forward from start if not found going backwards.
1720                  */
1721
1722                 if(current_pos < 0) {
1723                         DEBUG(7,("call_trans2findnext: notfound: seeking to pos %d\n", start_pos));
1724                         SeekDir(dirptr, start_pos);
1725                         for(current_pos = start_pos; (dname = ReadDirName(dirptr)) != NULL; ++current_pos) {
1726
1727                                 /*
1728                                  * Remember, mangle_map is called by
1729                                  * get_lanman2_dir_entry(), so the resume name
1730                                  * could be mangled. Ensure we do the same
1731                                  * here.
1732                                  */
1733
1734                                 if(dname) {
1735                                         /* make sure we get a copy that mangle_map can modify */
1736
1737                                         pstrcpy(dname_pstring, dname);
1738                                         mangle_map(dname_pstring, False, True, SNUM(conn));
1739
1740                                         if(strcsequal( resume_name, dname_pstring)) {
1741                                                 SeekDir(dirptr, current_pos+1);
1742                                                 DEBUG(7,("call_trans2findnext: got match at pos %d\n", current_pos+1 ));
1743                                                 break;
1744                                         }
1745                                 }
1746                         } /* end for */
1747                 } /* end if current_pos */
1748                 /* Can't find the name. Just resume from where we were... */
1749                 if (dname == 0) {
1750                         SeekDir(dirptr, start_pos);
1751                 }
1752         } /* end if resume_name && !continue_bit */
1753
1754         for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
1755                 BOOL got_exact_match = False;
1756
1757                 /* this is a heuristic to avoid seeking the dirptr except when
1758                         absolutely necessary. It allows for a filename of about 40 chars */
1759                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
1760                         out_of_space = True;
1761                         finished = False;
1762                 } else {
1763                         finished = !get_lanman2_dir_entry(conn,
1764                                                 inbuf, outbuf,
1765                                                 mask,dirtype,info_level,
1766                                                 requires_resume_key,dont_descend,
1767                                                 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
1768                                                 &last_name_off);
1769                 }
1770
1771                 if (finished && out_of_space)
1772                         finished = False;
1773
1774                 if (!finished && !out_of_space)
1775                         numentries++;
1776
1777                 /*
1778                  * As an optimisation if we know we aren't looking
1779                  * for a wildcard name (ie. the name matches the wildcard exactly)
1780                  * then we can finish on any (first) match.
1781                  * This speeds up large directory searches. JRA.
1782                  */
1783
1784                 if(got_exact_match)
1785                         finished = True;
1786
1787                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1788         }
1789
1790         /* Check if we can close the dirptr */
1791         if(close_after_request || (finished && close_if_end)) {
1792                 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
1793                 dptr_close(&dptr_num); /* This frees up the saved mask */
1794         }
1795
1796         /* Set up the return parameter block */
1797         SSVAL(params,0,numentries);
1798         SSVAL(params,2,finished);
1799         SSVAL(params,4,0); /* Never an EA error */
1800         SSVAL(params,6,last_name_off);
1801
1802         send_trans2_replies( outbuf, bufsize, params, 8, pdata, PTR_DIFF(p,pdata));
1803
1804         if ((! *directory) && dptr_path(dptr_num))
1805                 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1806
1807         DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1808                 smb_fn_name(CVAL(inbuf,smb_com)),
1809                 mask, directory, dirtype, numentries ) );
1810
1811         return(-1);
1812 }
1813
1814 /****************************************************************************
1815  Reply to a TRANS2_QFSINFO (query filesystem info).
1816 ****************************************************************************/
1817
1818 static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
1819                                         char **pparams, int total_params, char **ppdata, int total_data,
1820                                         unsigned int max_data_bytes)
1821 {
1822         char *pdata = *ppdata;
1823         char *params = *pparams;
1824         uint16 info_level = SVAL(params,0);
1825         int data_len, len;
1826         SMB_STRUCT_STAT st;
1827         char *vname = volume_label(SNUM(conn));
1828         int snum = SNUM(conn);
1829         char *fstype = lp_fstype(SNUM(conn));
1830         int quota_flag = 0;
1831
1832         DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
1833
1834         if(SMB_VFS_STAT(conn,".",&st)!=0) {
1835                 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
1836                 return ERROR_DOS(ERRSRV,ERRinvdevice);
1837         }
1838
1839         pdata = Realloc(*ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1840         if ( pdata == NULL )
1841                 return ERROR_DOS(ERRDOS,ERRnomem);
1842
1843         *ppdata = pdata;
1844         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1845
1846         switch (info_level) {
1847                 case SMB_INFO_ALLOCATION:
1848                 {
1849                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
1850                         data_len = 18;
1851                         SMB_VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
1852                         block_size = lp_block_size(snum);
1853                         if (bsize < block_size) {
1854                                 SMB_BIG_UINT factor = block_size/bsize;
1855                                 bsize = block_size;
1856                                 dsize /= factor;
1857                                 dfree /= factor;
1858                         }
1859                         if (bsize > block_size) {
1860                                 SMB_BIG_UINT factor = bsize/block_size;
1861                                 bsize = block_size;
1862                                 dsize *= factor;
1863                                 dfree *= factor;
1864                         }
1865                         bytes_per_sector = 512;
1866                         sectors_per_unit = bsize/bytes_per_sector;
1867
1868                         DEBUG(5,("call_trans2qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
1869 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
1870                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
1871
1872                         SIVAL(pdata,l1_idFileSystem,st.st_dev);
1873                         SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
1874                         SIVAL(pdata,l1_cUnit,dsize);
1875                         SIVAL(pdata,l1_cUnitAvail,dfree);
1876                         SSVAL(pdata,l1_cbSector,bytes_per_sector);
1877                         break;
1878                 }
1879
1880                 case SMB_INFO_VOLUME:
1881                         /* Return volume name */
1882                         /*
1883                          * Add volume serial number - hash of a combination of
1884                          * the called hostname and the service name.
1885                          */
1886                         SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(local_machine)<<16) );
1887                         len = srvstr_push(outbuf, pdata+l2_vol_szVolLabel, vname, -1, STR_NOALIGN);
1888                         SCVAL(pdata,l2_vol_cch,len);
1889                         data_len = l2_vol_szVolLabel + len;
1890                         DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
1891                                 (unsigned)st.st_ctime, len, vname));
1892                         break;
1893
1894                 case SMB_QUERY_FS_ATTRIBUTE_INFO:
1895                 case SMB_FS_ATTRIBUTE_INFORMATION:
1896
1897
1898 #if defined(HAVE_SYS_QUOTAS)
1899                         quota_flag = FILE_VOLUME_QUOTAS;
1900 #endif
1901
1902                         SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
1903                                 (lp_nt_acl_support(SNUM(conn)) ? FILE_PERSISTENT_ACLS : 0)|
1904                                 quota_flag); /* FS ATTRIBUTES */
1905
1906                         SIVAL(pdata,4,255); /* Max filename component length */
1907                         /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
1908                                 and will think we can't do long filenames */
1909                         len = srvstr_push(outbuf, pdata+12, fstype, -1, STR_UNICODE);
1910                         SIVAL(pdata,8,len);
1911                         data_len = 12 + len;
1912                         break;
1913
1914                 case SMB_QUERY_FS_LABEL_INFO:
1915                 case SMB_FS_LABEL_INFORMATION:
1916                         len = srvstr_push(outbuf, pdata+4, vname, -1, 0);
1917                         data_len = 4 + len;
1918                         SIVAL(pdata,0,len);
1919                         break;
1920
1921                 case SMB_QUERY_FS_VOLUME_INFO:
1922                 case SMB_FS_VOLUME_INFORMATION:
1923
1924                         /*
1925                          * Add volume serial number - hash of a combination of
1926                          * the called hostname and the service name.
1927                          */
1928                         SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
1929                                 (str_checksum(local_machine)<<16));
1930
1931                         len = srvstr_push(outbuf, pdata+18, vname, -1, STR_UNICODE);
1932                         SIVAL(pdata,12,len);
1933                         data_len = 18+len;
1934                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
1935                                 (int)strlen(vname),vname, lp_servicename(snum)));
1936                         break;
1937
1938                 case SMB_QUERY_FS_SIZE_INFO:
1939                 case SMB_FS_SIZE_INFORMATION:
1940                 {
1941                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
1942                         data_len = 24;
1943                         SMB_VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
1944                         block_size = lp_block_size(snum);
1945                         if (bsize < block_size) {
1946                                 SMB_BIG_UINT factor = block_size/bsize;
1947                                 bsize = block_size;
1948                                 dsize /= factor;
1949                                 dfree /= factor;
1950                         }
1951                         if (bsize > block_size) {
1952                                 SMB_BIG_UINT factor = bsize/block_size;
1953                                 bsize = block_size;
1954                                 dsize *= factor;
1955                                 dfree *= factor;
1956                         }
1957                         bytes_per_sector = 512;
1958                         sectors_per_unit = bsize/bytes_per_sector;
1959                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
1960 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
1961                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
1962                         SBIG_UINT(pdata,0,dsize);
1963                         SBIG_UINT(pdata,8,dfree);
1964                         SIVAL(pdata,16,sectors_per_unit);
1965                         SIVAL(pdata,20,bytes_per_sector);
1966                         break;
1967                 }
1968
1969                 case SMB_FS_FULL_SIZE_INFORMATION:
1970                 {
1971                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
1972                         data_len = 32;
1973                         SMB_VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
1974                         block_size = lp_block_size(snum);
1975                         if (bsize < block_size) {
1976                                 SMB_BIG_UINT factor = block_size/bsize;
1977                                 bsize = block_size;
1978                                 dsize /= factor;
1979                                 dfree /= factor;
1980                         }
1981                         if (bsize > block_size) {
1982                                 SMB_BIG_UINT factor = bsize/block_size;
1983                                 bsize = block_size;
1984                                 dsize *= factor;
1985                                 dfree *= factor;
1986                         }
1987                         bytes_per_sector = 512;
1988                         sectors_per_unit = bsize/bytes_per_sector;
1989                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
1990 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
1991                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
1992                         SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
1993                         SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
1994                         SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
1995                         SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
1996                         SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
1997                         break;
1998                 }
1999
2000                 case SMB_QUERY_FS_DEVICE_INFO:
2001                 case SMB_FS_DEVICE_INFORMATION:
2002                         data_len = 8;
2003                         SIVAL(pdata,0,0); /* dev type */
2004                         SIVAL(pdata,4,0); /* characteristics */
2005                         break;
2006
2007 #ifdef HAVE_SYS_QUOTAS
2008                 case SMB_FS_QUOTA_INFORMATION:
2009                 /*
2010                  * what we have to send --metze:
2011                  *
2012                  * Unknown1:            24 NULL bytes
2013                  * Soft Quota Treshold: 8 bytes seems like SMB_BIG_UINT or so
2014                  * Hard Quota Limit:    8 bytes seems like SMB_BIG_UINT or so
2015                  * Quota Flags:         2 byte :
2016                  * Unknown3:            6 NULL bytes
2017                  *
2018                  * 48 bytes total
2019                  *
2020                  * details for Quota Flags:
2021                  *
2022                  * 0x0020 Log Limit: log if the user exceeds his Hard Quota
2023                  * 0x0010 Log Warn:  log if the user exceeds his Soft Quota
2024                  * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
2025                  * 0x0001 Enable Quotas: enable quota for this fs
2026                  *
2027                  */
2028                 {
2029                         /* we need to fake up a fsp here,
2030                          * because its not send in this call
2031                          */
2032                         files_struct fsp;
2033                         SMB_NTQUOTA_STRUCT quotas;
2034
2035                         ZERO_STRUCT(fsp);
2036                         ZERO_STRUCT(quotas);
2037
2038                         fsp.conn = conn;
2039                         fsp.fnum = -1;
2040                         fsp.fd = -1;
2041
2042                         /* access check */
2043                         if (current_user.uid != 0) {
2044                                 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2045                                         lp_servicename(SNUM(conn)),conn->user));
2046                                 return ERROR_DOS(ERRDOS,ERRnoaccess);
2047                         }
2048
2049                         if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2050                                 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2051                                 return ERROR_DOS(ERRSRV,ERRerror);
2052                         }
2053
2054                         data_len = 48;
2055
2056                         DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn))));
2057
2058                         /* Unknown1 24 NULL bytes*/
2059                         SBIG_UINT(pdata,0,(SMB_BIG_UINT)0);
2060                         SBIG_UINT(pdata,8,(SMB_BIG_UINT)0);
2061                         SBIG_UINT(pdata,16,(SMB_BIG_UINT)0);
2062
2063                         /* Default Soft Quota 8 bytes */
2064                         SBIG_UINT(pdata,24,quotas.softlim);
2065
2066                         /* Default Hard Quota 8 bytes */
2067                         SBIG_UINT(pdata,32,quotas.hardlim);
2068
2069                         /* Quota flag 2 bytes */
2070                         SSVAL(pdata,40,quotas.qflags);
2071
2072                         /* Unknown3 6 NULL bytes */
2073                         SSVAL(pdata,42,0);
2074                         SIVAL(pdata,44,0);
2075
2076                         break;
2077                 }
2078 #endif /* HAVE_SYS_QUOTAS */
2079                 case SMB_FS_OBJECTID_INFORMATION:
2080                         data_len = 64;
2081                         break;
2082
2083                 /*
2084                  * Query the version and capabilities of the CIFS UNIX extensions
2085                  * in use.
2086                  */
2087
2088                 case SMB_QUERY_CIFS_UNIX_INFO:
2089                         if (!lp_unix_extensions())
2090                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2091                         data_len = 12;
2092                         SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
2093                         SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
2094                         SBIG_UINT(pdata,4,((SMB_BIG_UINT)CIFS_UNIX_POSIX_ACLS_CAP)); /* We have POSIX ACLs. */
2095                         break;
2096
2097                 case SMB_MAC_QUERY_FS_INFO:
2098                         /*
2099                          * Thursby MAC extension... ONLY on NTFS filesystems
2100                          * once we do streams then we don't need this
2101                          */
2102                         if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
2103                                 data_len = 88;
2104                                 SIVAL(pdata,84,0x100); /* Don't support mac... */
2105                                 break;
2106                         }
2107                         /* drop through */
2108                 default:
2109                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
2110         }
2111
2112
2113         send_trans2_replies( outbuf, bufsize, params, 0, pdata, data_len);
2114
2115         DEBUG( 4, ( "%s info_level = %d\n", smb_fn_name(CVAL(inbuf,smb_com)), info_level) );
2116
2117         return -1;
2118 }
2119
2120 #ifdef HAVE_SYS_QUOTAS
2121 /****************************************************************************
2122  Reply to a TRANS2_SETFSINFO (set filesystem info).
2123 ****************************************************************************/
2124
2125 static int call_trans2setfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2126                                         char **pparams, int total_params, char **ppdata, int total_data,
2127                                         unsigned int max_data_bytes)
2128 {
2129         char *pdata = *ppdata;
2130         char *params = *pparams;
2131         files_struct *fsp = NULL;
2132         uint16 info_level;
2133         int outsize;
2134         SMB_NTQUOTA_STRUCT quotas;
2135
2136         ZERO_STRUCT(quotas);
2137
2138         DEBUG(10,("call_trans2setfsinfo: SET_FS_QUOTA: for service [%s]\n",lp_servicename(SNUM(conn))));
2139
2140         /* access check */
2141         if ((current_user.uid != 0)||!CAN_WRITE(conn)) {
2142                 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2143                         lp_servicename(SNUM(conn)),conn->user));
2144                 return ERROR_DOS(ERRSRV,ERRaccess);
2145         }
2146
2147         /*  */
2148         if (total_params < 4) {
2149                 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
2150                         total_params));
2151                 return ERROR_DOS(ERRDOS,ERRinvalidparam);
2152         }
2153
2154         fsp = file_fsp(params,0);
2155
2156         if (!CHECK_NTQUOTA_HANDLE_OK(fsp,conn)) {
2157                 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
2158                 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
2159         }
2160
2161         info_level = SVAL(params,2);
2162
2163         switch(info_level) {
2164                 case SMB_FS_QUOTA_INFORMATION:
2165                         /* note: normaly there're 48 bytes,
2166                          * but we didn't use the last 6 bytes for now
2167                          * --metze
2168                          */
2169                         if (total_data < 42) {
2170                                 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
2171                                         total_data));
2172                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2173                         }
2174
2175                         /* unknown_1 24 NULL bytes in pdata*/
2176
2177                         /* the soft quotas 8 bytes (SMB_BIG_UINT)*/
2178                         quotas.softlim = (SMB_BIG_UINT)IVAL(pdata,24);
2179 #ifdef LARGE_SMB_OFF_T
2180                         quotas.softlim |= (((SMB_BIG_UINT)IVAL(pdata,28)) << 32);
2181 #else /* LARGE_SMB_OFF_T */
2182                         if ((IVAL(pdata,28) != 0)&&
2183                                 ((quotas.softlim != 0xFFFFFFFF)||
2184                                 (IVAL(pdata,28)!=0xFFFFFFFF))) {
2185                                 /* more than 32 bits? */
2186                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2187                         }
2188 #endif /* LARGE_SMB_OFF_T */
2189
2190                         /* the hard quotas 8 bytes (SMB_BIG_UINT)*/
2191                         quotas.hardlim = (SMB_BIG_UINT)IVAL(pdata,32);
2192 #ifdef LARGE_SMB_OFF_T
2193                         quotas.hardlim |= (((SMB_BIG_UINT)IVAL(pdata,36)) << 32);
2194 #else /* LARGE_SMB_OFF_T */
2195                         if ((IVAL(pdata,36) != 0)&&
2196                                 ((quotas.hardlim != 0xFFFFFFFF)||
2197                                 (IVAL(pdata,36)!=0xFFFFFFFF))) {
2198                                 /* more than 32 bits? */
2199                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2200                         }
2201 #endif /* LARGE_SMB_OFF_T */
2202
2203                         /* quota_flags 2 bytes **/
2204                         quotas.qflags = SVAL(pdata,40);
2205
2206                         /* unknown_2 6 NULL bytes follow*/
2207
2208                         /* now set the quotas */
2209                         if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2210                                 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2211                                 return ERROR_DOS(ERRSRV,ERRerror);
2212                         }
2213
2214                         break;
2215                 default:
2216                         DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
2217                                 info_level));
2218                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
2219                         break;
2220         }
2221
2222         /*
2223          * sending this reply works fine,
2224          * but I'm not sure it's the same
2225          * like windows do...
2226          * --metze
2227          */
2228         outsize = set_message(outbuf,10,0,True);
2229
2230         return outsize;
2231 }
2232 #endif /* HAVE_SYS_QUOTAS */
2233
2234 /****************************************************************************
2235  Utility function to set bad path error.
2236 ****************************************************************************/
2237
2238 int set_bad_path_error(int err, BOOL bad_path, char *outbuf, int def_class, uint32 def_code)
2239 {
2240         DEBUG(10,("set_bad_path_error: err = %d bad_path = %d\n",
2241                         err, (int)bad_path ));
2242
2243         if(err == ENOENT) {
2244                 if (bad_path) {
2245                         return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
2246                 } else {
2247                         return ERROR_NT(NT_STATUS_OBJECT_NAME_NOT_FOUND);
2248                 }
2249         }
2250         return UNIXERROR(def_class,def_code);
2251 }
2252
2253 /****************************************************************************
2254  Utility function to count the number of entries in a POSIX acl.
2255 ****************************************************************************/
2256
2257 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
2258 {
2259         unsigned int ace_count = 0;
2260         int entry_id = SMB_ACL_FIRST_ENTRY;
2261         SMB_ACL_ENTRY_T entry;
2262
2263         while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2264                 /* get_next... */
2265                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2266                         entry_id = SMB_ACL_NEXT_ENTRY;
2267                 }
2268                 ace_count++;
2269         }
2270         return ace_count;
2271 }
2272
2273 /****************************************************************************
2274  Utility function to marshall a POSIX acl into wire format.
2275 ****************************************************************************/
2276
2277 static BOOL marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
2278 {
2279         int entry_id = SMB_ACL_FIRST_ENTRY;
2280         SMB_ACL_ENTRY_T entry;
2281
2282         while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2283                 SMB_ACL_TAG_T tagtype;
2284                 SMB_ACL_PERMSET_T permset;
2285                 unsigned char perms = 0;
2286                 unsigned int own_grp;
2287
2288                 /* get_next... */
2289                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2290                         entry_id = SMB_ACL_NEXT_ENTRY;
2291                 }
2292
2293                 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
2294                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
2295                         return False;
2296                 }
2297
2298                 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
2299                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
2300                         return False;
2301                 }
2302
2303                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
2304                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
2305                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
2306
2307                 SCVAL(pdata,1,perms);
2308
2309                 switch (tagtype) {
2310                         case SMB_ACL_USER_OBJ:
2311                                 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
2312                                 own_grp = (unsigned int)pst->st_uid;
2313                                 SIVAL(pdata,2,own_grp);
2314                                 SIVAL(pdata,6,0);
2315                                 break;
2316                         case SMB_ACL_USER:
2317                                 {
2318                                         uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
2319                                         if (!puid) {
2320                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
2321                                         }
2322                                         own_grp = (unsigned int)*puid;
2323                                         SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
2324                                         SCVAL(pdata,0,SMB_POSIX_ACL_USER);
2325                                         SIVAL(pdata,2,own_grp);
2326                                         SIVAL(pdata,6,0);
2327                                         break;
2328                                 }
2329                         case SMB_ACL_GROUP_OBJ:
2330                                 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
2331                                 own_grp = (unsigned int)pst->st_gid;
2332                                 SIVAL(pdata,2,own_grp);
2333                                 SIVAL(pdata,6,0);
2334                                 break;
2335                         case SMB_ACL_GROUP:
2336                                 {
2337                                         gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
2338                                         if (!pgid) {
2339                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
2340                                         }
2341                                         own_grp = (unsigned int)*pgid;
2342                                         SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
2343                                         SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
2344                                         SIVAL(pdata,2,own_grp);
2345                                         SIVAL(pdata,6,0);
2346                                         break;
2347                                 }
2348                         case SMB_ACL_MASK:
2349                                 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
2350                                 SIVAL(pdata,2,0xFFFFFFFF);
2351                                 SIVAL(pdata,6,0xFFFFFFFF);
2352                                 break;
2353                         case SMB_ACL_OTHER:
2354                                 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
2355                                 SIVAL(pdata,2,0xFFFFFFFF);
2356                                 SIVAL(pdata,6,0xFFFFFFFF);
2357                                 break;
2358                         default:
2359                                 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
2360                                 return False;
2361                 }
2362                 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
2363         }
2364
2365         return True;
2366 }
2367
2368 /****************************************************************************
2369  Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
2370  file name or file id).
2371 ****************************************************************************/
2372
2373 static int call_trans2qfilepathinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2374                                         char **pparams, int total_params, char **ppdata, int total_data,
2375                                         unsigned int max_data_bytes)
2376 {
2377         char *params = *pparams;
2378         char *pdata = *ppdata;
2379         uint16 tran_call = SVAL(inbuf, smb_setup0);
2380         uint16 info_level;
2381         int mode=0;
2382         SMB_OFF_T file_size=0;
2383         SMB_BIG_UINT allocation_size=0;
2384         unsigned int data_size;
2385         unsigned int param_size = 2;
2386         SMB_STRUCT_STAT sbuf;
2387         pstring fname, dos_fname;
2388         char *fullpathname;
2389         char *base_name;
2390         char *p;
2391         SMB_OFF_T pos = 0;
2392         BOOL bad_path = False;
2393         BOOL delete_pending = False;
2394         int len;
2395         time_t c_time;
2396         files_struct *fsp = NULL;
2397         uint32 desired_access = 0x12019F; /* Default - GENERIC_EXECUTE mapping from Windows */
2398
2399         if (!params)
2400                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2401
2402         ZERO_STRUCT(sbuf);
2403
2404         if (tran_call == TRANSACT2_QFILEINFO) {
2405                 if (total_params < 4)
2406                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2407
2408                 fsp = file_fsp(params,0);
2409                 info_level = SVAL(params,2);
2410
2411                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
2412
2413                 if(fsp && (fsp->fake_file_handle)) {
2414                         /*
2415                          * This is actually for the QUOTA_FAKE_FILE --metze
2416                          */
2417
2418                         pstrcpy(fname, fsp->fsp_name);
2419                         /* We know this name is ok, it's already passed the checks. */
2420
2421                 } else if(fsp && (fsp->is_directory || fsp->fd == -1)) {
2422                         /*
2423                          * This is actually a QFILEINFO on a directory
2424                          * handle (returned from an NT SMB). NT5.0 seems
2425                          * to do this call. JRA.
2426                          */
2427                         /* We know this name is ok, it's already passed the checks. */
2428                         pstrcpy(fname, fsp->fsp_name);
2429
2430                         if (INFO_LEVEL_IS_UNIX(info_level)) {
2431                                 /* Always do lstat for UNIX calls. */
2432                                 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
2433                                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
2434                                         return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadpath);
2435                                 }
2436                         } else if (SMB_VFS_STAT(conn,fname,&sbuf)) {
2437                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
2438                                 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadpath);
2439                         }
2440
2441                         delete_pending = fsp->is_directory ? fsp->directory_delete_on_close : 0;
2442                 } else {
2443                         /*
2444                          * Original code - this is an open file.
2445                          */
2446                         CHECK_FSP(fsp,conn);
2447
2448                         pstrcpy(fname, fsp->fsp_name);
2449                         if (SMB_VFS_FSTAT(fsp,fsp->fd,&sbuf) != 0) {
2450                                 DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
2451                                 return(UNIXERROR(ERRDOS,ERRbadfid));
2452                         }
2453                         pos = fsp->position_information;
2454                         delete_pending = fsp->delete_on_close;
2455                         desired_access = fsp->desired_access;
2456                 }
2457         } else {
2458                 NTSTATUS status = NT_STATUS_OK;
2459
2460                 /* qpathinfo */
2461                 if (total_params < 6)
2462                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
2463
2464                 info_level = SVAL(params,0);
2465
2466                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
2467
2468                 srvstr_get_path(inbuf, fname, &params[6], sizeof(fname), -1, STR_TERMINATE, &status, False);
2469                 if (!NT_STATUS_IS_OK(status)) {
2470                         return ERROR_NT(status);
2471                 }
2472
2473                 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
2474
2475                 unix_convert(fname,conn,0,&bad_path,&sbuf);
2476                 if (bad_path) {
2477                         return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
2478                 }
2479                 if (!check_name(fname,conn)) {
2480                         DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
2481                         return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadpath);
2482                 }
2483
2484                 if (INFO_LEVEL_IS_UNIX(info_level)) {
2485                         /* Always do lstat for UNIX calls. */
2486                         if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
2487                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
2488                                 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadpath);
2489                         }
2490                 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf) && (info_level != SMB_INFO_IS_NAME_VALID)) {
2491                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
2492                         return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadpath);
2493                 }
2494         }
2495
2496         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions())
2497                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
2498
2499         DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d total_data=%d\n",
2500                 fname,fsp ? fsp->fnum : -1, info_level,tran_call,total_data));
2501
2502         p = strrchr_m(fname,'/');
2503         if (!p)
2504                 base_name = fname;
2505         else
2506                 base_name = p+1;
2507
2508         mode = dos_mode(conn,fname,&sbuf);
2509         if (!mode)
2510                 mode = FILE_ATTRIBUTE_NORMAL;
2511
2512         fullpathname = fname;
2513         file_size = get_file_size(sbuf);
2514         allocation_size = get_allocation_size(fsp,&sbuf);
2515         if (mode & aDIR) {
2516                 /* This is necessary, as otherwise the desktop.ini file in
2517                  * this folder is ignored */
2518                 mode |= (lp_profile_acls(SNUM(conn)) ? aRONLY : 0);
2519                 file_size = 0;
2520         }
2521
2522         params = Realloc(*pparams,2);
2523         if (params == NULL)
2524           return ERROR_DOS(ERRDOS,ERRnomem);
2525         *pparams = params;
2526         memset((char *)params,'\0',2);
2527         data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
2528         pdata = Realloc(*ppdata, data_size);
2529         if ( pdata == NULL )
2530                 return ERROR_DOS(ERRDOS,ERRnomem);
2531         *ppdata = pdata;
2532
2533         if (total_data > 0 && IVAL(pdata,0) == total_data) {
2534                 /* uggh, EAs for OS2 */
2535                 DEBUG(4,("Rejecting EA request with total_data=%d\n",total_data));
2536                 return ERROR_DOS(ERRDOS,ERReasnotsupported);
2537         }
2538
2539         memset((char *)pdata,'\0',data_size);
2540
2541         c_time = get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
2542
2543         if (fsp && fsp->pending_modtime) {
2544                 /* the pending modtime overrides the current modtime */
2545                 sbuf.st_mtime = fsp->pending_modtime;
2546         }
2547
2548         if (lp_dos_filetime_resolution(SNUM(conn))) {
2549                 c_time &= ~1;
2550                 sbuf.st_atime &= ~1;
2551                 sbuf.st_ctime &= ~1;
2552                 sbuf.st_mtime &= ~1;
2553         }
2554
2555         /* NT expects the name to be in an exact form of the *full*
2556            filename. See the trans2 torture test */
2557         if (strequal(base_name,".")) {
2558                 pstrcpy(dos_fname, "\\");
2559         } else {
2560                 pstr_sprintf(dos_fname, "\\%s", fname);
2561                 string_replace(dos_fname, '/', '\\');
2562         }
2563
2564         switch (info_level) {
2565                 case SMB_INFO_STANDARD:
2566                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_STANDARD\n"));
2567                         data_size = 22;
2568                         put_dos_date2(pdata,l1_fdateCreation,c_time);
2569                         put_dos_date2(pdata,l1_fdateLastAccess,sbuf.st_atime);
2570                         put_dos_date2(pdata,l1_fdateLastWrite,sbuf.st_mtime); /* write time */
2571                         SIVAL(pdata,l1_cbFile,(uint32)file_size);
2572                         SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
2573                         SSVAL(pdata,l1_attrFile,mode);
2574                         break;
2575
2576                 case SMB_INFO_QUERY_EA_SIZE:
2577                 {
2578                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
2579                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
2580                         data_size = 26;
2581                         put_dos_date2(pdata,l1_fdateCreation,c_time);
2582                         put_dos_date2(pdata,l1_fdateLastAccess,sbuf.st_atime);
2583                         put_dos_date2(pdata,l1_fdateLastWrite,sbuf.st_mtime); /* write time */
2584                         SIVAL(pdata,l1_cbFile,(uint32)file_size);
2585                         SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
2586                         SSVAL(pdata,l1_attrFile,mode);
2587                         SIVAL(pdata,l1_attrFile+2,ea_size);
2588                         break;
2589                 }
2590
2591                 case SMB_INFO_IS_NAME_VALID:
2592                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
2593                         if (tran_call == TRANSACT2_QFILEINFO) {
2594                                 /* os/2 needs this ? really ?*/
2595                                 return ERROR_DOS(ERRDOS,ERRbadfunc);
2596                         }
2597                         data_size = 0;
2598                         param_size = 0;
2599                         break;
2600
2601                 case SMB_INFO_QUERY_EAS_FROM_LIST:
2602                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
2603                         data_size = 24;
2604                         put_dos_date2(pdata,0,c_time);
2605                         put_dos_date2(pdata,4,sbuf.st_atime);
2606                         put_dos_date2(pdata,8,sbuf.st_mtime);
2607                         SIVAL(pdata,12,(uint32)file_size);
2608                         SIVAL(pdata,16,(uint32)allocation_size);
2609                         SIVAL(pdata,20,mode);
2610                         break;
2611
2612                 case SMB_INFO_QUERY_ALL_EAS:
2613                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
2614                         /* We have data_size bytes to put EA's into. */
2615                         data_size = fill_ea_buffer(pdata, data_size, conn, fsp, fname);
2616                         break;
2617
2618                 case SMB_FILE_BASIC_INFORMATION:
2619                 case SMB_QUERY_FILE_BASIC_INFO:
2620
2621                         if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
2622                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
2623                                 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
2624                         } else {
2625                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
2626                                 data_size = 40;
2627                                 SIVAL(pdata,36,0);
2628                         }
2629                         put_long_date(pdata,c_time);
2630                         put_long_date(pdata+8,sbuf.st_atime);
2631                         put_long_date(pdata+16,sbuf.st_mtime); /* write time */
2632                         put_long_date(pdata+24,sbuf.st_mtime); /* change time */
2633                         SIVAL(pdata,32,mode);
2634
2635                         DEBUG(5,("SMB_QFBI - "));
2636                         {
2637                                 time_t create_time = c_time;
2638                                 DEBUG(5,("create: %s ", ctime(&create_time)));
2639                         }
2640                         DEBUG(5,("access: %s ", ctime(&sbuf.st_atime)));
2641                         DEBUG(5,("write: %s ", ctime(&sbuf.st_mtime)));
2642                         DEBUG(5,("change: %s ", ctime(&sbuf.st_mtime)));
2643                         DEBUG(5,("mode: %x\n", mode));
2644
2645                         break;
2646
2647                 case SMB_FILE_STANDARD_INFORMATION:
2648                 case SMB_QUERY_FILE_STANDARD_INFO:
2649
2650                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
2651                         data_size = 24;
2652                         SOFF_T(pdata,0,allocation_size);
2653                         SOFF_T(pdata,8,file_size);
2654                         if (delete_pending & sbuf.st_nlink)
2655                                 SIVAL(pdata,16,sbuf.st_nlink - 1);
2656                         else
2657                                 SIVAL(pdata,16,sbuf.st_nlink);
2658                         SCVAL(pdata,20,0);
2659                         SCVAL(pdata,21,(mode&aDIR)?1:0);
2660                         break;
2661
2662                 case SMB_FILE_EA_INFORMATION:
2663                 case SMB_QUERY_FILE_EA_INFO:
2664                 {
2665                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
2666                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
2667                         data_size = 4;
2668                         SIVAL(pdata,0,ea_size);
2669                         break;
2670                 }
2671
2672                 /* Get the 8.3 name - used if NT SMB was negotiated. */
2673                 case SMB_QUERY_FILE_ALT_NAME_INFO:
2674                 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
2675                 {
2676                         pstring short_name;
2677
2678                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
2679                         pstrcpy(short_name,base_name);
2680                         /* Mangle if not already 8.3 */
2681                         if(!mangle_is_8_3(short_name, True)) {
2682                                 mangle_map(short_name,True,True,SNUM(conn));
2683                         }
2684                         len = srvstr_push(outbuf, pdata+4, short_name, -1, STR_UNICODE);
2685                         data_size = 4 + len;
2686                         SIVAL(pdata,0,len);
2687                         break;
2688                 }
2689
2690                 case SMB_QUERY_FILE_NAME_INFO:
2691                         /*
2692                           this must be *exactly* right for ACLs on mapped drives to work
2693                          */
2694                         len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
2695                         DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
2696                         data_size = 4 + len;
2697                         SIVAL(pdata,0,len);
2698                         break;
2699
2700                 case SMB_FILE_ALLOCATION_INFORMATION:
2701                 case SMB_QUERY_FILE_ALLOCATION_INFO:
2702                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
2703                         data_size = 8;
2704                         SOFF_T(pdata,0,allocation_size);
2705                         break;
2706
2707                 case SMB_FILE_END_OF_FILE_INFORMATION:
2708                 case SMB_QUERY_FILE_END_OF_FILEINFO:
2709                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
2710                         data_size = 8;
2711                         SOFF_T(pdata,0,file_size);
2712                         break;
2713
2714                 case SMB_QUERY_FILE_ALL_INFO:
2715                 case SMB_FILE_ALL_INFORMATION:
2716                 {
2717                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
2718                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
2719                         put_long_date(pdata,c_time);
2720                         put_long_date(pdata+8,sbuf.st_atime);
2721                         put_long_date(pdata+16,sbuf.st_mtime); /* write time */
2722                         put_long_date(pdata+24,sbuf.st_mtime); /* change time */
2723                         SIVAL(pdata,32,mode);
2724                         pdata += 40;
2725                         SOFF_T(pdata,0,allocation_size);
2726                         SOFF_T(pdata,8,file_size);
2727                         if (delete_pending && sbuf.st_nlink)
2728                                 SIVAL(pdata,16,sbuf.st_nlink - 1);
2729                         else
2730                                 SIVAL(pdata,16,sbuf.st_nlink);
2731                         SCVAL(pdata,20,delete_pending);
2732                         SCVAL(pdata,21,(mode&aDIR)?1:0);
2733                         pdata += 24;
2734                         SIVAL(pdata,0,ea_size);
2735                         pdata += 4; /* EA info */
2736                         len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
2737                         SIVAL(pdata,0,len);
2738                         pdata += 4 + len;
2739                         data_size = PTR_DIFF(pdata,(*ppdata));
2740                         break;
2741                 }
2742                 case SMB_FILE_INTERNAL_INFORMATION:
2743                         /* This should be an index number - looks like
2744                            dev/ino to me :-)
2745
2746                            I think this causes us to fail the IFSKIT
2747                            BasicFileInformationTest. -tpot */
2748
2749                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
2750                         SIVAL(pdata,0,sbuf.st_dev);
2751                         SIVAL(pdata,4,sbuf.st_ino);
2752                         data_size = 8;
2753                         break;
2754
2755                 case SMB_FILE_ACCESS_INFORMATION:
2756                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
2757                         SIVAL(pdata,0,desired_access);
2758                         data_size = 4;
2759                         break;
2760
2761                 case SMB_FILE_NAME_INFORMATION:
2762                         /* Pathname with leading '\'. */
2763                         {
2764                                 size_t byte_len;
2765                                 byte_len = dos_PutUniCode(pdata+4,dos_fname,max_data_bytes,False);
2766                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
2767                                 SIVAL(pdata,0,byte_len);
2768                                 data_size = 4 + byte_len;
2769                                 break;
2770                         }
2771
2772                 case SMB_FILE_DISPOSITION_INFORMATION:
2773                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
2774                         data_size = 1;
2775                         SCVAL(pdata,0,delete_pending);
2776                         break;
2777
2778                 case SMB_FILE_POSITION_INFORMATION:
2779                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
2780                         data_size = 8;
2781                         SOFF_T(pdata,0,pos);
2782                         break;
2783
2784                 case SMB_FILE_MODE_INFORMATION:
2785                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
2786                         SIVAL(pdata,0,mode);
2787                         data_size = 4;
2788                         break;
2789
2790                 case SMB_FILE_ALIGNMENT_INFORMATION:
2791                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
2792                         SIVAL(pdata,0,0); /* No alignment needed. */
2793                         data_size = 4;
2794                         break;
2795
2796 #if 0
2797                 /*
2798                  * NT4 server just returns "invalid query" to this - if we try to answer
2799                  * it then NTws gets a BSOD! (tridge).
2800                  * W2K seems to want this. JRA.
2801                  */
2802                 case SMB_QUERY_FILE_STREAM_INFO:
2803 #endif
2804                 case SMB_FILE_STREAM_INFORMATION:
2805                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STREAM_INFORMATION\n"));
2806                         if (mode & aDIR) {
2807                                 data_size = 0;
2808                         } else {
2809                                 size_t byte_len = dos_PutUniCode(pdata+24,"::$DATA", 0xE, False);
2810                                 SIVAL(pdata,0,0); /* ??? */
2811                                 SIVAL(pdata,4,byte_len); /* Byte length of unicode string ::$DATA */
2812                                 SOFF_T(pdata,8,file_size);
2813                                 SIVAL(pdata,16,allocation_size);
2814                                 SIVAL(pdata,20,0); /* ??? */
2815                                 data_size = 24 + byte_len;
2816                         }
2817                         break;
2818
2819                 case SMB_QUERY_COMPRESSION_INFO:
2820                 case SMB_FILE_COMPRESSION_INFORMATION:
2821                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
2822                         SOFF_T(pdata,0,file_size);
2823                         SIVAL(pdata,8,0); /* ??? */
2824                         SIVAL(pdata,12,0); /* ??? */
2825                         data_size = 16;
2826                         break;
2827
2828                 case SMB_FILE_NETWORK_OPEN_INFORMATION:
2829                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
2830                         put_long_date(pdata,c_time);
2831                         put_long_date(pdata+8,sbuf.st_atime);
2832                         put_long_date(pdata+16,sbuf.st_mtime); /* write time */
2833                         put_long_date(pdata+24,sbuf.st_mtime); /* change time */
2834                         SIVAL(pdata,32,allocation_size);
2835                         SOFF_T(pdata,40,file_size);
2836                         SIVAL(pdata,48,mode);
2837                         SIVAL(pdata,52,0); /* ??? */
2838                         data_size = 56;
2839                         break;
2840
2841                 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
2842                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
2843                         SIVAL(pdata,0,mode);
2844                         SIVAL(pdata,4,0);
2845                         data_size = 8;
2846                         break;
2847
2848                 /*
2849                  * CIFS UNIX Extensions.
2850                  */
2851
2852                 case SMB_QUERY_FILE_UNIX_BASIC:
2853
2854                         DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC\n"));
2855                         DEBUG(4,("call_trans2qfilepathinfo: st_mode=%o\n",(int)sbuf.st_mode));
2856
2857                         SOFF_T(pdata,0,get_file_size(sbuf));             /* File size 64 Bit */
2858                         pdata += 8;
2859
2860                         SOFF_T(pdata,0,get_allocation_size(fsp,&sbuf)); /* Number of bytes used on disk - 64 Bit */
2861                         pdata += 8;
2862
2863                         put_long_date(pdata,sbuf.st_ctime);       /* Creation Time 64 Bit */
2864                         put_long_date(pdata+8,sbuf.st_atime);     /* Last access time 64 Bit */
2865                         put_long_date(pdata+16,sbuf.st_mtime);    /* Last modification time 64 Bit */
2866                         pdata += 24;
2867
2868                         SIVAL(pdata,0,sbuf.st_uid);               /* user id for the owner */
2869                         SIVAL(pdata,4,0);
2870                         pdata += 8;
2871
2872                         SIVAL(pdata,0,sbuf.st_gid);               /* group id of owner */
2873                         SIVAL(pdata,4,0);
2874                         pdata += 8;
2875
2876                         SIVAL(pdata,0,unix_filetype(sbuf.st_mode));
2877                         pdata += 4;
2878
2879                         SIVAL(pdata,0,unix_dev_major(sbuf.st_rdev));   /* Major device number if type is device */
2880                         SIVAL(pdata,4,0);
2881                         pdata += 8;
2882
2883                         SIVAL(pdata,0,unix_dev_minor(sbuf.st_rdev));   /* Minor device number if type is device */
2884                         SIVAL(pdata,4,0);
2885                         pdata += 8;
2886
2887                         SINO_T(pdata,0,(SMB_INO_T)sbuf.st_ino);   /* inode number */
2888                         pdata += 8;
2889
2890                         SIVAL(pdata,0, unix_perms_to_wire(sbuf.st_mode));     /* Standard UNIX file permissions */
2891                         SIVAL(pdata,4,0);
2892                         pdata += 8;
2893
2894                         SIVAL(pdata,0,sbuf.st_nlink);             /* number of hard links */
2895                         SIVAL(pdata,4,0);
2896                         pdata += 8+1;
2897                         data_size = PTR_DIFF(pdata,(*ppdata));
2898
2899                         {
2900                                 int i;
2901                                 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC"));
2902
2903                                 for (i=0; i<100; i++)
2904                                         DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
2905                                 DEBUG(4,("\n"));
2906                         }
2907
2908                         break;
2909
2910                 case SMB_QUERY_FILE_UNIX_LINK:
2911                         {
2912                                 pstring buffer;
2913
2914                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
2915 #ifdef S_ISLNK
2916                                 if(!S_ISLNK(sbuf.st_mode))
2917                                         return(UNIXERROR(ERRSRV,ERRbadlink));
2918 #else
2919                                 return(UNIXERROR(ERRDOS,ERRbadlink));
2920 #endif
2921                                 len = SMB_VFS_READLINK(conn,fullpathname, buffer, sizeof(pstring)-1);     /* read link */
2922                                 if (len == -1)
2923                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
2924                                 buffer[len] = 0;
2925                                 len = srvstr_push(outbuf, pdata, buffer, -1, STR_TERMINATE);
2926                                 pdata += len;
2927                                 data_size = PTR_DIFF(pdata,(*ppdata));
2928
2929                                 break;
2930                         }
2931
2932                 case SMB_QUERY_POSIX_ACL:
2933                         {
2934                                 SMB_ACL_T file_acl = NULL;
2935                                 SMB_ACL_T def_acl = NULL;
2936                                 uint16 num_file_acls = 0;
2937                                 uint16 num_def_acls = 0;
2938
2939                                 if (fsp && !fsp->is_directory && (fsp->fd != -1)) {
2940                                         file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp, fsp->fd);
2941                                 } else {
2942                                         file_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_ACCESS);
2943                                 }
2944
2945                                 if (file_acl == NULL && no_acl_syscall_error(errno)) {
2946                                         DEBUG(5,("call_trans2qfilepathinfo: ACLs not implemented on filesystem containing %s\n",
2947                                                 fname ));
2948                                         return ERROR_NT(NT_STATUS_NOT_IMPLEMENTED);
2949                                 }
2950
2951                                 if (S_ISDIR(sbuf.st_mode)) {
2952                                         if (fsp && fsp->is_directory) {
2953                                                 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fsp->fsp_name, SMB_ACL_TYPE_DEFAULT);
2954                                         } else {
2955                                                 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_DEFAULT);
2956                                         }
2957                                         def_acl = free_empty_sys_acl(conn, def_acl);
2958                                 }
2959
2960                                 num_file_acls = count_acl_entries(conn, file_acl);
2961                                 num_def_acls = count_acl_entries(conn, def_acl);
2962
2963                                 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
2964                                         DEBUG(5,("call_trans2qfilepathinfo: data_size too small (%u) need %u\n",
2965                                                 data_size,
2966                                                 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
2967                                                         SMB_POSIX_ACL_HEADER_SIZE) ));
2968                                         if (file_acl) {
2969                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
2970                                         }
2971                                         if (def_acl) {
2972                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
2973                                         }
2974                                         return ERROR_NT(NT_STATUS_BUFFER_TOO_SMALL);
2975                                 }
2976
2977                                 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
2978                                 SSVAL(pdata,2,num_file_acls);
2979                                 SSVAL(pdata,4,num_def_acls);
2980                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, &sbuf, file_acl)) {
2981                                         if (file_acl) {
2982                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
2983                                         }
2984                                         if (def_acl) {
2985                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
2986                                         }
2987                                         return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
2988                                 }
2989                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), &sbuf, def_acl)) {
2990                                         if (file_acl) {
2991                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
2992                                         }
2993                                         if (def_acl) {
2994                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
2995                                         }
2996                                         return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
2997                                 }
2998
2999                                 if (file_acl) {
3000                                         SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3001                                 }
3002                                 if (def_acl) {
3003                                         SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3004                                 }
3005                                 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
3006                                 break;
3007                         }
3008
3009                 default:
3010                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
3011         }
3012
3013         send_trans2_replies(outbuf, bufsize, params, param_size, *ppdata, data_size);
3014
3015         return(-1);
3016 }
3017
3018 /****************************************************************************
3019  Deal with the internal needs of setting the delete on close flag. Note that
3020  as the tdb locking is recursive, it is safe to call this from within
3021  open_file_shared. JRA.
3022 ****************************************************************************/
3023
3024 NTSTATUS set_delete_on_close_internal(files_struct *fsp, BOOL delete_on_close, uint32 dosmode)
3025 {
3026         if (delete_on_close) {
3027                 /*
3028                  * Only allow delete on close for writable files.
3029                  */
3030
3031                 if (dosmode & aRONLY) {
3032                         DEBUG(10,("set_delete_on_close_internal: file %s delete on close flag set but file attribute is readonly.\n",
3033                                 fsp->fsp_name ));
3034                         return NT_STATUS_CANNOT_DELETE;
3035                 }
3036
3037                 /*
3038                  * Only allow delete on close for writable shares.
3039                  */
3040
3041                 if (!CAN_WRITE(fsp->conn)) {
3042                         DEBUG(10,("set_delete_on_close_internal: file %s delete on close flag set but write access denied on share.\n",
3043                                 fsp->fsp_name ));
3044                         return NT_STATUS_ACCESS_DENIED;
3045                 }
3046
3047                 /*
3048                  * Only allow delete on close for files/directories opened with delete intent.
3049                  */
3050
3051                 if (!(fsp->desired_access & DELETE_ACCESS)) {
3052                         DEBUG(10,("set_delete_on_close_internal: file %s delete on close flag set but delete access denied.\n",
3053                                 fsp->fsp_name ));
3054                         return NT_STATUS_ACCESS_DENIED;
3055                 }
3056         }
3057
3058         if(fsp->is_directory) {
3059                 fsp->directory_delete_on_close = delete_on_close;
3060                 DEBUG(10, ("set_delete_on_close_internal: %s delete on close flag for fnum = %d, directory %s\n",
3061                         delete_on_close ? "Added" : "Removed", fsp->fnum, fsp->fsp_name ));
3062         } else {
3063                 fsp->delete_on_close = delete_on_close;
3064                 DEBUG(10, ("set_delete_on_close_internal: %s delete on close flag for fnum = %d, file %s\n",
3065                         delete_on_close ? "Added" : "Removed", fsp->fnum, fsp->fsp_name ));
3066         }
3067
3068         return NT_STATUS_OK;
3069 }
3070
3071 /****************************************************************************
3072  Sets the delete on close flag over all share modes on this file.
3073  Modify the share mode entry for all files open
3074  on this device and inode to tell other smbds we have
3075  changed the delete on close flag. This will be noticed
3076  in the close code, the last closer will delete the file
3077  if flag is set.
3078 ****************************************************************************/
3079
3080 NTSTATUS set_delete_on_close_over_all(files_struct *fsp, BOOL delete_on_close)
3081 {
3082         DEBUG(10,("set_delete_on_close_over_all: %s delete on close flag for fnum = %d, file %s\n",
3083                 delete_on_close ? "Adding" : "Removing", fsp->fnum, fsp->fsp_name ));
3084
3085         if (fsp->is_directory || fsp->is_stat)
3086                 return NT_STATUS_OK;
3087
3088         if (lock_share_entry_fsp(fsp) == False)
3089                 return NT_STATUS_ACCESS_DENIED;
3090
3091         if (!modify_delete_flag(fsp->dev, fsp->inode, delete_on_close)) {
3092                 DEBUG(0,("set_delete_on_close_over_all: failed to change delete on close flag for file %s\n",
3093                         fsp->fsp_name ));
3094                 unlock_share_entry_fsp(fsp);
3095                 return NT_STATUS_ACCESS_DENIED;
3096         }
3097
3098         unlock_share_entry_fsp(fsp);
3099         return NT_STATUS_OK;
3100 }
3101
3102 /****************************************************************************
3103  Set a hard link (called by UNIX extensions and by NT rename with HARD link
3104  code.
3105 ****************************************************************************/
3106
3107 NTSTATUS hardlink_internals(connection_struct *conn, char *oldname, char *newname)
3108 {
3109         BOOL bad_path_oldname = False;
3110         BOOL bad_path_newname = False;
3111         SMB_STRUCT_STAT sbuf1, sbuf2;
3112         pstring last_component_oldname;
3113         pstring last_component_newname;
3114         NTSTATUS status = NT_STATUS_OK;
3115
3116         ZERO_STRUCT(sbuf1);
3117         ZERO_STRUCT(sbuf2);
3118
3119         /* No wildcards. */
3120         if (ms_has_wild(newname) || ms_has_wild(oldname)) {
3121                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
3122         }
3123
3124         unix_convert(oldname,conn,last_component_oldname,&bad_path_oldname,&sbuf1);
3125         if (bad_path_oldname) {
3126                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
3127         }
3128
3129         /* Quick check for "." and ".." */
3130         if (last_component_oldname[0] == '.') {
3131                 if (!last_component_oldname[1] || (last_component_oldname[1] == '.' && !last_component_oldname[2])) {
3132                         return NT_STATUS_OBJECT_NAME_INVALID;
3133                 }
3134         }
3135
3136         /* source must already exist. */
3137         if (!VALID_STAT(sbuf1)) {
3138                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3139         }
3140
3141         if (!check_name(oldname,conn)) {
3142                 return NT_STATUS_ACCESS_DENIED;
3143         }
3144
3145         unix_convert(newname,conn,last_component_newname,&bad_path_newname,&sbuf2);
3146         if (bad_path_newname) {
3147                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
3148         }
3149
3150         /* Quick check for "." and ".." */
3151         if (last_component_newname[0] == '.') {
3152                 if (!last_component_newname[1] || (last_component_newname[1] == '.' && !last_component_newname[2])) {
3153                         return NT_STATUS_OBJECT_NAME_INVALID;
3154                 }
3155         }
3156
3157         /* Disallow if newname already exists. */
3158         if (VALID_STAT(sbuf2)) {
3159                 return NT_STATUS_OBJECT_NAME_COLLISION;
3160         }
3161
3162         if (!check_name(newname,conn)) {
3163                 return NT_STATUS_ACCESS_DENIED;
3164         }
3165
3166         /* No links from a directory. */
3167         if (S_ISDIR(sbuf1.st_mode)) {
3168                 return NT_STATUS_FILE_IS_A_DIRECTORY;
3169         }
3170
3171         /* Ensure this is within the share. */
3172         if (!reduce_name(conn, oldname) != 0)
3173                 return NT_STATUS_ACCESS_DENIED;
3174
3175         DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n", newname, oldname ));
3176
3177         if (SMB_VFS_LINK(conn,oldname,newname) != 0) {
3178                 status = map_nt_error_from_unix(errno);
3179                 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
3180                                 nt_errstr(status), newname, oldname));
3181         }
3182
3183         return status;
3184 }
3185
3186 /****************************************************************************
3187  Reply to a TRANS2_SETFILEINFO (set file info by fileid).
3188 ****************************************************************************/
3189
3190 static int call_trans2setfilepathinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
3191                                         char **pparams, int total_params, char **ppdata, int total_data,
3192                                         unsigned int max_data_bytes)
3193 {
3194         char *params = *pparams;
3195         char *pdata = *ppdata;
3196         uint16 tran_call = SVAL(inbuf, smb_setup0);
3197         uint16 info_level;
3198         int dosmode=0;
3199         SMB_OFF_T size=0;
3200         struct utimbuf tvs;
3201         SMB_STRUCT_STAT sbuf;
3202         pstring fname;
3203         int fd = -1;
3204         BOOL bad_path = False;
3205         files_struct *fsp = NULL;
3206         uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
3207         gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
3208         mode_t unixmode = 0;
3209         NTSTATUS status = NT_STATUS_OK;
3210
3211         if (!params)
3212                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3213
3214         ZERO_STRUCT(sbuf);
3215
3216         if (tran_call == TRANSACT2_SETFILEINFO) {
3217                 if (total_params < 4)
3218                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3219
3220                 fsp = file_fsp(params,0);
3221                 info_level = SVAL(params,2);
3222
3223                 if(fsp && (fsp->is_directory || fsp->fd == -1)) {
3224                         /*
3225                          * This is actually a SETFILEINFO on a directory
3226                          * handle (returned from an NT SMB). NT5.0 seems
3227                          * to do this call. JRA.
3228                          */
3229                         pstrcpy(fname, fsp->fsp_name);
3230                         if (SMB_VFS_STAT(conn,fname,&sbuf) != 0) {
3231                                 DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
3232                                 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadpath);
3233                         }
3234                 } else if (fsp && fsp->print_file) {
3235                         /*
3236                          * Doing a DELETE_ON_CLOSE should cancel a print job.
3237                          */
3238                         if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
3239                                 fsp->share_mode = FILE_DELETE_ON_CLOSE;
3240
3241                                 DEBUG(3,("call_trans2setfilepathinfo: Cancelling print job (%s)\n", fsp->fsp_name ));
3242
3243                                 SSVAL(params,0,0);
3244                                 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3245                                 return(-1);
3246                         } else
3247                                 return (UNIXERROR(ERRDOS,ERRbadpath));
3248             } else {
3249                         /*
3250                          * Original code - this is an open file.
3251                          */
3252                         CHECK_FSP(fsp,conn);
3253
3254                         pstrcpy(fname, fsp->fsp_name);
3255                         fd = fsp->fd;
3256
3257                         if (SMB_VFS_FSTAT(fsp,fd,&sbuf) != 0) {
3258                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
3259                                 return(UNIXERROR(ERRDOS,ERRbadfid));
3260                         }
3261                 }
3262         } else {
3263                 /* set path info */
3264                 if (total_params < 6)
3265                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3266
3267                 info_level = SVAL(params,0);
3268                 srvstr_get_path(inbuf, fname, &params[6], sizeof(fname), -1, STR_TERMINATE, &status, False);
3269                 if (!NT_STATUS_IS_OK(status)) {
3270                         return ERROR_NT(status);
3271                 }
3272                 unix_convert(fname,conn,0,&bad_path,&sbuf);
3273                 if (bad_path) {
3274                         return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
3275                 }
3276
3277                 /*
3278                  * For CIFS UNIX extensions the target name may not exist.
3279                  */
3280
3281                 if(!VALID_STAT(sbuf) && !INFO_LEVEL_IS_UNIX(info_level)) {
3282                         DEBUG(3,("call_trans2setfilepathinfo: stat of %s failed (%s)\n", fname, strerror(errno)));
3283                         return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadpath);
3284                 }
3285
3286                 if(!check_name(fname, conn)) {
3287                         return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadpath);
3288                 }
3289
3290         }
3291
3292         if (!CAN_WRITE(conn))
3293                 return ERROR_DOS(ERRSRV,ERRaccess);
3294
3295         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions())
3296                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
3297
3298         if (VALID_STAT(sbuf))
3299                 unixmode = sbuf.st_mode;
3300
3301         DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d totdata=%d\n",
3302                 tran_call,fname, fsp ? fsp->fnum : -1, info_level,total_data));
3303
3304         /* Realloc the parameter and data sizes */
3305         params = Realloc(*pparams,2);
3306         if(params == NULL)
3307                 return ERROR_DOS(ERRDOS,ERRnomem);
3308         *pparams = params;
3309
3310         SSVAL(params,0,0);
3311
3312         if (fsp && fsp->pending_modtime) {
3313                 /* the pending modtime overrides the current modtime */
3314                 sbuf.st_mtime = fsp->pending_modtime;
3315         }
3316
3317         size = get_file_size(sbuf);
3318         tvs.modtime = sbuf.st_mtime;
3319         tvs.actime = sbuf.st_atime;
3320         dosmode = dos_mode(conn,fname,&sbuf);
3321         unixmode = sbuf.st_mode;
3322
3323         set_owner = VALID_STAT(sbuf) ? sbuf.st_uid : (uid_t)SMB_UID_NO_CHANGE;
3324         set_grp = VALID_STAT(sbuf) ? sbuf.st_gid : (gid_t)SMB_GID_NO_CHANGE;
3325
3326         switch (info_level) {
3327                 case SMB_INFO_STANDARD:
3328                 {
3329                         if (total_data < 12)
3330                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3331
3332                         /* access time */
3333                         tvs.actime = make_unix_date2(pdata+l1_fdateLastAccess);
3334                         /* write time */
3335                         tvs.modtime = make_unix_date2(pdata+l1_fdateLastWrite);
3336                         break;
3337                 }
3338
3339                 case SMB_INFO_SET_EA:
3340                         status = set_ea(conn, fsp, fname, pdata, total_data);
3341                         if (NT_STATUS_V(status) !=  NT_STATUS_V(NT_STATUS_OK))
3342                                 return ERROR_NT(status);
3343                         break;
3344
3345                 /* XXXX um, i don't think this is right.
3346                         it's also not in the cifs6.txt spec.
3347                 */
3348                 case SMB_INFO_QUERY_EAS_FROM_LIST:
3349                         if (total_data < 28)
3350                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3351
3352                         tvs.actime = make_unix_date2(pdata+8);
3353                         tvs.modtime = make_unix_date2(pdata+12);
3354                         size = IVAL(pdata,16);
3355                         dosmode = IVAL(pdata,24);
3356                         break;
3357
3358                 /* XXXX nor this.  not in cifs6.txt, either. */
3359                 case SMB_INFO_QUERY_ALL_EAS:
3360                         if (total_data < 28)
3361                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3362
3363                         tvs.actime = make_unix_date2(pdata+8);
3364                         tvs.modtime = make_unix_date2(pdata+12);
3365                         size = IVAL(pdata,16);
3366                         dosmode = IVAL(pdata,24);
3367                         break;
3368
3369                 case SMB_SET_FILE_BASIC_INFO:
3370                 case SMB_FILE_BASIC_INFORMATION:
3371                 {
3372                         /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
3373                         time_t write_time;
3374                         time_t changed_time;
3375
3376                         if (total_data < 36)
3377                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3378
3379                         /* Ignore create time at offset pdata. */
3380
3381                         /* access time */
3382                         tvs.actime = interpret_long_date(pdata+8);
3383
3384                         write_time = interpret_long_date(pdata+16);
3385                         changed_time = interpret_long_date(pdata+24);
3386
3387                         tvs.modtime = MIN(write_time, changed_time);
3388
3389                         if (write_time > tvs.modtime && write_time != 0xffffffff) {
3390                                 tvs.modtime = write_time;
3391                         }
3392                         /* Prefer a defined time to an undefined one. */
3393                         if (tvs.modtime == (time_t)0 || tvs.modtime == (time_t)-1)
3394                                 tvs.modtime = (write_time == (time_t)0 || write_time == (time_t)-1
3395                                         ? changed_time : write_time);
3396
3397                         /* attributes */
3398                         dosmode = IVAL(pdata,32);
3399                         break;
3400                 }
3401
3402                 case SMB_FILE_ALLOCATION_INFORMATION:
3403                 case SMB_SET_FILE_ALLOCATION_INFO:
3404                 {
3405                         int ret = -1;
3406                         SMB_BIG_UINT allocation_size;
3407
3408                         if (total_data < 8)
3409                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3410
3411                         allocation_size = (SMB_BIG_UINT)IVAL(pdata,0);
3412 #ifdef LARGE_SMB_OFF_T
3413                         allocation_size |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
3414 #else /* LARGE_SMB_OFF_T */
3415                         if (IVAL(pdata,4) != 0) /* more than 32 bits? */
3416                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
3417 #endif /* LARGE_SMB_OFF_T */
3418                         DEBUG(10,("call_trans2setfilepathinfo: Set file allocation info for file %s to %.0f\n",
3419                                         fname, (double)allocation_size ));
3420
3421                         if (allocation_size)
3422                                 allocation_size = smb_roundup(allocation_size);
3423
3424                         if(allocation_size != get_file_size(sbuf)) {
3425                                 SMB_STRUCT_STAT new_sbuf;
3426
3427                                 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting new allocation size to %.0f\n",
3428                                         fname, (double)allocation_size ));
3429
3430                                 if (fd == -1) {
3431                                         files_struct *new_fsp = NULL;
3432                                         int access_mode = 0;
3433                                         int action = 0;
3434
3435                                         if(global_oplock_break) {
3436                                                 /* Queue this file modify as we are the process of an oplock break.  */
3437
3438                                                 DEBUG(2,("call_trans2setfilepathinfo: queueing message due to being "));
3439                                                 DEBUGADD(2,( "in oplock break state.\n"));
3440
3441                                                 push_oplock_pending_smb_message(inbuf, length);
3442                                                 return -1;
3443                                         }
3444
3445                                         new_fsp = open_file_shared1(conn, fname, &sbuf,FILE_WRITE_DATA,
3446                                                                         SET_OPEN_MODE(DOS_OPEN_RDWR),
3447                                                                         (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
3448                                                                         FILE_ATTRIBUTE_NORMAL,
3449                                                                         INTERNAL_OPEN_ONLY, &access_mode, &action);
3450
3451                                         if (new_fsp == NULL)
3452                                                 return(UNIXERROR(ERRDOS,ERRbadpath));
3453                                         ret = vfs_allocate_file_space(new_fsp, allocation_size);
3454                                         if (SMB_VFS_FSTAT(new_fsp,new_fsp->fd,&new_sbuf) != 0) {
3455                                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
3456                                                                         new_fsp->fnum, strerror(errno)));
3457                                                 ret = -1;
3458                                         }
3459                                         close_file(new_fsp,True);
3460                                 } else {
3461                                         ret = vfs_allocate_file_space(fsp, allocation_size);
3462                                         if (SMB_VFS_FSTAT(fsp,fd,&new_sbuf) != 0) {
3463                                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
3464                                                                         fsp->fnum, strerror(errno)));
3465                                                 ret = -1;
3466                                         }
3467                                 }
3468                                 if (ret == -1)
3469                                         return ERROR_NT(NT_STATUS_DISK_FULL);
3470
3471                                 /* Allocate can truncate size... */
3472                                 size = get_file_size(new_sbuf);
3473                         }
3474
3475                         break;
3476                 }
3477
3478                 case SMB_FILE_END_OF_FILE_INFORMATION:
3479                 case SMB_SET_FILE_END_OF_FILE_INFO:
3480                 {
3481                         if (total_data < 8)
3482                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3483
3484                         size = IVAL(pdata,0);
3485 #ifdef LARGE_SMB_OFF_T
3486                         size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
3487 #else /* LARGE_SMB_OFF_T */
3488                         if (IVAL(pdata,4) != 0) /* more than 32 bits? */
3489                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
3490 #endif /* LARGE_SMB_OFF_T */
3491                         DEBUG(10,("call_trans2setfilepathinfo: Set end of file info for file %s to %.0f\n", fname, (double)size ));
3492                         break;
3493                 }
3494
3495                 case SMB_FILE_DISPOSITION_INFORMATION:
3496                 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
3497                 {
3498                         BOOL delete_on_close;
3499
3500                         if (total_data < 1)
3501                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3502
3503                         delete_on_close = (CVAL(pdata,0) ? True : False);
3504
3505                         /* Just ignore this set on a path. */
3506                         if (tran_call != TRANSACT2_SETFILEINFO)
3507                                 break;
3508
3509                         if (fsp == NULL)
3510                                 return(UNIXERROR(ERRDOS,ERRbadfid));
3511
3512                         status = set_delete_on_close_internal(fsp, delete_on_close, dosmode);
3513
3514                         if (NT_STATUS_V(status) !=  NT_STATUS_V(NT_STATUS_OK))
3515                                 return ERROR_NT(status);
3516
3517                         /* The set is across all open files on this dev/inode pair. */
3518                         status =set_delete_on_close_over_all(fsp, delete_on_close);
3519                         if (NT_STATUS_V(status) !=  NT_STATUS_V(NT_STATUS_OK))
3520                                 return ERROR_NT(status);
3521
3522                         break;
3523                 }
3524
3525                 case SMB_FILE_POSITION_INFORMATION:
3526                 {
3527                         SMB_BIG_UINT position_information;
3528
3529                         if (total_data < 8)
3530                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3531
3532                         position_information = (SMB_BIG_UINT)IVAL(pdata,0);
3533 #ifdef LARGE_SMB_OFF_T
3534                         position_information |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
3535 #else /* LARGE_SMB_OFF_T */
3536                         if (IVAL(pdata,4) != 0) /* more than 32 bits? */
3537                                 return ERROR_DOS(ERRDOS,ERRunknownlevel);
3538 #endif /* LARGE_SMB_OFF_T */
3539                         DEBUG(10,("call_trans2setfilepathinfo: Set file position information for file %s to %.0f\n",
3540                                         fname, (double)position_information ));
3541                         if (fsp)
3542                                 fsp->position_information = position_information;
3543                         break;
3544                 }
3545
3546                 /*
3547                  * CIFS UNIX extensions.
3548                  */
3549
3550                 case SMB_SET_FILE_UNIX_BASIC:
3551                 {
3552                         uint32 raw_unixmode;
3553
3554                         if (total_data < 100)
3555                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3556
3557                         if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
3558                            IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
3559                                 size=IVAL(pdata,0); /* first 8 Bytes are size */
3560 #ifdef LARGE_SMB_OFF_T
3561                                 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
3562 #else /* LARGE_SMB_OFF_T */
3563                                 if (IVAL(pdata,4) != 0) /* more than 32 bits? */
3564                                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
3565 #endif /* LARGE_SMB_OFF_T */
3566                         }
3567                         pdata+=24;          /* ctime & st_blocks are not changed */
3568                         tvs.actime = interpret_long_unix_date(pdata); /* access_time */
3569                         tvs.modtime = interpret_long_unix_date(pdata+8); /* modification_time */
3570                         pdata+=16;
3571                         set_owner = (uid_t)IVAL(pdata,0);
3572                         pdata += 8;
3573                         set_grp = (gid_t)IVAL(pdata,0);
3574                         pdata += 8;
3575                         raw_unixmode = IVAL(pdata,28);
3576                         unixmode = unix_perms_from_wire(conn, &sbuf, raw_unixmode);
3577                         dosmode = 0; /* Ensure dos mode change doesn't override this. */
3578
3579                         DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC: name = %s \
3580 size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
3581                                 fname, (double)size, (unsigned int)set_owner, (unsigned int)set_grp, (int)raw_unixmode));
3582
3583                         if (!VALID_STAT(sbuf)) {
3584
3585                                 /*
3586                                  * The only valid use of this is to create character and block
3587                                  * devices, and named pipes. This is deprecated (IMHO) and
3588                                  * a new info level should be used for mknod. JRA.
3589                                  */
3590
3591                                 uint32 file_type = IVAL(pdata,0);
3592 #if defined(HAVE_MAKEDEV)
3593                                 uint32 dev_major = IVAL(pdata,4);
3594                                 uint32 dev_minor = IVAL(pdata,12);
3595 #endif
3596
3597                                 uid_t myuid = geteuid();
3598                                 gid_t mygid = getegid();
3599                                 SMB_DEV_T dev = (SMB_DEV_T)0;
3600
3601                                 if (tran_call == TRANSACT2_SETFILEINFO)
3602                                         return(ERROR_DOS(ERRDOS,ERRnoaccess));
3603
3604                                 if (raw_unixmode == SMB_MODE_NO_CHANGE)
3605                                         return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3606
3607 #if defined(HAVE_MAKEDEV)
3608                                 dev = makedev(dev_major, dev_minor);
3609 #endif
3610
3611                                 /* We can only create as the owner/group we are. */
3612
3613                                 if ((set_owner != myuid) && (set_owner != (uid_t)SMB_UID_NO_CHANGE))
3614                                         return(ERROR_DOS(ERRDOS,ERRnoaccess));
3615                                 if ((set_grp != mygid) && (set_grp != (gid_t)SMB_GID_NO_CHANGE))
3616                                         return(ERROR_DOS(ERRDOS,ERRnoaccess));
3617
3618                                 switch (file_type) {
3619 #if defined(S_IFIFO)
3620                                         case UNIX_TYPE_FIFO:
3621                                                 unixmode |= S_IFIFO;
3622                                                 break;
3623 #endif
3624 #if defined(S_IFSOCK)
3625                                         case UNIX_TYPE_SOCKET:
3626                                                 unixmode |= S_IFSOCK;
3627                                                 break;
3628 #endif
3629 #if defined(S_IFCHR)
3630                                         case UNIX_TYPE_CHARDEV:
3631                                                 unixmode |= S_IFCHR;
3632                                                 break;
3633 #endif
3634 #if defined(S_IFBLK)
3635                                         case UNIX_TYPE_BLKDEV:
3636                                                 unixmode |= S_IFBLK;
3637                                                 break;
3638 #endif
3639                                         default:
3640                                                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
3641                                 }
3642
3643                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC doing mknod dev %.0f mode \
3644 0%o for file %s\n", (double)dev, unixmode, fname ));
3645
3646                                 /* Ok - do the mknod. */
3647                                 if (SMB_VFS_MKNOD(conn,fname, unixmode, dev) != 0)
3648                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3649
3650                                 inherit_access_acl(conn, fname, unixmode);
3651
3652                                 SSVAL(params,0,0);
3653                                 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3654                                 return(-1);
3655                         }
3656
3657                         /*
3658                          * Deal with the UNIX specific mode set.
3659                          */
3660
3661                         if (raw_unixmode != SMB_MODE_NO_CHANGE) {
3662                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
3663                                         (unsigned int)unixmode, fname ));
3664                                 if (SMB_VFS_CHMOD(conn,fname,unixmode) != 0)
3665                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3666                         }
3667
3668                         /*
3669                          * Deal with the UNIX specific uid set.
3670                          */
3671
3672                         if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) && (sbuf.st_uid != set_owner)) {
3673                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing owner %u for file %s\n",
3674                                         (unsigned int)set_owner, fname ));
3675                                 if (SMB_VFS_CHOWN(conn,fname,set_owner, (gid_t)-1) != 0)
3676                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3677                         }
3678
3679                         /*
3680                          * Deal with the UNIX specific gid set.
3681                          */
3682
3683                         if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) && (sbuf.st_gid != set_grp)) {
3684                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
3685                                         (unsigned int)set_owner, fname ));
3686                                 if (SMB_VFS_CHOWN(conn,fname,(uid_t)-1, set_grp) != 0)
3687                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3688                         }
3689                         break;
3690                 }
3691
3692                 case SMB_SET_FILE_UNIX_LINK:
3693                 {
3694                         pstring link_target;
3695                         char *newname = fname;
3696
3697                         /* Set a symbolic link. */
3698                         /* Don't allow this if follow links is false. */
3699
3700                         if (!lp_symlinks(SNUM(conn)))
3701                                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
3702
3703                         srvstr_pull(inbuf, link_target, pdata, sizeof(link_target), -1, STR_TERMINATE);
3704
3705                         /* !widelinks forces the target path to be within the share. */
3706                         /* This means we can interpret the target as a pathname. */
3707                         if (!lp_widelinks(SNUM(conn))) {
3708                                 pstring rel_name;
3709                                 char *last_dirp = NULL;
3710
3711                                 unix_format(link_target);
3712                                 if (*link_target == '/') {
3713                                         /* No absolute paths allowed. */
3714                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3715                                 }
3716                                 pstrcpy(rel_name, newname);
3717                                 last_dirp = strrchr_m(rel_name, '/');
3718                                 if (last_dirp) {
3719                                         last_dirp[1] = '\0';
3720                                 } else {
3721                                         pstrcpy(rel_name, "./");
3722                                 }
3723                                 pstrcat(rel_name, link_target);
3724
3725                                 if (!check_name(rel_name, conn)) {
3726                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3727                                 }
3728                         }
3729
3730                         DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
3731                                 fname, link_target ));
3732
3733                         if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0)
3734                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
3735                         SSVAL(params,0,0);
3736                         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3737                         return(-1);
3738                 }
3739
3740                 case SMB_SET_FILE_UNIX_HLINK:
3741                 {
3742                         pstring oldname;
3743                         char *newname = fname;
3744
3745                         /* Set a hard link. */
3746                         srvstr_get_path(inbuf, oldname, pdata, sizeof(oldname), -1, STR_TERMINATE, &status, False);
3747                         if (!NT_STATUS_IS_OK(status)) {
3748                                 return ERROR_NT(status);
3749                         }
3750
3751                         DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
3752                                 fname, oldname));
3753
3754                         status = hardlink_internals(conn, oldname, newname);
3755                         if (!NT_STATUS_IS_OK(status)) {
3756                                 return ERROR_NT(status);
3757                         }
3758
3759                         SSVAL(params,0,0);
3760                         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3761                         return(-1);
3762                 }
3763
3764                 case SMB_FILE_RENAME_INFORMATION:
3765                 {
3766                         BOOL overwrite;
3767                         uint32 root_fid;
3768                         uint32 len;
3769                         pstring newname;
3770                         pstring base_name;
3771                         char *p;
3772
3773                         if (total_data < 12)
3774                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3775
3776                         overwrite = (CVAL(pdata,0) ? True : False);
3777                         root_fid = IVAL(pdata,4);
3778                         len = IVAL(pdata,8);
3779                         srvstr_get_path(inbuf, newname, &pdata[12], sizeof(newname), len, 0, &status, False);
3780                         if (!NT_STATUS_IS_OK(status)) {
3781                                 return ERROR_NT(status);
3782                         }
3783
3784                         /* Check the new name has no '/' characters. */
3785                         if (strchr_m(newname, '/'))
3786                                 return ERROR_NT(NT_STATUS_NOT_SUPPORTED);
3787
3788                         RESOLVE_DFSPATH(newname, conn, inbuf, outbuf);
3789
3790                         /* Create the base directory. */
3791                         pstrcpy(base_name, fname);
3792                         p = strrchr_m(base_name, '/');
3793                         if (p)
3794                                 *p = '\0';
3795                         /* Append the new name. */
3796                         pstrcat(base_name, "/");
3797                         pstrcat(base_name, newname);
3798
3799                         if (fsp) {
3800                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
3801                                         fsp->fnum, fsp->fsp_name, base_name ));
3802                                 status = rename_internals_fsp(conn, fsp, base_name, 0, overwrite);
3803                         } else {
3804                                 DEBUG(10,("call_trans2setfilepathinfo: SMB_FILE_RENAME_INFORMATION %s -> %s\n",
3805                                         fname, newname ));
3806                                 status = rename_internals(conn, fname, base_name, 0, overwrite);
3807                         }
3808                         if (!NT_STATUS_IS_OK(status)) {
3809                                 return ERROR_NT(status);
3810                         }
3811                         process_pending_change_notify_queue((time_t)0);
3812                         SSVAL(params,0,0);
3813                         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3814                         return(-1);
3815                 }
3816
3817                 case SMB_SET_POSIX_ACL:
3818                 {
3819                         uint16 posix_acl_version;
3820                         uint16 num_file_acls;
3821                         uint16 num_def_acls;
3822                         BOOL valid_file_acls = True;
3823                         BOOL valid_def_acls = True;
3824
3825                         if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
3826                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3827                         }
3828                         posix_acl_version = SVAL(pdata,0);
3829                         num_file_acls = SVAL(pdata,2);
3830                         num_def_acls = SVAL(pdata,4);
3831
3832                         if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
3833                                 valid_file_acls = False;
3834                                 num_file_acls = 0;
3835                         }
3836
3837                         if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
3838                                 valid_def_acls = False;
3839                                 num_def_acls = 0;
3840                         }
3841
3842                         if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
3843                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3844                         }
3845
3846                         if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
3847                                         (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
3848                                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
3849                         }
3850
3851                         if (valid_file_acls && !set_unix_posix_acl(conn, fsp, fname, num_file_acls,
3852                                         pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
3853                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
3854                         }
3855
3856                         if (valid_def_acls && !set_unix_posix_default_acl(conn, fname, &sbuf, num_def_acls,
3857                                         pdata + SMB_POSIX_ACL_HEADER_SIZE +
3858                                         (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
3859                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
3860                         }
3861
3862                         SSVAL(params,0,0);
3863                         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3864                         return(-1);
3865                 }
3866
3867                 default:
3868                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
3869         }
3870
3871         /* get some defaults (no modifications) if any info is zero or -1. */
3872         if (tvs.actime == (time_t)0 || tvs.actime == (time_t)-1)
3873                 tvs.actime = sbuf.st_atime;
3874
3875         if (tvs.modtime == (time_t)0 || tvs.modtime == (time_t)-1)
3876                 tvs.modtime = sbuf.st_mtime;
3877
3878         DEBUG(6,("actime: %s " , ctime(&tvs.actime)));
3879         DEBUG(6,("modtime: %s ", ctime(&tvs.modtime)));
3880         DEBUG(6,("size: %.0f ", (double)size));
3881
3882         if (dosmode) {
3883                 if (S_ISDIR(sbuf.st_mode))
3884                         dosmode |= aDIR;
3885                 else
3886                         dosmode &= ~aDIR;
3887         }
3888
3889         DEBUG(6,("dosmode: %x\n"  , dosmode));
3890
3891         if(!((info_level == SMB_SET_FILE_END_OF_FILE_INFO) ||
3892                 (info_level == SMB_SET_FILE_ALLOCATION_INFO) ||
3893                 (info_level == SMB_FILE_ALLOCATION_INFORMATION) ||
3894                 (info_level == SMB_FILE_END_OF_FILE_INFORMATION))) {
3895
3896                 /*
3897                  * Only do this test if we are not explicitly
3898                  * changing the size of a file.
3899                  */
3900                 if (!size)
3901                         size = get_file_size(sbuf);
3902         }
3903
3904         /*
3905          * Try and set the times, size and mode of this file -
3906          * if they are different from the current values
3907          */
3908         if (sbuf.st_mtime != tvs.modtime || sbuf.st_atime != tvs.actime) {
3909                 if(fsp != NULL) {
3910                         /*
3911                          * This was a setfileinfo on an open file.
3912                          * NT does this a lot. We also need to
3913                          * set the time here, as it can be read by
3914                          * FindFirst/FindNext and with the patch for bug #2045
3915                          * in smbd/fileio.c it ensures that this timestamp is
3916                          * kept sticky even after a write. We save the request
3917                          * away and will set it on file close and after a write. JRA.
3918                          */
3919
3920                         if (tvs.modtime != (time_t)0 && tvs.modtime != (time_t)-1) {
3921                                 DEBUG(10,("call_trans2setfilepathinfo: setting pending modtime to %s\n", ctime(&tvs.modtime) ));
3922                                 fsp->pending_modtime = tvs.modtime;
3923                         }
3924
3925                         DEBUG(10,("call_trans2setfilepathinfo: setting utimes to modified values.\n"));
3926
3927                         if(file_utime(conn, fname, &tvs)!=0) {
3928                                 return(UNIXERROR(ERRDOS,ERRnoaccess));
3929                         }
3930                 }
3931         }
3932
3933         /* check the mode isn't different, before changing it */
3934         if ((dosmode != 0) && (dosmode != dos_mode(conn, fname, &sbuf))) {
3935
3936                 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting dos mode %x\n", fname, dosmode ));
3937
3938                 if(file_set_dosmode(conn, fname, dosmode, &sbuf, False)) {
3939                         DEBUG(2,("file_set_dosmode of %s failed (%s)\n", fname, strerror(errno)));
3940                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3941                 }
3942         }
3943
3944         if (size != get_file_size(sbuf)) {
3945
3946                 int ret;
3947
3948                 DEBUG(10,("call_trans2setfilepathinfo: file %s : setting new size to %.0f\n",
3949                         fname, (double)size ));
3950
3951                 if (fd == -1) {
3952                         files_struct *new_fsp = NULL;
3953                         int access_mode = 0;
3954                         int action = 0;
3955
3956                         if(global_oplock_break) {
3957                                 /* Queue this file modify as we are the process of an oplock break.  */
3958
3959                                 DEBUG(2,("call_trans2setfilepathinfo: queueing message due to being "));
3960                                 DEBUGADD(2,( "in oplock break state.\n"));
3961
3962                                 push_oplock_pending_smb_message(inbuf, length);
3963                                 return -1;
3964                         }
3965
3966                         new_fsp = open_file_shared(conn, fname, &sbuf,
3967                                                 SET_OPEN_MODE(DOS_OPEN_RDWR),
3968                                                 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
3969                                                 FILE_ATTRIBUTE_NORMAL,
3970                                                 INTERNAL_OPEN_ONLY, &access_mode, &action);
3971
3972                         if (new_fsp == NULL)
3973                                 return(UNIXERROR(ERRDOS,ERRbadpath));
3974                         ret = vfs_set_filelen(new_fsp, size);
3975                         close_file(new_fsp,True);
3976                 } else {
3977                         ret = vfs_set_filelen(fsp, size);
3978                 }
3979
3980                 if (ret == -1)
3981                         return (UNIXERROR(ERRHRD,ERRdiskfull));
3982         }
3983
3984         SSVAL(params,0,0);
3985         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
3986
3987         return(-1);
3988 }
3989
3990 /****************************************************************************
3991  Reply to a TRANS2_MKDIR (make directory with extended attributes).
3992 ****************************************************************************/
3993
3994 static int call_trans2mkdir(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
3995                                         char **pparams, int total_params, char **ppdata, int total_data,
3996                                         unsigned int max_data_bytes)
3997 {
3998         char *params = *pparams;
3999         pstring directory;
4000         int ret = -1;
4001         SMB_STRUCT_STAT sbuf;
4002         BOOL bad_path = False;
4003         NTSTATUS status = NT_STATUS_OK;
4004
4005         if (!CAN_WRITE(conn))
4006                 return ERROR_DOS(ERRSRV,ERRaccess);
4007
4008         if (total_params < 4)
4009                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
4010
4011         srvstr_get_path(inbuf, directory, &params[4], sizeof(directory), -1, STR_TERMINATE, &status, False);
4012         if (!NT_STATUS_IS_OK(status)) {
4013                 return ERROR_NT(status);
4014         }
4015
4016         DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
4017
4018         unix_convert(directory,conn,0,&bad_path,&sbuf);
4019         if (bad_path) {
4020                 return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
4021         }
4022         if (check_name(directory,conn))
4023                 ret = vfs_MkDir(conn,directory,unix_mode(conn,aDIR,directory,True));
4024
4025         if(ret < 0) {
4026                 DEBUG(5,("call_trans2mkdir error (%s)\n", strerror(errno)));
4027                 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRnoaccess);
4028         }
4029
4030         /* Realloc the parameter and data sizes */
4031         params = Realloc(*pparams,2);
4032         if(params == NULL)
4033                 return ERROR_DOS(ERRDOS,ERRnomem);
4034         *pparams = params;
4035
4036         SSVAL(params,0,0);
4037
4038         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
4039
4040         return(-1);
4041 }
4042
4043 /****************************************************************************
4044  Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
4045  We don't actually do this - we just send a null response.
4046 ****************************************************************************/
4047
4048 static int call_trans2findnotifyfirst(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
4049                                         char **pparams, int total_params, char **ppdata, int total_data,
4050                                         unsigned int max_data_bytes)
4051 {
4052         static uint16 fnf_handle = 257;
4053         char *params = *pparams;
4054         uint16 info_level;
4055
4056         if (total_params < 6)
4057                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
4058
4059         info_level = SVAL(params,4);
4060         DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
4061
4062         switch (info_level) {
4063                 case 1:
4064                 case 2:
4065                         break;
4066                 default:
4067                         return ERROR_DOS(ERRDOS,ERRunknownlevel);
4068         }
4069
4070         /* Realloc the parameter and data sizes */
4071         params = Realloc(*pparams,6);
4072         if(params == NULL)
4073                 return ERROR_DOS(ERRDOS,ERRnomem);
4074         *pparams = params;
4075
4076         SSVAL(params,0,fnf_handle);
4077         SSVAL(params,2,0); /* No changes */
4078         SSVAL(params,4,0); /* No EA errors */
4079
4080         fnf_handle++;
4081
4082         if(fnf_handle == 0)
4083                 fnf_handle = 257;
4084
4085         send_trans2_replies(outbuf, bufsize, params, 6, *ppdata, 0);
4086
4087         return(-1);
4088 }
4089
4090 /****************************************************************************
4091  Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
4092  changes). Currently this does nothing.
4093 ****************************************************************************/
4094
4095 static int call_trans2findnotifynext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
4096                                         char **pparams, int total_params, char **ppdata, int total_data,
4097                                         unsigned int max_data_bytes)
4098 {
4099         char *params = *pparams;
4100
4101         DEBUG(3,("call_trans2findnotifynext\n"));
4102
4103         /* Realloc the parameter and data sizes */
4104         params = Realloc(*pparams,4);
4105         if(params == NULL)
4106                 return ERROR_DOS(ERRDOS,ERRnomem);
4107         *pparams = params;
4108
4109         SSVAL(params,0,0); /* No changes */
4110         SSVAL(params,2,0); /* No EA errors */
4111
4112         send_trans2_replies(outbuf, bufsize, params, 4, *ppdata, 0);
4113
4114         return(-1);
4115 }
4116
4117 /****************************************************************************
4118  Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
4119 ****************************************************************************/
4120
4121 static int call_trans2getdfsreferral(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
4122                                         char **pparams, int total_params, char **ppdata, int total_data,
4123                                         unsigned int max_data_bytes)
4124 {
4125         char *params = *pparams;
4126         pstring pathname;
4127         int reply_size = 0;
4128         int max_referral_level;
4129
4130         DEBUG(10,("call_trans2getdfsreferral\n"));
4131
4132         if (total_params < 2)
4133                 return(ERROR_DOS(ERRDOS,ERRinvalidparam));
4134
4135         max_referral_level = SVAL(params,0);
4136
4137         if(!lp_host_msdfs())
4138                 return ERROR_DOS(ERRDOS,ERRbadfunc);
4139
4140         srvstr_pull(inbuf, pathname, &params[2], sizeof(pathname), -1, STR_TERMINATE);
4141         if((reply_size = setup_dfs_referral(conn, pathname,max_referral_level,ppdata)) < 0)
4142                 return UNIXERROR(ERRDOS,ERRbadfile);
4143
4144         SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
4145         send_trans2_replies(outbuf,bufsize,0,0,*ppdata,reply_size);
4146
4147         return(-1);
4148 }
4149
4150 #define LMCAT_SPL       0x53
4151 #define LMFUNC_GETJOBID 0x60
4152
4153 /****************************************************************************
4154  Reply to a TRANS2_IOCTL - used for OS/2 printing.
4155 ****************************************************************************/
4156
4157 static int call_trans2ioctl(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
4158                                         char **pparams, int total_params, char **ppdata, int total_data,
4159                                         unsigned int max_data_bytes)
4160 {
4161         char *pdata = *ppdata;
4162         files_struct *fsp = file_fsp(inbuf,smb_vwv15);
4163
4164         /* check for an invalid fid before proceeding */
4165
4166         if (!fsp)
4167                 return(ERROR_DOS(ERRDOS,ERRbadfid));
4168
4169         if ((SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
4170                         (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
4171                 pdata = Realloc(*ppdata, 32);
4172                 if(pdata == NULL)
4173                         return ERROR_DOS(ERRDOS,ERRnomem);
4174                 *ppdata = pdata;
4175
4176                 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
4177                         CAN ACCEPT THIS IN UNICODE. JRA. */
4178
4179                 SSVAL(pdata,0,fsp->rap_print_jobid);                     /* Job number */
4180                 srvstr_push( outbuf, pdata + 2, global_myname(), 15, STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
4181                 srvstr_push( outbuf, pdata+18, lp_servicename(SNUM(conn)), 13, STR_ASCII|STR_TERMINATE); /* Service name */
4182                 send_trans2_replies(outbuf,bufsize,*pparams,0,*ppdata,32);
4183                 return(-1);
4184         } else {
4185                 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
4186                 return ERROR_DOS(ERRSRV,ERRerror);
4187         }
4188 }
4189
4190 /****************************************************************************
4191  Reply to a SMBfindclose (stop trans2 directory search).
4192 ****************************************************************************/
4193
4194 int reply_findclose(connection_struct *conn,
4195                     char *inbuf,char *outbuf,int length,int bufsize)
4196 {
4197         int outsize = 0;
4198         int dptr_num=SVALS(inbuf,smb_vwv0);
4199         START_PROFILE(SMBfindclose);
4200
4201         DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
4202
4203         dptr_close(&dptr_num);
4204
4205         outsize = set_message(outbuf,0,0,True);
4206
4207         DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
4208
4209         END_PROFILE(SMBfindclose);
4210         return(outsize);
4211 }
4212
4213 /****************************************************************************
4214  Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
4215 ****************************************************************************/
4216
4217 int reply_findnclose(connection_struct *conn,
4218                      char *inbuf,char *outbuf,int length,int bufsize)
4219 {
4220         int outsize = 0;
4221         int dptr_num= -1;
4222         START_PROFILE(SMBfindnclose);
4223
4224         dptr_num = SVAL(inbuf,smb_vwv0);
4225
4226         DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
4227
4228         /* We never give out valid handles for a
4229            findnotifyfirst - so any dptr_num is ok here.
4230            Just ignore it. */
4231
4232         outsize = set_message(outbuf,0,0,True);
4233
4234         DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
4235
4236         END_PROFILE(SMBfindnclose);
4237         return(outsize);
4238 }
4239
4240 /****************************************************************************
4241  Reply to a SMBtranss2 - just ignore it!
4242 ****************************************************************************/
4243
4244 int reply_transs2(connection_struct *conn,
4245                   char *inbuf,char *outbuf,int length,int bufsize)
4246 {
4247         START_PROFILE(SMBtranss2);
4248         DEBUG(4,("Ignoring transs2 of length %d\n",length));
4249         END_PROFILE(SMBtranss2);
4250         return(-1);
4251 }
4252
4253 /****************************************************************************
4254  Reply to a SMBtrans2.
4255 ****************************************************************************/
4256
4257 int reply_trans2(connection_struct *conn,
4258                  char *inbuf,char *outbuf,int length,int bufsize)
4259 {
4260         int outsize = 0;
4261         unsigned int total_params = SVAL(inbuf, smb_tpscnt);
4262         unsigned int total_data =SVAL(inbuf, smb_tdscnt);
4263         unsigned int max_data_bytes = SVAL(inbuf, smb_mdrcnt);
4264 #if 0
4265         unsigned int max_param_reply = SVAL(inbuf, smb_mprcnt);
4266         unsigned int max_setup_fields = SVAL(inbuf, smb_msrcnt);
4267         BOOL close_tid = BITSETW(inbuf+smb_flags,0);
4268         BOOL no_final_response = BITSETW(inbuf+smb_flags,1);
4269         int32 timeout = IVALS(inbuf,smb_timeout);
4270 #endif
4271         unsigned int suwcnt = SVAL(inbuf, smb_suwcnt);
4272         unsigned int tran_call = SVAL(inbuf, smb_setup0);
4273         char *params = NULL, *data = NULL;
4274         unsigned int num_params, num_params_sofar, num_data, num_data_sofar;
4275         START_PROFILE(SMBtrans2);
4276
4277         if(global_oplock_break && (tran_call == TRANSACT2_OPEN)) {
4278                 /* Queue this open message as we are the process of an
4279                  * oplock break.  */
4280
4281                 DEBUG(2,("reply_trans2: queueing message trans2open due to being "));
4282                 DEBUGADD(2,( "in oplock break state.\n"));
4283
4284                 push_oplock_pending_smb_message(inbuf, length);
4285                 END_PROFILE(SMBtrans2);
4286                 return -1;
4287         }
4288
4289         if (IS_IPC(conn) && (tran_call != TRANSACT2_OPEN)
4290             && (tran_call != TRANSACT2_GET_DFS_REFERRAL)) {
4291                 END_PROFILE(SMBtrans2);
4292                 return ERROR_DOS(ERRSRV,ERRaccess);
4293         }
4294
4295         outsize = set_message(outbuf,0,0,True);
4296
4297         /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
4298            is so as a sanity check */
4299         if (suwcnt != 1) {
4300                 /*
4301                  * Need to have rc=0 for ioctl to get job id for OS/2.
4302                  *  Network printing will fail if function is not successful.
4303                  *  Similar function in reply.c will be used if protocol
4304                  *  is LANMAN1.0 instead of LM1.2X002.
4305                  *  Until DosPrintSetJobInfo with PRJINFO3 is supported,
4306                  *  outbuf doesn't have to be set(only job id is used).
4307                  */
4308                 if ( (suwcnt == 4) && (tran_call == TRANSACT2_IOCTL) &&
4309                                 (SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
4310                                 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
4311                         DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
4312                 } else {
4313                         DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",suwcnt));
4314                         DEBUG(2,("Transaction is %d\n",tran_call));
4315                         END_PROFILE(SMBtrans2);
4316                         ERROR_DOS(ERRDOS,ERRinvalidparam);
4317                 }
4318         }
4319
4320         /* Allocate the space for the maximum needed parameters and data */
4321         if (total_params > 0)
4322                 params = (char *)malloc(total_params);
4323         if (total_data > 0)
4324                 data = (char *)malloc(total_data);
4325
4326         if ((total_params && !params)  || (total_data && !data)) {
4327                 DEBUG(2,("Out of memory in reply_trans2\n"));
4328                 SAFE_FREE(params);
4329                 SAFE_FREE(data);
4330                 END_PROFILE(SMBtrans2);
4331                 return ERROR_DOS(ERRDOS,ERRnomem);
4332         }
4333
4334         /* Copy the param and data bytes sent with this request into
4335            the params buffer */
4336         num_params = num_params_sofar = SVAL(inbuf,smb_pscnt);
4337         num_data = num_data_sofar = SVAL(inbuf, smb_dscnt);
4338
4339         if (num_params > total_params || num_data > total_data)
4340                 exit_server("invalid params in reply_trans2");
4341
4342         if(params) {
4343                 unsigned int psoff = SVAL(inbuf, smb_psoff);
4344                 if ((psoff + num_params < psoff) || (psoff + num_params < num_params))
4345                         goto bad_param;
4346                 if ((smb_base(inbuf) + psoff + num_params > inbuf + length) ||
4347                                 (smb_base(inbuf) + psoff + num_params < smb_base(inbuf)))
4348                         goto bad_param;
4349                 memcpy( params, smb_base(inbuf) + psoff, num_params);
4350         }
4351         if(data) {
4352                 unsigned int dsoff = SVAL(inbuf, smb_dsoff);
4353                 if ((dsoff + num_data < dsoff) || (dsoff + num_data < num_data))
4354                         goto bad_param;
4355                 if ((smb_base(inbuf) + dsoff + num_data > inbuf + length) ||
4356                                 (smb_base(inbuf) + dsoff + num_data < smb_base(inbuf)))
4357                         goto bad_param;
4358                 memcpy( data, smb_base(inbuf) + dsoff, num_data);
4359         }
4360
4361         srv_signing_trans_start(SVAL(inbuf,smb_mid));
4362
4363         if(num_data_sofar < total_data || num_params_sofar < total_params)  {
4364                 /* We need to send an interim response then receive the rest
4365                    of the parameter/data bytes */
4366                 outsize = set_message(outbuf,0,0,True);
4367                 srv_signing_trans_stop();
4368                 if (!send_smb(smbd_server_fd(),outbuf))
4369                         exit_server("reply_trans2: send_smb failed.");
4370
4371                 while (num_data_sofar < total_data ||
4372                        num_params_sofar < total_params) {
4373                         BOOL ret;
4374                         unsigned int param_disp;
4375                         unsigned int param_off;
4376                         unsigned int data_disp;
4377                         unsigned int data_off;
4378
4379                         ret = receive_next_smb(inbuf,bufsize,SMB_SECONDARY_WAIT);
4380
4381                         /*
4382                          * The sequence number for the trans reply is always
4383                          * based on the last secondary received.
4384                          */
4385
4386                         srv_signing_trans_start(SVAL(inbuf,smb_mid));
4387
4388                         if ((ret &&
4389                              (CVAL(inbuf, smb_com) != SMBtranss2)) || !ret) {
4390                                 outsize = set_message(outbuf,0,0,True);
4391                                 if(ret)
4392                                         DEBUG(0,("reply_trans2: Invalid secondary trans2 packet\n"));
4393                                 else
4394                                         DEBUG(0,("reply_trans2: %s in getting secondary trans2 response.\n",
4395                                                  (smb_read_error == READ_ERROR) ? "error" : "timeout" ));
4396                                 goto bad_param;
4397                         }
4398
4399                         /* Revise total_params and total_data in case
4400                            they have changed downwards */
4401                         if (SVAL(inbuf, smb_tpscnt) < total_params)
4402                                 total_params = SVAL(inbuf, smb_tpscnt);
4403                         if (SVAL(inbuf, smb_tdscnt) < total_data)
4404                                 total_data = SVAL(inbuf, smb_tdscnt);
4405
4406                         num_params = SVAL(inbuf,smb_spscnt);
4407                         param_off = SVAL(inbuf, smb_spsoff);
4408                         param_disp = SVAL(inbuf, smb_spsdisp);
4409                         num_params_sofar += num_params;
4410
4411                         num_data = SVAL(inbuf, smb_sdscnt);
4412                         data_off = SVAL(inbuf, smb_sdsoff);
4413                         data_disp = SVAL(inbuf, smb_sdsdisp);
4414                         num_data_sofar += num_data;
4415
4416                         if (num_params_sofar > total_params || num_data_sofar > total_data)
4417                                 goto bad_param;
4418
4419                         if (num_params) {
4420                                 if (param_disp + num_params > total_params)
4421                                         goto bad_param;
4422                                 if ((param_disp + num_params < param_disp) ||
4423                                                 (param_disp + num_params < num_params))
4424                                         goto bad_param;
4425                                 if (param_disp > total_params)
4426                                         goto bad_param;
4427                                 if ((smb_base(inbuf) + param_off + num_params >= inbuf + bufsize) ||
4428                                                 (smb_base(inbuf) + param_off + num_params < smb_base(inbuf)))
4429                                         goto bad_param;
4430                                 if (params + param_disp < params)
4431                                         goto bad_param;
4432
4433                                 memcpy( &params[param_disp], smb_base(inbuf) + param_off, num_params);
4434                         }
4435                         if (num_data) {
4436                                 if (data_disp + num_data > total_data)
4437                                         goto bad_param;
4438                                 if ((data_disp + num_data < data_disp) ||
4439                                                 (data_disp + num_data < num_data))
4440                                         goto bad_param;
4441                                 if (data_disp > total_data)
4442                                         goto bad_param;
4443                                 if ((smb_base(inbuf) + data_off + num_data >= inbuf + bufsize) ||
4444                                                 (smb_base(inbuf) + data_off + num_data < smb_base(inbuf)))
4445                                         goto bad_param;
4446                                 if (data + data_disp < data)
4447                                         goto bad_param;
4448
4449                                 memcpy( &data[data_disp], smb_base(inbuf) + data_off, num_data);
4450                         }
4451                 }
4452         }
4453
4454         if (Protocol >= PROTOCOL_NT1) {
4455                 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | 0x40); /* IS_LONG_NAME */
4456         }
4457
4458         /* Now we must call the relevant TRANS2 function */
4459         switch(tran_call)  {
4460         case TRANSACT2_OPEN:
4461                 START_PROFILE_NESTED(Trans2_open);
4462                 outsize = call_trans2open(conn, inbuf, outbuf, bufsize,
4463                                           &params, total_params, &data, total_data, max_data_bytes);
4464                 END_PROFILE_NESTED(Trans2_open);
4465                 break;
4466
4467         case TRANSACT2_FINDFIRST:
4468                 START_PROFILE_NESTED(Trans2_findfirst);
4469                 outsize = call_trans2findfirst(conn, inbuf, outbuf, bufsize,
4470                                           &params, total_params, &data, total_data, max_data_bytes);
4471                 END_PROFILE_NESTED(Trans2_findfirst);
4472                 break;
4473
4474         case TRANSACT2_FINDNEXT:
4475                 START_PROFILE_NESTED(Trans2_findnext);
4476                 outsize = call_trans2findnext(conn, inbuf, outbuf, length, bufsize,
4477                                           &params, total_params, &data, total_data, max_data_bytes);
4478                 END_PROFILE_NESTED(Trans2_findnext);
4479                 break;
4480
4481         case TRANSACT2_QFSINFO:
4482                 START_PROFILE_NESTED(Trans2_qfsinfo);
4483                 outsize = call_trans2qfsinfo(conn, inbuf, outbuf, length, bufsize,
4484                                           &params, total_params, &data, total_data, max_data_bytes);
4485                 END_PROFILE_NESTED(Trans2_qfsinfo);
4486             break;
4487
4488 #ifdef HAVE_SYS_QUOTAS
4489         case TRANSACT2_SETFSINFO:
4490                 START_PROFILE_NESTED(Trans2_setfsinfo);
4491                 outsize = call_trans2setfsinfo(conn, inbuf, outbuf, length, bufsize,
4492                                           &params, total_params, &data, total_data, max_data_bytes);
4493                 END_PROFILE_NESTED(Trans2_setfsinfo);
4494                 break;
4495 #endif
4496         case TRANSACT2_QPATHINFO:
4497         case TRANSACT2_QFILEINFO:
4498                 START_PROFILE_NESTED(Trans2_qpathinfo);
4499                 outsize = call_trans2qfilepathinfo(conn, inbuf, outbuf, length, bufsize,
4500                                           &params, total_params, &data, total_data, max_data_bytes);
4501                 END_PROFILE_NESTED(Trans2_qpathinfo);
4502                 break;
4503         case TRANSACT2_SETPATHINFO:
4504         case TRANSACT2_SETFILEINFO:
4505                 START_PROFILE_NESTED(Trans2_setpathinfo);
4506                 outsize = call_trans2setfilepathinfo(conn, inbuf, outbuf, length, bufsize,
4507                                           &params, total_params, &data, total_data, max_data_bytes);
4508                 END_PROFILE_NESTED(Trans2_setpathinfo);
4509                 break;
4510
4511         case TRANSACT2_FINDNOTIFYFIRST:
4512                 START_PROFILE_NESTED(Trans2_findnotifyfirst);
4513                 outsize = call_trans2findnotifyfirst(conn, inbuf, outbuf, length, bufsize,
4514                                           &params, total_params, &data, total_data, max_data_bytes);
4515                 END_PROFILE_NESTED(Trans2_findnotifyfirst);
4516                 break;
4517
4518         case TRANSACT2_FINDNOTIFYNEXT:
4519                 START_PROFILE_NESTED(Trans2_findnotifynext);
4520                 outsize = call_trans2findnotifynext(conn, inbuf, outbuf, length, bufsize,
4521                                           &params, total_params, &data, total_data, max_data_bytes);
4522                 END_PROFILE_NESTED(Trans2_findnotifynext);
4523                 break;
4524         case TRANSACT2_MKDIR:
4525                 START_PROFILE_NESTED(Trans2_mkdir);
4526                 outsize = call_trans2mkdir(conn, inbuf, outbuf, length, bufsize,
4527                                           &params, total_params, &data, total_data, max_data_bytes);
4528                 END_PROFILE_NESTED(Trans2_mkdir);
4529                 break;
4530
4531         case TRANSACT2_GET_DFS_REFERRAL:
4532                 START_PROFILE_NESTED(Trans2_get_dfs_referral);
4533                 outsize = call_trans2getdfsreferral(conn,inbuf,outbuf,length, bufsize,
4534                                           &params, total_params, &data, total_data, max_data_bytes);
4535                 END_PROFILE_NESTED(Trans2_get_dfs_referral);
4536                 break;
4537         case TRANSACT2_IOCTL:
4538                 START_PROFILE_NESTED(Trans2_ioctl);
4539                 outsize = call_trans2ioctl(conn,inbuf,outbuf,length, bufsize,
4540                                           &params, total_params, &data, total_data, max_data_bytes);
4541                 END_PROFILE_NESTED(Trans2_ioctl);
4542                 break;
4543         default:
4544                 /* Error in request */
4545                 DEBUG(2,("Unknown request %d in trans2 call\n", tran_call));
4546                 SAFE_FREE(params);
4547                 SAFE_FREE(data);
4548                 END_PROFILE(SMBtrans2);
4549                 srv_signing_trans_stop();
4550                 return ERROR_DOS(ERRSRV,ERRerror);
4551         }
4552
4553         /* As we do not know how many data packets will need to be
4554            returned here the various call_trans2xxxx calls
4555            must send their own. Thus a call_trans2xxx routine only
4556            returns a value other than -1 when it wants to send
4557            an error packet.
4558         */
4559
4560         srv_signing_trans_stop();
4561
4562         SAFE_FREE(params);
4563         SAFE_FREE(data);
4564         END_PROFILE(SMBtrans2);
4565         return outsize; /* If a correct response was needed the
4566                            call_trans2xxx calls have already sent
4567                            it. If outsize != -1 then it is returning */
4568
4569   bad_param:
4570
4571         srv_signing_trans_stop();
4572         SAFE_FREE(params);
4573         SAFE_FREE(data);
4574         END_PROFILE(SMBtrans2);
4575         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
4576 }