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