source/smbd/trans2.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB transaction2 handling
   4    Copyright (C) Jeremy Allison                 1994-2007
   5    Copyright (C) Stefan (metze) Metzmacher      2003
   6    Copyright (C) Volker Lendecke                2005
   7    Copyright (C) Steve French                   2005
   8
   9    Extensively modified by Andrew Tridgell, 1995
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24 */
  25
  26 #include "includes.h"
  27
  28 extern int max_send;
  29 extern enum protocol_types Protocol;
  30 extern int smb_read_error;
  31 extern uint32 global_client_caps;
  32 extern struct current_user current_user;
  33
  34 #define get_file_size(sbuf) ((sbuf).st_size)
  35 #define DIR_ENTRY_SAFETY_MARGIN 4096
  36
  37 /********************************************************************
  38  Roundup a value to the nearest allocation roundup size boundary.
  39  Only do this for Windows clients.
  40 ********************************************************************/
  41
  42 SMB_BIG_UINT smb_roundup(connection_struct *conn, SMB_BIG_UINT val)
  43 {
  44         SMB_BIG_UINT rval = lp_allocation_roundup_size(SNUM(conn));
  45
  46         /* Only roundup for Windows clients. */
  47         enum remote_arch_types ra_type = get_remote_arch();
  48         if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
  49                 val = SMB_ROUNDUP(val,rval);
  50         }
  51         return val;
  52 }
  53
  54 /********************************************************************
  55  Given a stat buffer return the allocated size on disk, taking into
  56  account sparse files.
  57 ********************************************************************/
  58
  59 SMB_BIG_UINT get_allocation_size(connection_struct *conn, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
  60 {
  61         SMB_BIG_UINT ret;
  62
  63         if(S_ISDIR(sbuf->st_mode)) {
  64                 return 0;
  65         }
  66
  67 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
  68         ret = (SMB_BIG_UINT)STAT_ST_BLOCKSIZE * (SMB_BIG_UINT)sbuf->st_blocks;
  69 #else
  70         ret = (SMB_BIG_UINT)get_file_size(*sbuf);
  71 #endif
  72
  73         if (fsp && fsp->initial_allocation_size)
  74                 ret = MAX(ret,fsp->initial_allocation_size);
  75
  76         return smb_roundup(conn, ret);
  77 }
  78
  79 /****************************************************************************
  80  Utility functions for dealing with extended attributes.
  81 ****************************************************************************/
  82
  83 static const char *prohibited_ea_names[] = {
  84         SAMBA_POSIX_INHERITANCE_EA_NAME,
  85         SAMBA_XATTR_DOS_ATTRIB,
  86         NULL
  87 };
  88
  89 /****************************************************************************
  90  Refuse to allow clients to overwrite our private xattrs.
  91 ****************************************************************************/
  92
  93 static BOOL samba_private_attr_name(const char *unix_ea_name)
  94 {
  95         int i;
  96
  97         for (i = 0; prohibited_ea_names[i]; i++) {
  98                 if (strequal( prohibited_ea_names[i], unix_ea_name))
  99                         return True;
 100         }
 101         return False;
 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_ARRAY(mem_ctx, val, char, attr_size);
 119         if (!val) {
 120                 return False;
 121         }
 122
 123         if (fsp && fsp->fh->fd != -1) {
 124                 sizeret = SMB_VFS_FGETXATTR(fsp, fsp->fh->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 %u: ", ea_name, (unsigned int)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 = (unsigned char *)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_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
 157                                         const char *fname, size_t *pea_total_len)
 158 {
 159         /* Get a list of all xattrs. Max namesize is 64k. */
 160         size_t ea_namelist_size = 1024;
 161         char *ea_namelist;
 162         char *p;
 163         ssize_t sizeret;
 164         int i;
 165         struct ea_list *ea_list_head = NULL;
 166
 167         *pea_total_len = 0;
 168
 169         if (!lp_ea_support(SNUM(conn))) {
 170                 return NULL;
 171         }
 172
 173         for (i = 0, ea_namelist = TALLOC_ARRAY(mem_ctx, char, ea_namelist_size); i < 6;
 174              ea_namelist = TALLOC_REALLOC_ARRAY(mem_ctx, ea_namelist, char, ea_namelist_size), i++) {
 175
 176                 if (!ea_namelist) {
 177                         return NULL;
 178                 }
 179
 180                 if (fsp && fsp->fh->fd != -1) {
 181                         sizeret = SMB_VFS_FLISTXATTR(fsp, fsp->fh->fd, ea_namelist, ea_namelist_size);
 182                 } else {
 183                         sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist, ea_namelist_size);
 184                 }
 185
 186                 if (sizeret == -1 && errno == ERANGE) {
 187                         ea_namelist_size *= 2;
 188                 } else {
 189                         break;
 190                 }
 191         }
 192
 193         if (sizeret == -1)
 194                 return NULL;
 195
 196         DEBUG(10,("get_ea_list_from_file: ea_namelist size = %u\n", (unsigned int)sizeret ));
 197
 198         if (sizeret) {
 199                 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p) + 1) {
 200                         struct ea_list *listp;
 201
 202                         if (strnequal(p, "system.", 7) || samba_private_attr_name(p))
 203                                 continue;
 204
 205                         listp = TALLOC_P(mem_ctx, struct ea_list);
 206                         if (!listp)
 207                                 return NULL;
 208
 209                         if (!get_ea_value(mem_ctx, conn, fsp, fname, p, &listp->ea)) {
 210                                 return NULL;
 211                         }
 212
 213                         {
 214                                 fstring dos_ea_name;
 215                                 push_ascii_fstring(dos_ea_name, listp->ea.name);
 216                                 *pea_total_len += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
 217                                 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len = %u\n",
 218                                         (unsigned int)*pea_total_len, dos_ea_name,
 219                                         (unsigned int)listp->ea.value.length ));
 220                         }
 221                         DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
 222                 }
 223                 /* Add on 4 for total length. */
 224                 if (*pea_total_len) {
 225                         *pea_total_len += 4;
 226                 }
 227         }
 228
 229         DEBUG(10,("get_ea_list_from_file: total_len = %u\n", (unsigned int)*pea_total_len));
 230         return ea_list_head;
 231 }
 232
 233 /****************************************************************************
 234  Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
 235  that was filled.
 236 ****************************************************************************/
 237
 238 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
 239         connection_struct *conn, struct ea_list *ea_list)
 240 {
 241         unsigned int ret_data_size = 4;
 242         char *p = pdata;
 243
 244         SMB_ASSERT(total_data_size >= 4);
 245
 246         if (!lp_ea_support(SNUM(conn))) {
 247                 SIVAL(pdata,4,0);
 248                 return 4;
 249         }
 250
 251         for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
 252                 size_t dos_namelen;
 253                 fstring dos_ea_name;
 254                 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
 255                 dos_namelen = strlen(dos_ea_name);
 256                 if (dos_namelen > 255 || dos_namelen == 0) {
 257                         break;
 258                 }
 259                 if (ea_list->ea.value.length > 65535) {
 260                         break;
 261                 }
 262                 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
 263                         break;
 264                 }
 265
 266                 /* We know we have room. */
 267                 SCVAL(p,0,ea_list->ea.flags);
 268                 SCVAL(p,1,dos_namelen);
 269                 SSVAL(p,2,ea_list->ea.value.length);
 270                 fstrcpy(p+4, dos_ea_name);
 271                 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
 272
 273                 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
 274                 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
 275         }
 276
 277         ret_data_size = PTR_DIFF(p, pdata);
 278         DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
 279         SIVAL(pdata,0,ret_data_size);
 280         return ret_data_size;
 281 }
 282
 283 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
 284 {
 285         size_t total_ea_len = 0;
 286         TALLOC_CTX *mem_ctx = NULL;
 287
 288         if (!lp_ea_support(SNUM(conn))) {
 289                 return 0;
 290         }
 291         mem_ctx = talloc_init("estimate_ea_size");
 292         (void)get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
 293         talloc_destroy(mem_ctx);
 294         return total_ea_len;
 295 }
 296
 297 /****************************************************************************
 298  Ensure the EA name is case insensitive by matching any existing EA name.
 299 ****************************************************************************/
 300
 301 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
 302 {
 303         size_t total_ea_len;
 304         TALLOC_CTX *mem_ctx = talloc_init("canonicalize_ea_name");
 305         struct ea_list *ea_list = get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
 306
 307         for (; ea_list; ea_list = ea_list->next) {
 308                 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
 309                         DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
 310                                 &unix_ea_name[5], ea_list->ea.name));
 311                         safe_strcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-6);
 312                         break;
 313                 }
 314         }
 315         talloc_destroy(mem_ctx);
 316 }
 317
 318 /****************************************************************************
 319  Set or delete an extended attribute.
 320 ****************************************************************************/
 321
 322 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp, const char *fname, struct ea_list *ea_list)
 323 {
 324         if (!lp_ea_support(SNUM(conn))) {
 325                 return NT_STATUS_EAS_NOT_SUPPORTED;
 326         }
 327
 328         for (;ea_list; ea_list = ea_list->next) {
 329                 int ret;
 330                 fstring unix_ea_name;
 331
 332                 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
 333                 fstrcat(unix_ea_name, ea_list->ea.name);
 334
 335                 canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
 336
 337                 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
 338
 339                 if (samba_private_attr_name(unix_ea_name)) {
 340                         DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
 341                         return NT_STATUS_ACCESS_DENIED;
 342                 }
 343
 344                 if (ea_list->ea.value.length == 0) {
 345                         /* Remove the attribute. */
 346                         if (fsp && (fsp->fh->fd != -1)) {
 347                                 DEBUG(10,("set_ea: deleting ea name %s on file %s by file descriptor.\n",
 348                                         unix_ea_name, fsp->fsp_name));
 349                                 ret = SMB_VFS_FREMOVEXATTR(fsp, fsp->fh->fd, unix_ea_name);
 350                         } else {
 351                                 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
 352                                         unix_ea_name, fname));
 353                                 ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
 354                         }
 355 #ifdef ENOATTR
 356                         /* Removing a non existent attribute always succeeds. */
 357                         if (ret == -1 && errno == ENOATTR) {
 358                                 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
 359                                                 unix_ea_name));
 360                                 ret = 0;
 361                         }
 362 #endif
 363                 } else {
 364                         if (fsp && (fsp->fh->fd != -1)) {
 365                                 DEBUG(10,("set_ea: setting ea name %s on file %s by file descriptor.\n",
 366                                         unix_ea_name, fsp->fsp_name));
 367                                 ret = SMB_VFS_FSETXATTR(fsp, fsp->fh->fd, unix_ea_name,
 368                                                         ea_list->ea.value.data, ea_list->ea.value.length, 0);
 369                         } else {
 370                                 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
 371                                         unix_ea_name, fname));
 372                                 ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name,
 373                                                         ea_list->ea.value.data, ea_list->ea.value.length, 0);
 374                         }
 375                 }
 376
 377                 if (ret == -1) {
 378 #ifdef ENOTSUP
 379                         if (errno == ENOTSUP) {
 380                                 return NT_STATUS_EAS_NOT_SUPPORTED;
 381                         }
 382 #endif
 383                         return map_nt_error_from_unix(errno);
 384                 }
 385
 386         }
 387         return NT_STATUS_OK;
 388 }
 389 /****************************************************************************
 390  Read a list of EA names from an incoming data buffer. Create an ea_list with them.
 391 ****************************************************************************/
 392
 393 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
 394 {
 395         struct ea_list *ea_list_head = NULL;
 396         size_t offset = 0;
 397
 398         while (offset + 2 < data_size) {
 399                 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
 400                 unsigned int namelen = CVAL(pdata,offset);
 401
 402                 offset++; /* Go past the namelen byte. */
 403
 404                 /* integer wrap paranioa. */
 405                 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
 406                                 (offset > data_size) || (namelen > data_size) ||
 407                                 (offset + namelen >= data_size)) {
 408                         break;
 409                 }
 410                 /* Ensure the name is null terminated. */
 411                 if (pdata[offset + namelen] != '\0') {
 412                         return NULL;
 413                 }
 414                 pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset]);
 415                 if (!eal->ea.name) {
 416                         return NULL;
 417                 }
 418
 419                 offset += (namelen + 1); /* Go past the name + terminating zero. */
 420                 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
 421                 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
 422         }
 423
 424         return ea_list_head;
 425 }
 426
 427 /****************************************************************************
 428  Read one EA list entry from the buffer.
 429 ****************************************************************************/
 430
 431 struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
 432 {
 433         struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
 434         uint16 val_len;
 435         unsigned int namelen;
 436
 437         if (!eal) {
 438                 return NULL;
 439         }
 440
 441         if (data_size < 6) {
 442                 return NULL;
 443         }
 444
 445         eal->ea.flags = CVAL(pdata,0);
 446         namelen = CVAL(pdata,1);
 447         val_len = SVAL(pdata,2);
 448
 449         if (4 + namelen + 1 + val_len > data_size) {
 450                 return NULL;
 451         }
 452
 453         /* Ensure the name is null terminated. */
 454         if (pdata[namelen + 4] != '\0') {
 455                 return NULL;
 456         }
 457         pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4);
 458         if (!eal->ea.name) {
 459                 return NULL;
 460         }
 461
 462         eal->ea.value = data_blob_talloc(eal, NULL, (size_t)val_len + 1);
 463         if (!eal->ea.value.data) {
 464                 return NULL;
 465         }
 466
 467         memcpy(eal->ea.value.data, pdata + 4 + namelen + 1, val_len);
 468
 469         /* Ensure we're null terminated just in case we print the value. */
 470         eal->ea.value.data[val_len] = '\0';
 471         /* But don't count the null. */
 472         eal->ea.value.length--;
 473
 474         if (pbytes_used) {
 475                 *pbytes_used = 4 + namelen + 1 + val_len;
 476         }
 477
 478         DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal->ea.name));
 479         dump_data(10, (const char *)eal->ea.value.data, eal->ea.value.length);
 480
 481         return eal;
 482 }
 483
 484 /****************************************************************************
 485  Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
 486 ****************************************************************************/
 487
 488 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
 489 {
 490         struct ea_list *ea_list_head = NULL;
 491         size_t offset = 0;
 492         size_t bytes_used = 0;
 493
 494         while (offset < data_size) {
 495                 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
 496
 497                 if (!eal) {
 498                         return NULL;
 499                 }
 500
 501                 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
 502                 offset += bytes_used;
 503         }
 504
 505         return ea_list_head;
 506 }
 507
 508 /****************************************************************************
 509  Count the total EA size needed.
 510 ****************************************************************************/
 511
 512 static size_t ea_list_size(struct ea_list *ealist)
 513 {
 514         fstring dos_ea_name;
 515         struct ea_list *listp;
 516         size_t ret = 0;
 517
 518         for (listp = ealist; listp; listp = listp->next) {
 519                 push_ascii_fstring(dos_ea_name, listp->ea.name);
 520                 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
 521         }
 522         /* Add on 4 for total length. */
 523         if (ret) {
 524                 ret += 4;
 525         }
 526
 527         return ret;
 528 }
 529
 530 /****************************************************************************
 531  Return a union of EA's from a file list and a list of names.
 532  The TALLOC context for the two lists *MUST* be identical as we steal
 533  memory from one list to add to another. JRA.
 534 ****************************************************************************/
 535
 536 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
 537 {
 538         struct ea_list *nlistp, *flistp;
 539
 540         for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
 541                 for (flistp = file_list; flistp; flistp = flistp->next) {
 542                         if (strequal(nlistp->ea.name, flistp->ea.name)) {
 543                                 break;
 544                         }
 545                 }
 546
 547                 if (flistp) {
 548                         /* Copy the data from this entry. */
 549                         nlistp->ea.flags = flistp->ea.flags;
 550                         nlistp->ea.value = flistp->ea.value;
 551                 } else {
 552                         /* Null entry. */
 553                         nlistp->ea.flags = 0;
 554                         ZERO_STRUCT(nlistp->ea.value);
 555                 }
 556         }
 557
 558         *total_ea_len = ea_list_size(name_list);
 559         return name_list;
 560 }
 561
 562 /****************************************************************************
 563   Send the required number of replies back.
 564   We assume all fields other than the data fields are
 565   set correctly for the type of call.
 566   HACK ! Always assumes smb_setup field is zero.
 567 ****************************************************************************/
 568
 569 int send_trans2_replies(char *outbuf,
 570                         int bufsize,
 571                         const char *params,
 572                         int paramsize,
 573                         const char *pdata,
 574                         int datasize,
 575                         int max_data_bytes)
 576 {
 577         /* As we are using a protocol > LANMAN1 then the max_send
 578          variable must have been set in the sessetupX call.
 579          This takes precedence over the max_xmit field in the
 580          global struct. These different max_xmit variables should
 581          be merged as this is now too confusing */
 582
 583         int data_to_send = datasize;
 584         int params_to_send = paramsize;
 585         int useable_space;
 586         const char *pp = params;
 587         const char *pd = pdata;
 588         int params_sent_thistime, data_sent_thistime, total_sent_thistime;
 589         int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
 590         int data_alignment_offset = 0;
 591
 592         /* Initially set the wcnt area to be 10 - this is true for all trans2 replies */
 593
 594         set_message(outbuf,10,0,True);
 595
 596         /* Modify the data_to_send and datasize and set the error if
 597            we're trying to send more than max_data_bytes. We still send
 598            the part of the packet(s) that fit. Strange, but needed
 599            for OS/2. */
 600
 601         if (max_data_bytes > 0 && datasize > max_data_bytes) {
 602                 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
 603                         max_data_bytes, datasize ));
 604                 datasize = data_to_send = max_data_bytes;
 605                 error_packet_set(outbuf,ERRDOS,ERRbufferoverflow,STATUS_BUFFER_OVERFLOW,__LINE__,__FILE__);
 606         }
 607
 608         /* If there genuinely are no parameters or data to send just send the empty packet */
 609
 610         if(params_to_send == 0 && data_to_send == 0) {
 611                 show_msg(outbuf);
 612                 if (!send_smb(smbd_server_fd(),outbuf))
 613                         exit_server_cleanly("send_trans2_replies: send_smb failed.");
 614                 return 0;
 615         }
 616
 617         /* When sending params and data ensure that both are nicely aligned */
 618         /* Only do this alignment when there is also data to send - else
 619                 can cause NT redirector problems. */
 620
 621         if (((params_to_send % 4) != 0) && (data_to_send != 0))
 622                 data_alignment_offset = 4 - (params_to_send % 4);
 623
 624         /* Space is bufsize minus Netbios over TCP header minus SMB header */
 625         /* The alignment_offset is to align the param bytes on an even byte
 626                 boundary. NT 4.0 Beta needs this to work correctly. */
 627
 628         useable_space = bufsize - ((smb_buf(outbuf)+ alignment_offset+data_alignment_offset) - outbuf);
 629
 630         /* useable_space can never be more than max_send minus the alignment offset. */
 631
 632         useable_space = MIN(useable_space, max_send - (alignment_offset+data_alignment_offset));
 633
 634         while (params_to_send || data_to_send) {
 635                 /* Calculate whether we will totally or partially fill this packet */
 636
 637                 total_sent_thistime = params_to_send + data_to_send + alignment_offset + data_alignment_offset;
 638
 639                 /* We can never send more than useable_space */
 640                 /*
 641                  * Note that 'useable_space' does not include the alignment offsets,
 642                  * but we must include the alignment offsets in the calculation of
 643                  * the length of the data we send over the wire, as the alignment offsets
 644                  * are sent here. Fix from Marc_Jacobsen@hp.com.
 645                  */
 646
 647                 total_sent_thistime = MIN(total_sent_thistime, useable_space+ alignment_offset + data_alignment_offset);
 648
 649                 set_message(outbuf, 10, total_sent_thistime, True);
 650
 651                 /* Set total params and data to be sent */
 652                 SSVAL(outbuf,smb_tprcnt,paramsize);
 653                 SSVAL(outbuf,smb_tdrcnt,datasize);
 654
 655                 /* Calculate how many parameters and data we can fit into
 656                  * this packet. Parameters get precedence
 657                  */
 658
 659                 params_sent_thistime = MIN(params_to_send,useable_space);
 660                 data_sent_thistime = useable_space - params_sent_thistime;
 661                 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
 662
 663                 SSVAL(outbuf,smb_prcnt, params_sent_thistime);
 664
 665                 /* smb_proff is the offset from the start of the SMB header to the
 666                         parameter bytes, however the first 4 bytes of outbuf are
 667                         the Netbios over TCP header. Thus use smb_base() to subtract
 668                         them from the calculation */
 669
 670                 SSVAL(outbuf,smb_proff,((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
 671
 672                 if(params_sent_thistime == 0)
 673                         SSVAL(outbuf,smb_prdisp,0);
 674                 else
 675                         /* Absolute displacement of param bytes sent in this packet */
 676                         SSVAL(outbuf,smb_prdisp,pp - params);
 677
 678                 SSVAL(outbuf,smb_drcnt, data_sent_thistime);
 679                 if(data_sent_thistime == 0) {
 680                         SSVAL(outbuf,smb_droff,0);
 681                         SSVAL(outbuf,smb_drdisp, 0);
 682                 } else {
 683                         /* The offset of the data bytes is the offset of the
 684                                 parameter bytes plus the number of parameters being sent this time */
 685                         SSVAL(outbuf,smb_droff,((smb_buf(outbuf)+alignment_offset) -
 686                                 smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
 687                         SSVAL(outbuf,smb_drdisp, pd - pdata);
 688                 }
 689
 690                 /* Copy the param bytes into the packet */
 691
 692                 if(params_sent_thistime)
 693                         memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
 694
 695                 /* Copy in the data bytes */
 696                 if(data_sent_thistime)
 697                         memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
 698                                 data_alignment_offset,pd,data_sent_thistime);
 699
 700                 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
 701                         params_sent_thistime, data_sent_thistime, useable_space));
 702                 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
 703                         params_to_send, data_to_send, paramsize, datasize));
 704
 705                 /* Send the packet */
 706                 show_msg(outbuf);
 707                 if (!send_smb(smbd_server_fd(),outbuf))
 708                         exit_server_cleanly("send_trans2_replies: send_smb failed.");
 709
 710                 pp += params_sent_thistime;
 711                 pd += data_sent_thistime;
 712
 713                 params_to_send -= params_sent_thistime;
 714                 data_to_send -= data_sent_thistime;
 715
 716                 /* Sanity check */
 717                 if(params_to_send < 0 || data_to_send < 0) {
 718                         DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
 719                                 params_to_send, data_to_send));
 720                         return -1;
 721                 }
 722         }
 723
 724         return 0;
 725 }
 726
 727 /****************************************************************************
 728  Reply to a TRANSACT2_OPEN.
 729 ****************************************************************************/
 730
 731 static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
 732                                 char **pparams, int total_params, char **ppdata, int total_data,
 733                                 unsigned int max_data_bytes)
 734 {
 735         char *params = *pparams;
 736         char *pdata = *ppdata;
 737         int deny_mode;
 738         int32 open_attr;
 739         BOOL oplock_request;
 740 #if 0
 741         BOOL return_additional_info;
 742         int16 open_sattr;
 743         time_t open_time;
 744 #endif
 745         int open_ofun;
 746         uint32 open_size;
 747         char *pname;
 748         pstring fname;
 749         SMB_OFF_T size=0;
 750         int fattr=0,mtime=0;
 751         SMB_INO_T inode = 0;
 752         SMB_STRUCT_STAT sbuf;
 753         int smb_action = 0;
 754         files_struct *fsp;
 755         struct ea_list *ea_list = NULL;
 756         uint16 flags = 0;
 757         NTSTATUS status;
 758         uint32 access_mask;
 759         uint32 share_mode;
 760         uint32 create_disposition;
 761         uint32 create_options = 0;
 762
 763         /*
 764          * Ensure we have enough parameters to perform the operation.
 765          */
 766
 767         if (total_params < 29) {
 768                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 769         }
 770
 771         flags = SVAL(params, 0);
 772         deny_mode = SVAL(params, 2);
 773         open_attr = SVAL(params,6);
 774         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
 775         if (oplock_request) {
 776                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
 777         }
 778
 779 #if 0
 780         return_additional_info = BITSETW(params,0);
 781         open_sattr = SVAL(params, 4);
 782         open_time = make_unix_date3(params+8);
 783 #endif
 784         open_ofun = SVAL(params,12);
 785         open_size = IVAL(params,14);
 786         pname = &params[28];
 787
 788         if (IS_IPC(conn)) {
 789                 return(ERROR_DOS(ERRSRV,ERRaccess));
 790         }
 791
 792         srvstr_get_path(inbuf, fname, pname, sizeof(fname), total_params - 28, STR_TERMINATE, &status);
 793         if (!NT_STATUS_IS_OK(status)) {
 794                 return ERROR_NT(status);
 795         }
 796
 797         DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
 798                 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
 799                 (unsigned int)open_ofun, open_size));
 800
 801         /* XXXX we need to handle passed times, sattr and flags */
 802
 803         status = unix_convert(conn, fname, False, NULL, &sbuf);
 804         if (!NT_STATUS_IS_OK(status)) {
 805                 return ERROR_NT(status);
 806         }
 807
 808         status = check_name(conn, fname);
 809         if (!NT_STATUS_IS_OK(status)) {
 810                 return ERROR_NT(status);
 811         }
 812
 813         if (open_ofun == 0) {
 814                 return ERROR_NT(NT_STATUS_OBJECT_NAME_COLLISION);
 815         }
 816
 817         if (!map_open_params_to_ntcreate(fname, deny_mode, open_ofun,
 818                                 &access_mask,
 819                                 &share_mode,
 820                                 &create_disposition,
 821                                 &create_options)) {
 822                 return ERROR_DOS(ERRDOS, ERRbadaccess);
 823         }
 824
 825         /* Any data in this call is an EA list. */
 826         if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
 827                 return ERROR_NT(NT_STATUS_EAS_NOT_SUPPORTED);
 828         }
 829
 830         if (total_data != 4) {
 831                 if (total_data < 10) {
 832                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 833                 }
 834
 835                 if (IVAL(pdata,0) > total_data) {
 836                         DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
 837                                 IVAL(pdata,0), (unsigned int)total_data));
 838                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 839                 }
 840
 841                 ea_list = read_ea_list(tmp_talloc_ctx(), pdata + 4,
 842                                        total_data - 4);
 843                 if (!ea_list) {
 844                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 845                 }
 846         } else if (IVAL(pdata,0) != 4) {
 847                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
 848         }
 849
 850         status = open_file_ntcreate(conn,fname,&sbuf,
 851                 access_mask,
 852                 share_mode,
 853                 create_disposition,
 854                 create_options,
 855                 open_attr,
 856                 oplock_request,
 857                 &smb_action, &fsp);
 858
 859         if (!NT_STATUS_IS_OK(status)) {
 860                 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
 861                         /* We have re-scheduled this call. */
 862                         return -1;
 863                 }
 864                 return ERROR_NT(status);
 865         }
 866
 867         size = get_file_size(sbuf);
 868         fattr = dos_mode(conn,fname,&sbuf);
 869         mtime = sbuf.st_mtime;
 870         inode = sbuf.st_ino;
 871         if (fattr & aDIR) {
 872                 close_file(fsp,ERROR_CLOSE);
 873                 return(ERROR_DOS(ERRDOS,ERRnoaccess));
 874         }
 875
 876         /* Save the requested allocation size. */
 877         /* Allocate space for the file if a size hint is supplied */
 878         if ((smb_action == FILE_WAS_CREATED) || (smb_action == FILE_WAS_OVERWRITTEN)) {
 879                 SMB_BIG_UINT allocation_size = (SMB_BIG_UINT)open_size;
 880                 if (allocation_size && (allocation_size > (SMB_BIG_UINT)size)) {
 881                         fsp->initial_allocation_size = smb_roundup(fsp->conn, allocation_size);
 882                         if (fsp->is_directory) {
 883                                 close_file(fsp,ERROR_CLOSE);
 884                                 /* Can't set allocation size on a directory. */
 885                                 return ERROR_NT(NT_STATUS_ACCESS_DENIED);
 886                         }
 887                         if (vfs_allocate_file_space(fsp, fsp->initial_allocation_size) == -1) {
 888                                 close_file(fsp,ERROR_CLOSE);
 889                                 return ERROR_NT(NT_STATUS_DISK_FULL);
 890                         }
 891
 892                         /* Adjust size here to return the right size in the reply.
 893                            Windows does it this way. */
 894                         size = fsp->initial_allocation_size;
 895                 } else {
 896                         fsp->initial_allocation_size = smb_roundup(fsp->conn,(SMB_BIG_UINT)size);
 897                 }
 898         }
 899
 900         if (ea_list && smb_action == FILE_WAS_CREATED) {
 901                 status = set_ea(conn, fsp, fname, ea_list);
 902                 if (!NT_STATUS_IS_OK(status)) {
 903                         close_file(fsp,ERROR_CLOSE);
 904                         return ERROR_NT(status);
 905                 }
 906         }
 907
 908         /* Realloc the size of parameters and data we will return */
 909         *pparams = (char *)SMB_REALLOC(*pparams, 30);
 910         if(*pparams == NULL ) {
 911                 return ERROR_NT(NT_STATUS_NO_MEMORY);
 912         }
 913         params = *pparams;
 914
 915         SSVAL(params,0,fsp->fnum);
 916         SSVAL(params,2,fattr);
 917         srv_put_dos_date2(params,4, mtime);
 918         SIVAL(params,8, (uint32)size);
 919         SSVAL(params,12,deny_mode);
 920         SSVAL(params,14,0); /* open_type - file or directory. */
 921         SSVAL(params,16,0); /* open_state - only valid for IPC device. */
 922
 923         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
 924                 smb_action |= EXTENDED_OPLOCK_GRANTED;
 925         }
 926
 927         SSVAL(params,18,smb_action);
 928
 929         /*
 930          * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
 931          */
 932         SIVAL(params,20,inode);
 933         SSVAL(params,24,0); /* Padding. */
 934         if (flags & 8) {
 935                 uint32 ea_size = estimate_ea_size(conn, fsp, fname);
 936                 SIVAL(params, 26, ea_size);
 937         } else {
 938                 SIVAL(params, 26, 0);
 939         }
 940
 941         /* Send the required number of replies */
 942         send_trans2_replies(outbuf, bufsize, params, 30, *ppdata, 0, max_data_bytes);
 943
 944         return -1;
 945 }
 946
 947 /*********************************************************
 948  Routine to check if a given string matches exactly.
 949  as a special case a mask of "." does NOT match. That
 950  is required for correct wildcard semantics
 951  Case can be significant or not.
 952 **********************************************************/
 953
 954 static BOOL exact_match(connection_struct *conn, char *str, char *mask)
 955 {
 956         if (mask[0] == '.' && mask[1] == 0)
 957                 return False;
 958         if (conn->case_sensitive)
 959                 return strcmp(str,mask)==0;
 960         if (StrCaseCmp(str,mask) != 0) {
 961                 return False;
 962         }
 963         if (dptr_has_wild(conn->dirptr)) {
 964                 return False;
 965         }
 966         return True;
 967 }
 968
 969 /****************************************************************************
 970  Return the filetype for UNIX extensions.
 971 ****************************************************************************/
 972
 973 static uint32 unix_filetype(mode_t mode)
 974 {
 975         if(S_ISREG(mode))
 976                 return UNIX_TYPE_FILE;
 977         else if(S_ISDIR(mode))
 978                 return UNIX_TYPE_DIR;
 979 #ifdef S_ISLNK
 980         else if(S_ISLNK(mode))
 981                 return UNIX_TYPE_SYMLINK;
 982 #endif
 983 #ifdef S_ISCHR
 984         else if(S_ISCHR(mode))
 985                 return UNIX_TYPE_CHARDEV;
 986 #endif
 987 #ifdef S_ISBLK
 988         else if(S_ISBLK(mode))
 989                 return UNIX_TYPE_BLKDEV;
 990 #endif
 991 #ifdef S_ISFIFO
 992         else if(S_ISFIFO(mode))
 993                 return UNIX_TYPE_FIFO;
 994 #endif
 995 #ifdef S_ISSOCK
 996         else if(S_ISSOCK(mode))
 997                 return UNIX_TYPE_SOCKET;
 998 #endif
 999
1000         DEBUG(0,("unix_filetype: unknown filetype %u", (unsigned)mode));
1001         return UNIX_TYPE_UNKNOWN;
1002 }
1003
1004 /****************************************************************************
1005  Map wire perms onto standard UNIX permissions. Obey share restrictions.
1006 ****************************************************************************/
1007
1008 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1009
1010 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1011                                 SMB_STRUCT_STAT *psbuf,
1012                                 uint32 perms,
1013                                 enum perm_type ptype,
1014                                 mode_t *ret_perms)
1015 {
1016         mode_t ret = 0;
1017
1018         if (perms == SMB_MODE_NO_CHANGE) {
1019                 if (!VALID_STAT(*psbuf)) {
1020                         return NT_STATUS_INVALID_PARAMETER;
1021                 } else {
1022                         *ret_perms = psbuf->st_mode;
1023                         return NT_STATUS_OK;
1024                 }
1025         }
1026
1027         ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1028         ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1029         ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1030         ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1031         ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1032         ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1033         ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1034         ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1035         ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1036 #ifdef S_ISVTX
1037         ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1038 #endif
1039 #ifdef S_ISGID
1040         ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1041 #endif
1042 #ifdef S_ISUID
1043         ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1044 #endif
1045
1046         switch (ptype) {
1047         case PERM_NEW_FILE:
1048                 /* Apply mode mask */
1049                 ret &= lp_create_mask(SNUM(conn));
1050                 /* Add in force bits */
1051                 ret |= lp_force_create_mode(SNUM(conn));
1052                 break;
1053         case PERM_NEW_DIR:
1054                 ret &= lp_dir_mask(SNUM(conn));
1055                 /* Add in force bits */
1056                 ret |= lp_force_dir_mode(SNUM(conn));
1057                 break;
1058         case PERM_EXISTING_FILE:
1059                 /* Apply mode mask */
1060                 ret &= lp_security_mask(SNUM(conn));
1061                 /* Add in force bits */
1062                 ret |= lp_force_security_mode(SNUM(conn));
1063                 break;
1064         case PERM_EXISTING_DIR:
1065                 /* Apply mode mask */
1066                 ret &= lp_dir_security_mask(SNUM(conn));
1067                 /* Add in force bits */
1068                 ret |= lp_force_dir_security_mode(SNUM(conn));
1069                 break;
1070         }
1071
1072         *ret_perms = ret;
1073         return NT_STATUS_OK;
1074 }
1075
1076 /****************************************************************************
1077  Get a level dependent lanman2 dir entry.
1078 ****************************************************************************/
1079
1080 static BOOL get_lanman2_dir_entry(connection_struct *conn,
1081                                   void *inbuf, char *outbuf,
1082                                  char *path_mask,uint32 dirtype,int info_level,
1083                                  int requires_resume_key,
1084                                  BOOL dont_descend,char **ppdata,
1085                                  char *base_data, int space_remaining,
1086                                  BOOL *out_of_space, BOOL *got_exact_match,
1087                                  int *last_entry_off, struct ea_list *name_list, TALLOC_CTX *ea_ctx)
1088 {
1089         const char *dname;
1090         BOOL found = False;
1091         SMB_STRUCT_STAT sbuf;
1092         pstring mask;
1093         pstring pathreal;
1094         pstring fname;
1095         char *p, *q, *pdata = *ppdata;
1096         uint32 reskey=0;
1097         long prev_dirpos=0;
1098         uint32 mode=0;
1099         SMB_OFF_T file_size = 0;
1100         SMB_BIG_UINT allocation_size = 0;
1101         uint32 len;
1102         struct timespec mdate_ts, adate_ts, create_date_ts;
1103         time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1104         char *nameptr;
1105         char *last_entry_ptr;
1106         BOOL was_8_3;
1107         uint32 nt_extmode; /* Used for NT connections instead of mode */
1108         BOOL needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
1109         BOOL check_mangled_names = lp_manglednames(conn->params);
1110
1111         *fname = 0;
1112         *out_of_space = False;
1113         *got_exact_match = False;
1114
1115         ZERO_STRUCT(mdate_ts);
1116         ZERO_STRUCT(adate_ts);
1117         ZERO_STRUCT(create_date_ts);
1118
1119         if (!conn->dirptr)
1120                 return(False);
1121
1122         p = strrchr_m(path_mask,'/');
1123         if(p != NULL) {
1124                 if(p[1] == '\0')
1125                         pstrcpy(mask,"*.*");
1126                 else
1127                         pstrcpy(mask, p+1);
1128         } else
1129                 pstrcpy(mask, path_mask);
1130
1131
1132         while (!found) {
1133                 BOOL got_match;
1134                 BOOL ms_dfs_link = False;
1135
1136                 /* Needed if we run out of space */
1137                 long curr_dirpos = prev_dirpos = dptr_TellDir(conn->dirptr);
1138                 dname = dptr_ReadDirName(conn->dirptr,&curr_dirpos,&sbuf);
1139
1140                 /*
1141                  * Due to bugs in NT client redirectors we are not using
1142                  * resume keys any more - set them to zero.
1143                  * Check out the related comments in findfirst/findnext.
1144                  * JRA.
1145                  */
1146
1147                 reskey = 0;
1148
1149                 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %ld\n",
1150                         (long)conn->dirptr,curr_dirpos));
1151
1152                 if (!dname)
1153                         return(False);
1154
1155                 pstrcpy(fname,dname);
1156
1157                 if(!(got_match = *got_exact_match = exact_match(conn, fname, mask)))
1158                         got_match = mask_match(fname, mask, conn->case_sensitive);
1159
1160                 if(!got_match && check_mangled_names &&
1161                    !mangle_is_8_3(fname, False, conn->params)) {
1162
1163                         /*
1164                          * It turns out that NT matches wildcards against
1165                          * both long *and* short names. This may explain some
1166                          * of the wildcard wierdness from old DOS clients
1167                          * that some people have been seeing.... JRA.
1168                          */
1169
1170                         pstring newname;
1171                         pstrcpy( newname, fname);
1172                         mangle_map( newname, True, False, conn->params);
1173                         if(!(got_match = *got_exact_match = exact_match(conn, newname, mask)))
1174                                 got_match = mask_match(newname, mask, conn->case_sensitive);
1175                 }
1176
1177                 if(got_match) {
1178                         BOOL isdots = (strequal(fname,"..") || strequal(fname,"."));
1179                         if (dont_descend && !isdots)
1180                                 continue;
1181
1182                         pstrcpy(pathreal,conn->dirpath);
1183                         if(needslash)
1184                                 pstrcat(pathreal,"/");
1185                         pstrcat(pathreal,dname);
1186
1187                         if (INFO_LEVEL_IS_UNIX(info_level)) {
1188                                 if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
1189                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
1190                                                 pathreal,strerror(errno)));
1191                                         continue;
1192                                 }
1193                         } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
1194
1195                                 /* Needed to show the msdfs symlinks as
1196                                  * directories */
1197
1198                                 if(lp_host_msdfs() &&
1199                                    lp_msdfs_root(SNUM(conn)) &&
1200                                    ((ms_dfs_link = is_msdfs_link(NULL,conn, pathreal, NULL, NULL, &sbuf)) == True)) {
1201
1202                                         DEBUG(5,("get_lanman2_dir_entry: Masquerading msdfs link %s as a directory\n", pathreal));
1203                                         sbuf.st_mode = (sbuf.st_mode & 0xFFF) | S_IFDIR;
1204
1205                                 } else {
1206
1207                                         DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
1208                                                 pathreal,strerror(errno)));
1209                                         continue;
1210                                 }
1211                         }
1212
1213                         if (ms_dfs_link) {
1214                                 mode = dos_mode_msdfs(conn,pathreal,&sbuf);
1215                         } else {
1216                                 mode = dos_mode(conn,pathreal,&sbuf);
1217                         }
1218
1219                         if (!dir_check_ftype(conn,mode,dirtype)) {
1220                                 DEBUG(5,("[%s] attribs didn't match %x\n",fname,dirtype));
1221                                 continue;
1222                         }
1223
1224                         if (!(mode & aDIR))
1225                                 file_size = get_file_size(sbuf);
1226                         allocation_size = get_allocation_size(conn,NULL,&sbuf);
1227
1228                         mdate_ts = get_mtimespec(&sbuf);
1229                         adate_ts = get_atimespec(&sbuf);
1230                         create_date_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
1231
1232                         if (lp_dos_filetime_resolution(SNUM(conn))) {
1233                                 dos_filetime_timespec(&create_date_ts);
1234                                 dos_filetime_timespec(&mdate_ts);
1235                                 dos_filetime_timespec(&adate_ts);
1236                         }
1237
1238                         create_date = convert_timespec_to_time_t(create_date_ts);
1239                         mdate = convert_timespec_to_time_t(mdate_ts);
1240                         adate = convert_timespec_to_time_t(adate_ts);
1241
1242                         DEBUG(5,("get_lanman2_dir_entry found %s fname=%s\n",pathreal,fname));
1243
1244                         found = True;
1245
1246                         dptr_DirCacheAdd(conn->dirptr, dname, curr_dirpos);
1247                 }
1248         }
1249
1250         mangle_map(fname,False,True,conn->params);
1251
1252         p = pdata;
1253         last_entry_ptr = p;
1254
1255         nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
1256
1257         switch (info_level) {
1258                 case SMB_FIND_INFO_STANDARD:
1259                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1260                         if(requires_resume_key) {
1261                                 SIVAL(p,0,reskey);
1262                                 p += 4;
1263                         }
1264                         srv_put_dos_date2(p,0,create_date);
1265                         srv_put_dos_date2(p,4,adate);
1266                         srv_put_dos_date2(p,8,mdate);
1267                         SIVAL(p,12,(uint32)file_size);
1268                         SIVAL(p,16,(uint32)allocation_size);
1269                         SSVAL(p,20,mode);
1270                         p += 23;
1271                         nameptr = p;
1272                         p += align_string(outbuf, p, 0);
1273                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1274                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1275                                 if (len > 2) {
1276                                         SCVAL(nameptr, -1, len - 2);
1277                                 } else {
1278                                         SCVAL(nameptr, -1, 0);
1279                                 }
1280                         } else {
1281                                 if (len > 1) {
1282                                         SCVAL(nameptr, -1, len - 1);
1283                                 } else {
1284                                         SCVAL(nameptr, -1, 0);
1285                                 }
1286                         }
1287                         p += len;
1288                         break;
1289
1290                 case SMB_FIND_EA_SIZE:
1291                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_SIZE\n"));
1292                         if(requires_resume_key) {
1293                                 SIVAL(p,0,reskey);
1294                                 p += 4;
1295                         }
1296                         srv_put_dos_date2(p,0,create_date);
1297                         srv_put_dos_date2(p,4,adate);
1298                         srv_put_dos_date2(p,8,mdate);
1299                         SIVAL(p,12,(uint32)file_size);
1300                         SIVAL(p,16,(uint32)allocation_size);
1301                         SSVAL(p,20,mode);
1302                         {
1303                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1304                                 SIVAL(p,22,ea_size); /* Extended attributes */
1305                         }
1306                         p += 27;
1307                         nameptr = p - 1;
1308                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE | STR_NOALIGN);
1309                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1310                                 if (len > 2) {
1311                                         len -= 2;
1312                                 } else {
1313                                         len = 0;
1314                                 }
1315                         } else {
1316                                 if (len > 1) {
1317                                         len -= 1;
1318                                 } else {
1319                                         len = 0;
1320                                 }
1321                         }
1322                         SCVAL(nameptr,0,len);
1323                         p += len;
1324                         SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1325                         break;
1326
1327                 case SMB_FIND_EA_LIST:
1328                 {
1329                         struct ea_list *file_list = NULL;
1330                         size_t ea_len = 0;
1331
1332                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_LIST\n"));
1333                         if (!name_list) {
1334                                 return False;
1335                         }
1336                         if(requires_resume_key) {
1337                                 SIVAL(p,0,reskey);
1338                                 p += 4;
1339                         }
1340                         srv_put_dos_date2(p,0,create_date);
1341                         srv_put_dos_date2(p,4,adate);
1342                         srv_put_dos_date2(p,8,mdate);
1343                         SIVAL(p,12,(uint32)file_size);
1344                         SIVAL(p,16,(uint32)allocation_size);
1345                         SSVAL(p,20,mode);
1346                         p += 22; /* p now points to the EA area. */
1347
1348                         file_list = get_ea_list_from_file(ea_ctx, conn, NULL, pathreal, &ea_len);
1349                         name_list = ea_list_union(name_list, file_list, &ea_len);
1350
1351                         /* We need to determine if this entry will fit in the space available. */
1352                         /* Max string size is 255 bytes. */
1353                         if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1354                                 /* Move the dirptr back to prev_dirpos */
1355                                 dptr_SeekDir(conn->dirptr, prev_dirpos);
1356                                 *out_of_space = True;
1357                                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1358                                 return False; /* Not finished - just out of space */
1359                         }
1360
1361                         /* Push the ea_data followed by the name. */
1362                         p += fill_ea_buffer(ea_ctx, p, space_remaining, conn, name_list);
1363                         nameptr = p;
1364                         len = srvstr_push(outbuf, p + 1, fname, -1, STR_TERMINATE | STR_NOALIGN);
1365                         if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1366                                 if (len > 2) {
1367                                         len -= 2;
1368                                 } else {
1369                                         len = 0;
1370                                 }
1371                         } else {
1372                                 if (len > 1) {
1373                                         len -= 1;
1374                                 } else {
1375                                         len = 0;
1376                                 }
1377                         }
1378                         SCVAL(nameptr,0,len);
1379                         p += len + 1;
1380                         SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1381                         break;
1382                 }
1383
1384                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1385                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1386                         was_8_3 = mangle_is_8_3(fname, True, conn->params);
1387                         p += 4;
1388                         SIVAL(p,0,reskey); p += 4;
1389                         put_long_date_timespec(p,create_date_ts); p += 8;
1390                         put_long_date_timespec(p,adate_ts); p += 8;
1391                         put_long_date_timespec(p,mdate_ts); p += 8;
1392                         put_long_date_timespec(p,mdate_ts); p += 8;
1393                         SOFF_T(p,0,file_size); p += 8;
1394                         SOFF_T(p,0,allocation_size); p += 8;
1395                         SIVAL(p,0,nt_extmode); p += 4;
1396                         q = p; p += 4; /* q is placeholder for name length. */
1397                         {
1398                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1399                                 SIVAL(p,0,ea_size); /* Extended attributes */
1400                                 p += 4;
1401                         }
1402                         /* Clear the short name buffer. This is
1403                          * IMPORTANT as not doing so will trigger
1404                          * a Win2k client bug. JRA.
1405                          */
1406                         if (!was_8_3 && check_mangled_names) {
1407                                 pstring mangled_name;
1408                                 pstrcpy(mangled_name, fname);
1409                                 mangle_map(mangled_name,True,True,
1410                                            conn->params);
1411                                 mangled_name[12] = 0;
1412                                 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1413                                 if (len < 24) {
1414                                         memset(p + 2 + len,'\0',24 - len);
1415                                 }
1416                                 SSVAL(p, 0, len);
1417                         } else {
1418                                 memset(p,'\0',26);
1419                         }
1420                         p += 2 + 24;
1421                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1422                         SIVAL(q,0,len);
1423                         p += len;
1424                         SIVAL(p,0,0); /* Ensure any padding is null. */
1425                         len = PTR_DIFF(p, pdata);
1426                         len = (len + 3) & ~3;
1427                         SIVAL(pdata,0,len);
1428                         p = pdata + len;
1429                         break;
1430
1431                 case SMB_FIND_FILE_DIRECTORY_INFO:
1432                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1433                         p += 4;
1434                         SIVAL(p,0,reskey); p += 4;
1435                         put_long_date_timespec(p,create_date_ts); p += 8;
1436                         put_long_date_timespec(p,adate_ts); p += 8;
1437                         put_long_date_timespec(p,mdate_ts); p += 8;
1438                         put_long_date_timespec(p,mdate_ts); p += 8;
1439                         SOFF_T(p,0,file_size); p += 8;
1440                         SOFF_T(p,0,allocation_size); p += 8;
1441                         SIVAL(p,0,nt_extmode); p += 4;
1442                         len = srvstr_push(outbuf, p + 4, fname, -1, STR_TERMINATE_ASCII);
1443                         SIVAL(p,0,len);
1444                         p += 4 + len;
1445                         SIVAL(p,0,0); /* Ensure any padding is null. */
1446                         len = PTR_DIFF(p, pdata);
1447                         len = (len + 3) & ~3;
1448                         SIVAL(pdata,0,len);
1449                         p = pdata + len;
1450                         break;
1451
1452                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1453                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1454                         p += 4;
1455                         SIVAL(p,0,reskey); p += 4;
1456                         put_long_date_timespec(p,create_date_ts); p += 8;
1457                         put_long_date_timespec(p,adate_ts); p += 8;
1458                         put_long_date_timespec(p,mdate_ts); p += 8;
1459                         put_long_date_timespec(p,mdate_ts); p += 8;
1460                         SOFF_T(p,0,file_size); p += 8;
1461                         SOFF_T(p,0,allocation_size); p += 8;
1462                         SIVAL(p,0,nt_extmode); p += 4;
1463                         q = p; p += 4; /* q is placeholder for name length. */
1464                         {
1465                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1466                                 SIVAL(p,0,ea_size); /* Extended attributes */
1467                                 p +=4;
1468                         }
1469                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1470                         SIVAL(q, 0, len);
1471                         p += len;
1472
1473                         SIVAL(p,0,0); /* Ensure any padding is null. */
1474                         len = PTR_DIFF(p, pdata);
1475                         len = (len + 3) & ~3;
1476                         SIVAL(pdata,0,len);
1477                         p = pdata + len;
1478                         break;
1479
1480                 case SMB_FIND_FILE_NAMES_INFO:
1481                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1482                         p += 4;
1483                         SIVAL(p,0,reskey); p += 4;
1484                         p += 4;
1485                         /* this must *not* be null terminated or w2k gets in a loop trying to set an
1486                            acl on a dir (tridge) */
1487                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1488                         SIVAL(p, -4, len);
1489                         p += len;
1490                         SIVAL(p,0,0); /* Ensure any padding is null. */
1491                         len = PTR_DIFF(p, pdata);
1492                         len = (len + 3) & ~3;
1493                         SIVAL(pdata,0,len);
1494                         p = pdata + len;
1495                         break;
1496
1497                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1498                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1499                         p += 4;
1500                         SIVAL(p,0,reskey); p += 4;
1501                         put_long_date_timespec(p,create_date_ts); p += 8;
1502                         put_long_date_timespec(p,adate_ts); p += 8;
1503                         put_long_date_timespec(p,mdate_ts); p += 8;
1504                         put_long_date_timespec(p,mdate_ts); p += 8;
1505                         SOFF_T(p,0,file_size); p += 8;
1506                         SOFF_T(p,0,allocation_size); p += 8;
1507                         SIVAL(p,0,nt_extmode); p += 4;
1508                         q = p; p += 4; /* q is placeholder for name length. */
1509                         {
1510                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1511                                 SIVAL(p,0,ea_size); /* Extended attributes */
1512                                 p +=4;
1513                         }
1514                         SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1515                         SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1516                         SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1517                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1518                         SIVAL(q, 0, len);
1519                         p += len;
1520                         SIVAL(p,0,0); /* Ensure any padding is null. */
1521                         len = PTR_DIFF(p, pdata);
1522                         len = (len + 3) & ~3;
1523                         SIVAL(pdata,0,len);
1524                         p = pdata + len;
1525                         break;
1526
1527                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1528                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1529                         was_8_3 = mangle_is_8_3(fname, True, conn->params);
1530                         p += 4;
1531                         SIVAL(p,0,reskey); p += 4;
1532                         put_long_date_timespec(p,create_date_ts); p += 8;
1533                         put_long_date_timespec(p,adate_ts); p += 8;
1534                         put_long_date_timespec(p,mdate_ts); p += 8;
1535                         put_long_date_timespec(p,mdate_ts); p += 8;
1536                         SOFF_T(p,0,file_size); p += 8;
1537                         SOFF_T(p,0,allocation_size); p += 8;
1538                         SIVAL(p,0,nt_extmode); p += 4;
1539                         q = p; p += 4; /* q is placeholder for name length */
1540                         {
1541                                 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1542                                 SIVAL(p,0,ea_size); /* Extended attributes */
1543                                 p +=4;
1544                         }
1545                         /* Clear the short name buffer. This is
1546                          * IMPORTANT as not doing so will trigger
1547                          * a Win2k client bug. JRA.
1548                          */
1549                         if (!was_8_3 && check_mangled_names) {
1550                                 pstring mangled_name;
1551                                 pstrcpy(mangled_name, fname);
1552                                 mangle_map(mangled_name,True,True,
1553                                            conn->params);
1554                                 mangled_name[12] = 0;
1555                                 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1556                                 SSVAL(p, 0, len);
1557                                 if (len < 24) {
1558                                         memset(p + 2 + len,'\0',24 - len);
1559                                 }
1560                                 SSVAL(p, 0, len);
1561                         } else {
1562                                 memset(p,'\0',26);
1563                         }
1564                         p += 26;
1565                         SSVAL(p,0,0); p += 2; /* Reserved ? */
1566                         SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1567                         SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1568                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1569                         SIVAL(q,0,len);
1570                         p += len;
1571                         SIVAL(p,0,0); /* Ensure any padding is null. */
1572                         len = PTR_DIFF(p, pdata);
1573                         len = (len + 3) & ~3;
1574                         SIVAL(pdata,0,len);
1575                         p = pdata + len;
1576                         break;
1577
1578                 /* CIFS UNIX Extension. */
1579
1580                 case SMB_FIND_FILE_UNIX:
1581                         DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX\n"));
1582                         p+= 4;
1583                         SIVAL(p,0,reskey); p+= 4;    /* Used for continuing search. */
1584
1585                         /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1586                         SOFF_T(p,0,get_file_size(sbuf));             /* File size 64 Bit */
1587                         p+= 8;
1588
1589                         SOFF_T(p,0,get_allocation_size(conn,NULL,&sbuf)); /* Number of bytes used on disk - 64 Bit */
1590                         p+= 8;
1591
1592                         put_long_date_timespec(p,get_ctimespec(&sbuf));       /* Inode change Time 64 Bit */
1593                         put_long_date_timespec(p+8,get_atimespec(&sbuf));     /* Last access time 64 Bit */
1594                         put_long_date_timespec(p+16,get_mtimespec(&sbuf));    /* Last modification time 64 Bit */
1595                         p+= 24;
1596
1597                         SIVAL(p,0,sbuf.st_uid);               /* user id for the owner */
1598                         SIVAL(p,4,0);
1599                         p+= 8;
1600
1601                         SIVAL(p,0,sbuf.st_gid);               /* group id of owner */
1602                         SIVAL(p,4,0);
1603                         p+= 8;
1604
1605                         SIVAL(p,0,unix_filetype(sbuf.st_mode));
1606                         p+= 4;
1607
1608                         SIVAL(p,0,unix_dev_major(sbuf.st_rdev));   /* Major device number if type is device */
1609                         SIVAL(p,4,0);
1610                         p+= 8;
1611
1612                         SIVAL(p,0,unix_dev_minor(sbuf.st_rdev));   /* Minor device number if type is device */
1613                         SIVAL(p,4,0);
1614                         p+= 8;
1615
1616                         SINO_T_VAL(p,0,(SMB_INO_T)sbuf.st_ino);   /* inode number */
1617                         p+= 8;
1618
1619                         SIVAL(p,0, unix_perms_to_wire(sbuf.st_mode));     /* Standard UNIX file permissions */
1620                         SIVAL(p,4,0);
1621                         p+= 8;
1622
1623                         SIVAL(p,0,sbuf.st_nlink);             /* number of hard links */
1624                         SIVAL(p,4,0);
1625                         p+= 8;
1626
1627                         len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1628                         p += len;
1629                         SIVAL(p,0,0); /* Ensure any padding is null. */
1630
1631                         len = PTR_DIFF(p, pdata);
1632                         len = (len + 3) & ~3;
1633                         SIVAL(pdata,0,len);     /* Offset from this structure to the beginning of the next one */
1634                         p = pdata + len;
1635                         /* End of SMB_QUERY_FILE_UNIX_BASIC */
1636
1637                         break;
1638
1639                 default:
1640                         return(False);
1641         }
1642
1643
1644         if (PTR_DIFF(p,pdata) > space_remaining) {
1645                 /* Move the dirptr back to prev_dirpos */
1646                 dptr_SeekDir(conn->dirptr, prev_dirpos);
1647                 *out_of_space = True;
1648                 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1649                 return False; /* Not finished - just out of space */
1650         }
1651
1652         /* Setup the last entry pointer, as an offset from base_data */
1653         *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
1654         /* Advance the data pointer to the next slot */
1655         *ppdata = p;
1656
1657         return(found);
1658 }
1659
1660 /****************************************************************************
1661  Reply to a TRANS2_FINDFIRST.
1662 ****************************************************************************/
1663
1664 static int call_trans2findfirst(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
1665                                 char **pparams, int total_params, char **ppdata, int total_data,
1666                                 unsigned int max_data_bytes)
1667 {
1668         /* We must be careful here that we don't return more than the
1669                 allowed number of data bytes. If this means returning fewer than
1670                 maxentries then so be it. We assume that the redirector has
1671                 enough room for the fixed number of parameter bytes it has
1672                 requested. */
1673         char *params = *pparams;
1674         char *pdata = *ppdata;
1675         uint32 dirtype;
1676         int maxentries;
1677         uint16 findfirst_flags;
1678         BOOL close_after_first;
1679         BOOL close_if_end;
1680         BOOL requires_resume_key;
1681         int info_level;
1682         pstring directory;
1683         pstring mask;
1684         char *p;
1685         int last_entry_off=0;
1686         int dptr_num = -1;
1687         int numentries = 0;
1688         int i;
1689         BOOL finished = False;
1690         BOOL dont_descend = False;
1691         BOOL out_of_space = False;
1692         int space_remaining;
1693         BOOL mask_contains_wcard = False;
1694         SMB_STRUCT_STAT sbuf;
1695         TALLOC_CTX *ea_ctx = NULL;
1696         struct ea_list *ea_list = NULL;
1697         NTSTATUS ntstatus = NT_STATUS_OK;
1698
1699         if (total_params < 13) {
1700                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1701         }
1702
1703         dirtype = SVAL(params,0);
1704         maxentries = SVAL(params,2);
1705         findfirst_flags = SVAL(params,4);
1706         close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
1707         close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1708         requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1709         info_level = SVAL(params,6);
1710
1711         *directory = *mask = 0;
1712
1713         DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
1714 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
1715                 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
1716                 info_level, max_data_bytes));
1717
1718         if (!maxentries) {
1719                 /* W2K3 seems to treat zero as 1. */
1720                 maxentries = 1;
1721         }
1722
1723         switch (info_level) {
1724                 case SMB_FIND_INFO_STANDARD:
1725                 case SMB_FIND_EA_SIZE:
1726                 case SMB_FIND_EA_LIST:
1727                 case SMB_FIND_FILE_DIRECTORY_INFO:
1728                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1729                 case SMB_FIND_FILE_NAMES_INFO:
1730                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1731                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1732                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1733                         break;
1734                 case SMB_FIND_FILE_UNIX:
1735                         if (!lp_unix_extensions()) {
1736                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
1737                         }
1738                         break;
1739                 default:
1740                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
1741         }
1742
1743         srvstr_get_path_wcard(inbuf, directory, params+12, sizeof(directory), total_params - 12, STR_TERMINATE, &ntstatus, &mask_contains_wcard);
1744         if (!NT_STATUS_IS_OK(ntstatus)) {
1745                 return ERROR_NT(ntstatus);
1746         }
1747
1748         RESOLVE_DFSPATH_WCARD(directory, conn, inbuf, outbuf);
1749
1750         ntstatus = unix_convert(conn, directory, True, NULL, &sbuf);
1751         if (!NT_STATUS_IS_OK(ntstatus)) {
1752                 return ERROR_NT(ntstatus);
1753         }
1754         ntstatus = check_name(conn, directory);
1755         if (!NT_STATUS_IS_OK(ntstatus)) {
1756                 return ERROR_NT(ntstatus);
1757         }
1758
1759         p = strrchr_m(directory,'/');
1760         if(p == NULL) {
1761                 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
1762                 if((directory[0] == '.') && (directory[1] == '\0')) {
1763                         pstrcpy(mask,"*");
1764                         mask_contains_wcard = True;
1765                 } else {
1766                         pstrcpy(mask,directory);
1767                 }
1768                 pstrcpy(directory,"./");
1769         } else {
1770                 pstrcpy(mask,p+1);
1771                 *p = 0;
1772         }
1773
1774         DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
1775
1776         if (info_level == SMB_FIND_EA_LIST) {
1777                 uint32 ea_size;
1778
1779                 if (total_data < 4) {
1780                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1781                 }
1782
1783                 ea_size = IVAL(pdata,0);
1784                 if (ea_size != total_data) {
1785                         DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
1786 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
1787                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1788                 }
1789
1790                 if (!lp_ea_support(SNUM(conn))) {
1791                         return ERROR_DOS(ERRDOS,ERReasnotsupported);
1792                 }
1793
1794                 if ((ea_ctx = talloc_init("findnext_ea_list")) == NULL) {
1795                         return ERROR_NT(NT_STATUS_NO_MEMORY);
1796                 }
1797
1798                 /* Pull out the list of names. */
1799                 ea_list = read_ea_name_list(ea_ctx, pdata + 4, ea_size - 4);
1800                 if (!ea_list) {
1801                         talloc_destroy(ea_ctx);
1802                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1803                 }
1804         }
1805
1806         *ppdata = (char *)SMB_REALLOC(
1807                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1808         if(*ppdata == NULL ) {
1809                 talloc_destroy(ea_ctx);
1810                 return ERROR_NT(NT_STATUS_NO_MEMORY);
1811         }
1812         pdata = *ppdata;
1813
1814         /* Realloc the params space */
1815         *pparams = (char *)SMB_REALLOC(*pparams, 10);
1816         if (*pparams == NULL) {
1817                 talloc_destroy(ea_ctx);
1818                 return ERROR_NT(NT_STATUS_NO_MEMORY);
1819         }
1820         params = *pparams;
1821
1822         /* Save the wildcard match and attribs we are using on this directory -
1823                 needed as lanman2 assumes these are being saved between calls */
1824
1825         ntstatus = dptr_create(conn,
1826                                 directory,
1827                                 False,
1828                                 True,
1829                                 SVAL(inbuf,smb_pid),
1830                                 mask,
1831                                 mask_contains_wcard,
1832                                 dirtype,
1833                                 &conn->dirptr);
1834
1835         if (!NT_STATUS_IS_OK(ntstatus)) {
1836                 talloc_destroy(ea_ctx);
1837                 return ERROR_NT(ntstatus);
1838         }
1839
1840         dptr_num = dptr_dnum(conn->dirptr);
1841         DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
1842
1843         /* We don't need to check for VOL here as this is returned by
1844                 a different TRANS2 call. */
1845
1846         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn->dirpath,lp_dontdescend(SNUM(conn))));
1847         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
1848                 dont_descend = True;
1849
1850         p = pdata;
1851         space_remaining = max_data_bytes;
1852         out_of_space = False;
1853
1854         for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
1855                 BOOL got_exact_match = False;
1856
1857                 /* this is a heuristic to avoid seeking the dirptr except when
1858                         absolutely necessary. It allows for a filename of about 40 chars */
1859                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
1860                         out_of_space = True;
1861                         finished = False;
1862                 } else {
1863                         finished = !get_lanman2_dir_entry(conn,
1864                                         inbuf, outbuf,
1865                                         mask,dirtype,info_level,
1866                                         requires_resume_key,dont_descend,
1867                                         &p,pdata,space_remaining, &out_of_space, &got_exact_match,
1868                                         &last_entry_off, ea_list, ea_ctx);
1869                 }
1870
1871                 if (finished && out_of_space)
1872                         finished = False;
1873
1874                 if (!finished && !out_of_space)
1875                         numentries++;
1876
1877                 /*
1878                  * As an optimisation if we know we aren't looking
1879                  * for a wildcard name (ie. the name matches the wildcard exactly)
1880                  * then we can finish on any (first) match.
1881                  * This speeds up large directory searches. JRA.
1882                  */
1883
1884                 if(got_exact_match)
1885                         finished = True;
1886
1887                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1888         }
1889
1890         talloc_destroy(ea_ctx);
1891
1892         /* Check if we can close the dirptr */
1893         if(close_after_first || (finished && close_if_end)) {
1894                 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
1895                 dptr_close(&dptr_num);
1896         }
1897
1898         /*
1899          * If there are no matching entries we must return ERRDOS/ERRbadfile -
1900          * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
1901          * the protocol level is less than NT1. Tested with smbclient. JRA.
1902          * This should fix the OS/2 client bug #2335.
1903          */
1904
1905         if(numentries == 0) {
1906                 dptr_close(&dptr_num);
1907                 if (Protocol < PROTOCOL_NT1) {
1908                         return ERROR_DOS(ERRDOS,ERRnofiles);
1909                 } else {
1910                         return ERROR_BOTH(NT_STATUS_NO_SUCH_FILE,ERRDOS,ERRbadfile);
1911                 }
1912         }
1913
1914         /* At this point pdata points to numentries directory entries. */
1915
1916         /* Set up the return parameter block */
1917         SSVAL(params,0,dptr_num);
1918         SSVAL(params,2,numentries);
1919         SSVAL(params,4,finished);
1920         SSVAL(params,6,0); /* Never an EA error */
1921         SSVAL(params,8,last_entry_off);
1922
1923         send_trans2_replies( outbuf, bufsize, params, 10, pdata, PTR_DIFF(p,pdata), max_data_bytes);
1924
1925         if ((! *directory) && dptr_path(dptr_num))
1926                 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1927
1928         DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1929                 smb_fn_name(CVAL(inbuf,smb_com)),
1930                 mask, directory, dirtype, numentries ) );
1931
1932         /*
1933          * Force a name mangle here to ensure that the
1934          * mask as an 8.3 name is top of the mangled cache.
1935          * The reasons for this are subtle. Don't remove
1936          * this code unless you know what you are doing
1937          * (see PR#13758). JRA.
1938          */
1939
1940         if(!mangle_is_8_3_wildcards( mask, False, conn->params))
1941                 mangle_map(mask, True, True, conn->params);
1942
1943         return(-1);
1944 }
1945
1946 /****************************************************************************
1947  Reply to a TRANS2_FINDNEXT.
1948 ****************************************************************************/
1949
1950 static int call_trans2findnext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
1951                                         char **pparams, int total_params, char **ppdata, int total_data,
1952                                         unsigned int max_data_bytes)
1953 {
1954         /* We must be careful here that we don't return more than the
1955                 allowed number of data bytes. If this means returning fewer than
1956                 maxentries then so be it. We assume that the redirector has
1957                 enough room for the fixed number of parameter bytes it has
1958                 requested. */
1959         char *params = *pparams;
1960         char *pdata = *ppdata;
1961         int dptr_num;
1962         int maxentries;
1963         uint16 info_level;
1964         uint32 resume_key;
1965         uint16 findnext_flags;
1966         BOOL close_after_request;
1967         BOOL close_if_end;
1968         BOOL requires_resume_key;
1969         BOOL continue_bit;
1970         BOOL mask_contains_wcard = False;
1971         pstring resume_name;
1972         pstring mask;
1973         pstring directory;
1974         char *p;
1975         uint16 dirtype;
1976         int numentries = 0;
1977         int i, last_entry_off=0;
1978         BOOL finished = False;
1979         BOOL dont_descend = False;
1980         BOOL out_of_space = False;
1981         int space_remaining;
1982         TALLOC_CTX *ea_ctx = NULL;
1983         struct ea_list *ea_list = NULL;
1984         NTSTATUS ntstatus = NT_STATUS_OK;
1985
1986         if (total_params < 13) {
1987                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1988         }
1989
1990         dptr_num = SVAL(params,0);
1991         maxentries = SVAL(params,2);
1992         info_level = SVAL(params,4);
1993         resume_key = IVAL(params,6);
1994         findnext_flags = SVAL(params,10);
1995         close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
1996         close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1997         requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1998         continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
1999
2000         *mask = *directory = *resume_name = 0;
2001
2002         srvstr_get_path_wcard(inbuf, resume_name, params+12, sizeof(resume_name), total_params - 12, STR_TERMINATE, &ntstatus, &mask_contains_wcard);
2003         if (!NT_STATUS_IS_OK(ntstatus)) {
2004                 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2005                    complain (it thinks we're asking for the directory above the shared
2006                    path or an invalid name). Catch this as the resume name is only compared, never used in
2007                    a file access. JRA. */
2008                 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) {
2009                         pstrcpy(resume_name, "..");
2010                 } else if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_OBJECT_NAME_INVALID)) {
2011                         pstrcpy(resume_name, ".");
2012                 } else {
2013                         return ERROR_NT(ntstatus);
2014                 }
2015         }
2016
2017         DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2018 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2019 resume_key = %d resume name = %s continue=%d level = %d\n",
2020                 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
2021                 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
2022
2023         if (!maxentries) {
2024                 /* W2K3 seems to treat zero as 1. */
2025                 maxentries = 1;
2026         }
2027
2028         switch (info_level) {
2029                 case SMB_FIND_INFO_STANDARD:
2030                 case SMB_FIND_EA_SIZE:
2031                 case SMB_FIND_EA_LIST:
2032                 case SMB_FIND_FILE_DIRECTORY_INFO:
2033                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2034                 case SMB_FIND_FILE_NAMES_INFO:
2035                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2036                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2037                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2038                         break;
2039                 case SMB_FIND_FILE_UNIX:
2040                         if (!lp_unix_extensions()) {
2041                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2042                         }
2043                         break;
2044                 default:
2045                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2046         }
2047
2048         if (info_level == SMB_FIND_EA_LIST) {
2049                 uint32 ea_size;
2050
2051                 if (total_data < 4) {
2052                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2053                 }
2054
2055                 ea_size = IVAL(pdata,0);
2056                 if (ea_size != total_data) {
2057                         DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2058 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2059                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2060                 }
2061
2062                 if (!lp_ea_support(SNUM(conn))) {
2063                         return ERROR_DOS(ERRDOS,ERReasnotsupported);
2064                 }
2065
2066                 if ((ea_ctx = talloc_init("findnext_ea_list")) == NULL) {
2067                         return ERROR_NT(NT_STATUS_NO_MEMORY);
2068                 }
2069
2070                 /* Pull out the list of names. */
2071                 ea_list = read_ea_name_list(ea_ctx, pdata + 4, ea_size - 4);
2072                 if (!ea_list) {
2073                         talloc_destroy(ea_ctx);
2074                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2075                 }
2076         }
2077
2078         *ppdata = (char *)SMB_REALLOC(
2079                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2080         if(*ppdata == NULL) {
2081                 talloc_destroy(ea_ctx);
2082                 return ERROR_NT(NT_STATUS_NO_MEMORY);
2083         }
2084
2085         pdata = *ppdata;
2086
2087         /* Realloc the params space */
2088         *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2089         if(*pparams == NULL ) {
2090                 talloc_destroy(ea_ctx);
2091                 return ERROR_NT(NT_STATUS_NO_MEMORY);
2092         }
2093
2094         params = *pparams;
2095
2096         /* Check that the dptr is valid */
2097         if(!(conn->dirptr = dptr_fetch_lanman2(dptr_num))) {
2098                 talloc_destroy(ea_ctx);
2099                 return ERROR_DOS(ERRDOS,ERRnofiles);
2100         }
2101
2102         string_set(&conn->dirpath,dptr_path(dptr_num));
2103
2104         /* Get the wildcard mask from the dptr */
2105         if((p = dptr_wcard(dptr_num))== NULL) {
2106                 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2107                 talloc_destroy(ea_ctx);
2108                 return ERROR_DOS(ERRDOS,ERRnofiles);
2109         }
2110
2111         pstrcpy(mask, p);
2112         pstrcpy(directory,conn->dirpath);
2113
2114         /* Get the attr mask from the dptr */
2115         dirtype = dptr_attr(dptr_num);
2116
2117         DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2118                 dptr_num, mask, dirtype,
2119                 (long)conn->dirptr,
2120                 dptr_TellDir(conn->dirptr)));
2121
2122         /* We don't need to check for VOL here as this is returned by
2123                 a different TRANS2 call. */
2124
2125         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn->dirpath,lp_dontdescend(SNUM(conn))));
2126         if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2127                 dont_descend = True;
2128
2129         p = pdata;
2130         space_remaining = max_data_bytes;
2131         out_of_space = False;
2132
2133         /*
2134          * Seek to the correct position. We no longer use the resume key but
2135          * depend on the last file name instead.
2136          */
2137
2138         if(*resume_name && !continue_bit) {
2139                 SMB_STRUCT_STAT st;
2140
2141                 long current_pos = 0;
2142                 /*
2143                  * Remember, mangle_map is called by
2144                  * get_lanman2_dir_entry(), so the resume name
2145                  * could be mangled. Ensure we check the unmangled name.
2146                  */
2147
2148                 if (mangle_is_mangled(resume_name, conn->params)) {
2149                         mangle_check_cache(resume_name, sizeof(resume_name)-1,
2150                                            conn->params);
2151                 }
2152
2153                 /*
2154                  * Fix for NT redirector problem triggered by resume key indexes
2155                  * changing between directory scans. We now return a resume key of 0
2156                  * and instead look for the filename to continue from (also given
2157                  * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2158                  * findfirst/findnext (as is usual) then the directory pointer
2159                  * should already be at the correct place.
2160                  */
2161
2162                 finished = !dptr_SearchDir(conn->dirptr, resume_name, &current_pos, &st);
2163         } /* end if resume_name && !continue_bit */
2164
2165         for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2166                 BOOL got_exact_match = False;
2167
2168                 /* this is a heuristic to avoid seeking the dirptr except when
2169                         absolutely necessary. It allows for a filename of about 40 chars */
2170                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2171                         out_of_space = True;
2172                         finished = False;
2173                 } else {
2174                         finished = !get_lanman2_dir_entry(conn,
2175                                                 inbuf, outbuf,
2176                                                 mask,dirtype,info_level,
2177                                                 requires_resume_key,dont_descend,
2178                                                 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
2179                                                 &last_entry_off, ea_list, ea_ctx);
2180                 }
2181
2182                 if (finished && out_of_space)
2183                         finished = False;
2184
2185                 if (!finished && !out_of_space)
2186                         numentries++;
2187
2188                 /*
2189                  * As an optimisation if we know we aren't looking
2190                  * for a wildcard name (ie. the name matches the wildcard exactly)
2191                  * then we can finish on any (first) match.
2192                  * This speeds up large directory searches. JRA.
2193                  */
2194
2195                 if(got_exact_match)
2196                         finished = True;
2197
2198                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2199         }
2200
2201         talloc_destroy(ea_ctx);
2202
2203         /* Check if we can close the dirptr */
2204         if(close_after_request || (finished && close_if_end)) {
2205                 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2206                 dptr_close(&dptr_num); /* This frees up the saved mask */
2207         }
2208
2209         /* Set up the return parameter block */
2210         SSVAL(params,0,numentries);
2211         SSVAL(params,2,finished);
2212         SSVAL(params,4,0); /* Never an EA error */
2213         SSVAL(params,6,last_entry_off);
2214
2215         send_trans2_replies( outbuf, bufsize, params, 8, pdata, PTR_DIFF(p,pdata), max_data_bytes);
2216
2217         if ((! *directory) && dptr_path(dptr_num))
2218                 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
2219
2220         DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2221                 smb_fn_name(CVAL(inbuf,smb_com)),
2222                 mask, directory, dirtype, numentries ) );
2223
2224         return(-1);
2225 }
2226
2227 /****************************************************************************
2228  Reply to a TRANS2_QFSINFO (query filesystem info).
2229 ****************************************************************************/
2230
2231 static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2232                                         char **pparams, int total_params, char **ppdata, int total_data,
2233                                         unsigned int max_data_bytes)
2234 {
2235         char *pdata = *ppdata;
2236         char *params = *pparams;
2237         uint16 info_level;
2238         int data_len, len;
2239         SMB_STRUCT_STAT st;
2240         char *vname = volume_label(SNUM(conn));
2241         int snum = SNUM(conn);
2242         char *fstype = lp_fstype(SNUM(conn));
2243         int quota_flag = 0;
2244
2245         if (total_params < 2) {
2246                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2247         }
2248
2249         info_level = SVAL(params,0);
2250
2251         DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
2252
2253         if(SMB_VFS_STAT(conn,".",&st)!=0) {
2254                 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
2255                 return ERROR_DOS(ERRSRV,ERRinvdevice);
2256         }
2257
2258         *ppdata = (char *)SMB_REALLOC(
2259                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2260         if (*ppdata == NULL ) {
2261                 return ERROR_NT(NT_STATUS_NO_MEMORY);
2262         }
2263
2264         pdata = *ppdata;
2265         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2266
2267         switch (info_level) {
2268                 case SMB_INFO_ALLOCATION:
2269                 {
2270                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2271                         data_len = 18;
2272                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2273                                 return(UNIXERROR(ERRHRD,ERRgeneral));
2274                         }
2275
2276                         block_size = lp_block_size(snum);
2277                         if (bsize < block_size) {
2278                                 SMB_BIG_UINT factor = block_size/bsize;
2279                                 bsize = block_size;
2280                                 dsize /= factor;
2281                                 dfree /= factor;
2282                         }
2283                         if (bsize > block_size) {
2284                                 SMB_BIG_UINT factor = bsize/block_size;
2285                                 bsize = block_size;
2286                                 dsize *= factor;
2287                                 dfree *= factor;
2288                         }
2289                         bytes_per_sector = 512;
2290                         sectors_per_unit = bsize/bytes_per_sector;
2291
2292                         DEBUG(5,("call_trans2qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2293 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2294                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2295
2296                         SIVAL(pdata,l1_idFileSystem,st.st_dev);
2297                         SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
2298                         SIVAL(pdata,l1_cUnit,dsize);
2299                         SIVAL(pdata,l1_cUnitAvail,dfree);
2300                         SSVAL(pdata,l1_cbSector,bytes_per_sector);
2301                         break;
2302                 }
2303
2304                 case SMB_INFO_VOLUME:
2305                         /* Return volume name */
2306                         /*
2307                          * Add volume serial number - hash of a combination of
2308                          * the called hostname and the service name.
2309                          */
2310                         SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
2311                         /*
2312                          * Win2k3 and previous mess this up by sending a name length
2313                          * one byte short. I believe only older clients (OS/2 Win9x) use
2314                          * this call so try fixing this by adding a terminating null to
2315                          * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2316                          */
2317                         len = srvstr_push(outbuf, pdata+l2_vol_szVolLabel, vname, -1, STR_NOALIGN|STR_TERMINATE);
2318                         SCVAL(pdata,l2_vol_cch,len);
2319                         data_len = l2_vol_szVolLabel + len;
2320                         DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
2321                                 (unsigned)st.st_ctime, len, vname));
2322                         break;
2323
2324                 case SMB_QUERY_FS_ATTRIBUTE_INFO:
2325                 case SMB_FS_ATTRIBUTE_INFORMATION:
2326
2327
2328 #if defined(HAVE_SYS_QUOTAS)
2329                         quota_flag = FILE_VOLUME_QUOTAS;
2330 #endif
2331
2332                         SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
2333                                 (lp_nt_acl_support(SNUM(conn)) ? FILE_PERSISTENT_ACLS : 0)|
2334                                 quota_flag); /* FS ATTRIBUTES */
2335
2336                         SIVAL(pdata,4,255); /* Max filename component length */
2337                         /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2338                                 and will think we can't do long filenames */
2339                         len = srvstr_push(outbuf, pdata+12, fstype, -1, STR_UNICODE);
2340                         SIVAL(pdata,8,len);
2341                         data_len = 12 + len;
2342                         break;
2343
2344                 case SMB_QUERY_FS_LABEL_INFO:
2345                 case SMB_FS_LABEL_INFORMATION:
2346                         len = srvstr_push(outbuf, pdata+4, vname, -1, 0);
2347                         data_len = 4 + len;
2348                         SIVAL(pdata,0,len);
2349                         break;
2350
2351                 case SMB_QUERY_FS_VOLUME_INFO:
2352                 case SMB_FS_VOLUME_INFORMATION:
2353
2354                         /*
2355                          * Add volume serial number - hash of a combination of
2356                          * the called hostname and the service name.
2357                          */
2358                         SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
2359                                 (str_checksum(get_local_machine_name())<<16));
2360
2361                         len = srvstr_push(outbuf, pdata+18, vname, -1, STR_UNICODE);
2362                         SIVAL(pdata,12,len);
2363                         data_len = 18+len;
2364                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
2365                                 (int)strlen(vname),vname, lp_servicename(snum)));
2366                         break;
2367
2368                 case SMB_QUERY_FS_SIZE_INFO:
2369                 case SMB_FS_SIZE_INFORMATION:
2370                 {
2371                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2372                         data_len = 24;
2373                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2374                                 return(UNIXERROR(ERRHRD,ERRgeneral));
2375                         }
2376                         block_size = lp_block_size(snum);
2377                         if (bsize < block_size) {
2378                                 SMB_BIG_UINT factor = block_size/bsize;
2379                                 bsize = block_size;
2380                                 dsize /= factor;
2381                                 dfree /= factor;
2382                         }
2383                         if (bsize > block_size) {
2384                                 SMB_BIG_UINT factor = bsize/block_size;
2385                                 bsize = block_size;
2386                                 dsize *= factor;
2387                                 dfree *= factor;
2388                         }
2389                         bytes_per_sector = 512;
2390                         sectors_per_unit = bsize/bytes_per_sector;
2391                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2392 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2393                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2394                         SBIG_UINT(pdata,0,dsize);
2395                         SBIG_UINT(pdata,8,dfree);
2396                         SIVAL(pdata,16,sectors_per_unit);
2397                         SIVAL(pdata,20,bytes_per_sector);
2398                         break;
2399                 }
2400
2401                 case SMB_FS_FULL_SIZE_INFORMATION:
2402                 {
2403                         SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2404                         data_len = 32;
2405                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2406                                 return(UNIXERROR(ERRHRD,ERRgeneral));
2407                         }
2408                         block_size = lp_block_size(snum);
2409                         if (bsize < block_size) {
2410                                 SMB_BIG_UINT factor = block_size/bsize;
2411                                 bsize = block_size;
2412                                 dsize /= factor;
2413                                 dfree /= factor;
2414                         }
2415                         if (bsize > block_size) {
2416                                 SMB_BIG_UINT factor = bsize/block_size;
2417                                 bsize = block_size;
2418                                 dsize *= factor;
2419                                 dfree *= factor;
2420                         }
2421                         bytes_per_sector = 512;
2422                         sectors_per_unit = bsize/bytes_per_sector;
2423                         DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2424 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2425                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2426                         SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
2427                         SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
2428                         SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
2429                         SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
2430                         SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
2431                         break;
2432                 }
2433
2434                 case SMB_QUERY_FS_DEVICE_INFO:
2435                 case SMB_FS_DEVICE_INFORMATION:
2436                         data_len = 8;
2437                         SIVAL(pdata,0,0); /* dev type */
2438                         SIVAL(pdata,4,0); /* characteristics */
2439                         break;
2440
2441 #ifdef HAVE_SYS_QUOTAS
2442                 case SMB_FS_QUOTA_INFORMATION:
2443                 /*
2444                  * what we have to send --metze:
2445                  *
2446                  * Unknown1:            24 NULL bytes
2447                  * Soft Quota Treshold: 8 bytes seems like SMB_BIG_UINT or so
2448                  * Hard Quota Limit:    8 bytes seems like SMB_BIG_UINT or so
2449                  * Quota Flags:         2 byte :
2450                  * Unknown3:            6 NULL bytes
2451                  *
2452                  * 48 bytes total
2453                  *
2454                  * details for Quota Flags:
2455                  *
2456                  * 0x0020 Log Limit: log if the user exceeds his Hard Quota
2457                  * 0x0010 Log Warn:  log if the user exceeds his Soft Quota
2458                  * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
2459                  * 0x0001 Enable Quotas: enable quota for this fs
2460                  *
2461                  */
2462                 {
2463                         /* we need to fake up a fsp here,
2464                          * because its not send in this call
2465                          */
2466                         files_struct fsp;
2467                         SMB_NTQUOTA_STRUCT quotas;
2468
2469                         ZERO_STRUCT(fsp);
2470                         ZERO_STRUCT(quotas);
2471
2472                         fsp.conn = conn;
2473                         fsp.fnum = -1;
2474
2475                         /* access check */
2476                         if (current_user.ut.uid != 0) {
2477                                 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2478                                         lp_servicename(SNUM(conn)),conn->user));
2479                                 return ERROR_DOS(ERRDOS,ERRnoaccess);
2480                         }
2481
2482                         if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2483                                 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2484                                 return ERROR_DOS(ERRSRV,ERRerror);
2485                         }
2486
2487                         data_len = 48;
2488
2489                         DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn))));
2490
2491                         /* Unknown1 24 NULL bytes*/
2492                         SBIG_UINT(pdata,0,(SMB_BIG_UINT)0);
2493                         SBIG_UINT(pdata,8,(SMB_BIG_UINT)0);
2494                         SBIG_UINT(pdata,16,(SMB_BIG_UINT)0);
2495
2496                         /* Default Soft Quota 8 bytes */
2497                         SBIG_UINT(pdata,24,quotas.softlim);
2498
2499                         /* Default Hard Quota 8 bytes */
2500                         SBIG_UINT(pdata,32,quotas.hardlim);
2501
2502                         /* Quota flag 2 bytes */
2503                         SSVAL(pdata,40,quotas.qflags);
2504
2505                         /* Unknown3 6 NULL bytes */
2506                         SSVAL(pdata,42,0);
2507                         SIVAL(pdata,44,0);
2508
2509                         break;
2510                 }
2511 #endif /* HAVE_SYS_QUOTAS */
2512                 case SMB_FS_OBJECTID_INFORMATION:
2513                         data_len = 64;
2514                         break;
2515
2516                 /*
2517                  * Query the version and capabilities of the CIFS UNIX extensions
2518                  * in use.
2519                  */
2520
2521                 case SMB_QUERY_CIFS_UNIX_INFO:
2522                         if (!lp_unix_extensions()) {
2523                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2524                         }
2525                         data_len = 12;
2526                         SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
2527                         SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
2528                         /* We have POSIX ACLs, pathname and locking capability. */
2529                         SBIG_UINT(pdata,4,((SMB_BIG_UINT)(
2530                                         CIFS_UNIX_POSIX_ACLS_CAP|
2531                                         CIFS_UNIX_POSIX_PATHNAMES_CAP|
2532                                         CIFS_UNIX_FCNTL_LOCKS_CAP|
2533                                         CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)));
2534                         break;
2535
2536                 case SMB_QUERY_POSIX_FS_INFO:
2537                 {
2538                         int rc;
2539                         vfs_statvfs_struct svfs;
2540
2541                         if (!lp_unix_extensions()) {
2542                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2543                         }
2544
2545                         rc = SMB_VFS_STATVFS(conn, ".", &svfs);
2546
2547                         if (!rc) {
2548                                 data_len = 56;
2549                                 SIVAL(pdata,0,svfs.OptimalTransferSize);
2550                                 SIVAL(pdata,4,svfs.BlockSize);
2551                                 SBIG_UINT(pdata,8,svfs.TotalBlocks);
2552                                 SBIG_UINT(pdata,16,svfs.BlocksAvail);
2553                                 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
2554                                 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
2555                                 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
2556                                 SBIG_UINT(pdata,48,svfs.FsIdentifier);
2557                                 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
2558 #ifdef EOPNOTSUPP
2559                         } else if (rc == EOPNOTSUPP) {
2560                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2561 #endif /* EOPNOTSUPP */
2562                         } else {
2563                                 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2564                                 return ERROR_DOS(ERRSRV,ERRerror);
2565                         }
2566                         break;
2567                 }
2568
2569                 case SMB_MAC_QUERY_FS_INFO:
2570                         /*
2571                          * Thursby MAC extension... ONLY on NTFS filesystems
2572                          * once we do streams then we don't need this
2573                          */
2574                         if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
2575                                 data_len = 88;
2576                                 SIVAL(pdata,84,0x100); /* Don't support mac... */
2577                                 break;
2578                         }
2579                         /* drop through */
2580                 default:
2581                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2582         }
2583
2584
2585         send_trans2_replies( outbuf, bufsize, params, 0, pdata, data_len, max_data_bytes);
2586
2587         DEBUG( 4, ( "%s info_level = %d\n", smb_fn_name(CVAL(inbuf,smb_com)), info_level) );
2588
2589         return -1;
2590 }
2591
2592 /****************************************************************************
2593  Reply to a TRANS2_SETFSINFO (set filesystem info).
2594 ****************************************************************************/
2595
2596 static int call_trans2setfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2597                                         char **pparams, int total_params, char **ppdata, int total_data,
2598                                         unsigned int max_data_bytes)
2599 {
2600         char *pdata = *ppdata;
2601         char *params = *pparams;
2602         uint16 info_level;
2603         int outsize;
2604
2605         DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn))));
2606
2607         /*  */
2608         if (total_params < 4) {
2609                 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
2610                         total_params));
2611                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2612         }
2613
2614         info_level = SVAL(params,2);
2615
2616         switch(info_level) {
2617                 case SMB_SET_CIFS_UNIX_INFO:
2618                         {
2619                                 uint16 client_unix_major;
2620                                 uint16 client_unix_minor;
2621                                 uint32 client_unix_cap_low;
2622                                 uint32 client_unix_cap_high;
2623
2624                                 if (!lp_unix_extensions()) {
2625                                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2626                                 }
2627
2628                                 /* There should be 12 bytes of capabilities set. */
2629                                 if (total_data < 8) {
2630                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2631                                 }
2632                                 client_unix_major = SVAL(pdata,0);
2633                                 client_unix_minor = SVAL(pdata,2);
2634                                 client_unix_cap_low = IVAL(pdata,4);
2635                                 client_unix_cap_high = IVAL(pdata,8);
2636                                 /* Just print these values for now. */
2637                                 DEBUG(10,("call_trans2setfsinfo: set unix info. major = %u, minor = %u \
2638 cap_low = 0x%x, cap_high = 0x%x\n",
2639                                         (unsigned int)client_unix_major,
2640                                         (unsigned int)client_unix_minor,
2641                                         (unsigned int)client_unix_cap_low,
2642                                         (unsigned int)client_unix_cap_high ));
2643
2644                                 /* Here is where we must switch to posix pathname processing... */
2645                                 if (client_unix_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2646                                         lp_set_posix_pathnames();
2647                                         mangle_change_to_posix();
2648                                 }
2649
2650                                 if ((client_unix_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
2651                                     !(client_unix_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
2652                                         /* Client that knows how to do posix locks,
2653                                          * but not posix open/mkdir operations. Set a
2654                                          * default type for read/write checks. */
2655
2656                                         lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
2657
2658                                 }
2659                                 break;
2660                         }
2661                 case SMB_FS_QUOTA_INFORMATION:
2662                         {
2663                                 files_struct *fsp = NULL;
2664                                 SMB_NTQUOTA_STRUCT quotas;
2665
2666                                 ZERO_STRUCT(quotas);
2667
2668                                 /* access check */
2669                                 if ((current_user.ut.uid != 0)||!CAN_WRITE(conn)) {
2670                                         DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2671                                                 lp_servicename(SNUM(conn)),conn->user));
2672                                         return ERROR_DOS(ERRSRV,ERRaccess);
2673                                 }
2674
2675                                 /* note: normaly there're 48 bytes,
2676                                  * but we didn't use the last 6 bytes for now
2677                                  * --metze
2678                                  */
2679                                 fsp = file_fsp(params,0);
2680                                 if (!CHECK_NTQUOTA_HANDLE_OK(fsp,conn)) {
2681                                         DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
2682                                         return ERROR_NT(NT_STATUS_INVALID_HANDLE);
2683                                 }
2684
2685                                 if (total_data < 42) {
2686                                         DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
2687                                                 total_data));
2688                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2689                                 }
2690
2691                                 /* unknown_1 24 NULL bytes in pdata*/
2692
2693                                 /* the soft quotas 8 bytes (SMB_BIG_UINT)*/
2694                                 quotas.softlim = (SMB_BIG_UINT)IVAL(pdata,24);
2695 #ifdef LARGE_SMB_OFF_T
2696                                 quotas.softlim |= (((SMB_BIG_UINT)IVAL(pdata,28)) << 32);
2697 #else /* LARGE_SMB_OFF_T */
2698                                 if ((IVAL(pdata,28) != 0)&&
2699                                         ((quotas.softlim != 0xFFFFFFFF)||
2700                                         (IVAL(pdata,28)!=0xFFFFFFFF))) {
2701                                         /* more than 32 bits? */
2702                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2703                                 }
2704 #endif /* LARGE_SMB_OFF_T */
2705
2706                                 /* the hard quotas 8 bytes (SMB_BIG_UINT)*/
2707                                 quotas.hardlim = (SMB_BIG_UINT)IVAL(pdata,32);
2708 #ifdef LARGE_SMB_OFF_T
2709                                 quotas.hardlim |= (((SMB_BIG_UINT)IVAL(pdata,36)) << 32);
2710 #else /* LARGE_SMB_OFF_T */
2711                                 if ((IVAL(pdata,36) != 0)&&
2712                                         ((quotas.hardlim != 0xFFFFFFFF)||
2713                                         (IVAL(pdata,36)!=0xFFFFFFFF))) {
2714                                         /* more than 32 bits? */
2715                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2716                                 }
2717 #endif /* LARGE_SMB_OFF_T */
2718
2719                                 /* quota_flags 2 bytes **/
2720                                 quotas.qflags = SVAL(pdata,40);
2721
2722                                 /* unknown_2 6 NULL bytes follow*/
2723
2724                                 /* now set the quotas */
2725                                 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2726                                         DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2727                                         return ERROR_DOS(ERRSRV,ERRerror);
2728                                 }
2729
2730                                 break;
2731                         }
2732                 default:
2733                         DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
2734                                 info_level));
2735                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2736                         break;
2737         }
2738
2739         /*
2740          * sending this reply works fine,
2741          * but I'm not sure it's the same
2742          * like windows do...
2743          * --metze
2744          */
2745         outsize = set_message(outbuf,10,0,True);
2746
2747         return outsize;
2748 }
2749
2750 #if defined(HAVE_POSIX_ACLS)
2751 /****************************************************************************
2752  Utility function to count the number of entries in a POSIX acl.
2753 ****************************************************************************/
2754
2755 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
2756 {
2757         unsigned int ace_count = 0;
2758         int entry_id = SMB_ACL_FIRST_ENTRY;
2759         SMB_ACL_ENTRY_T entry;
2760
2761         while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2762                 /* get_next... */
2763                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2764                         entry_id = SMB_ACL_NEXT_ENTRY;
2765                 }
2766                 ace_count++;
2767         }
2768         return ace_count;
2769 }
2770
2771 /****************************************************************************
2772  Utility function to marshall a POSIX acl into wire format.
2773 ****************************************************************************/
2774
2775 static BOOL marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
2776 {
2777         int entry_id = SMB_ACL_FIRST_ENTRY;
2778         SMB_ACL_ENTRY_T entry;
2779
2780         while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2781                 SMB_ACL_TAG_T tagtype;
2782                 SMB_ACL_PERMSET_T permset;
2783                 unsigned char perms = 0;
2784                 unsigned int own_grp;
2785
2786                 /* get_next... */
2787                 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2788                         entry_id = SMB_ACL_NEXT_ENTRY;
2789                 }
2790
2791                 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
2792                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
2793                         return False;
2794                 }
2795
2796                 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
2797                         DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
2798                         return False;
2799                 }
2800
2801                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
2802                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
2803                 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
2804
2805                 SCVAL(pdata,1,perms);
2806
2807                 switch (tagtype) {
2808                         case SMB_ACL_USER_OBJ:
2809                                 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
2810                                 own_grp = (unsigned int)pst->st_uid;
2811                                 SIVAL(pdata,2,own_grp);
2812                                 SIVAL(pdata,6,0);
2813                                 break;
2814                         case SMB_ACL_USER:
2815                                 {
2816                                         uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
2817                                         if (!puid) {
2818                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
2819                                         }
2820                                         own_grp = (unsigned int)*puid;
2821                                         SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
2822                                         SCVAL(pdata,0,SMB_POSIX_ACL_USER);
2823                                         SIVAL(pdata,2,own_grp);
2824                                         SIVAL(pdata,6,0);
2825                                         break;
2826                                 }
2827                         case SMB_ACL_GROUP_OBJ:
2828                                 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
2829                                 own_grp = (unsigned int)pst->st_gid;
2830                                 SIVAL(pdata,2,own_grp);
2831                                 SIVAL(pdata,6,0);
2832                                 break;
2833                         case SMB_ACL_GROUP:
2834                                 {
2835                                         gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
2836                                         if (!pgid) {
2837                                                 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
2838                                         }
2839                                         own_grp = (unsigned int)*pgid;
2840                                         SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
2841                                         SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
2842                                         SIVAL(pdata,2,own_grp);
2843                                         SIVAL(pdata,6,0);
2844                                         break;
2845                                 }
2846                         case SMB_ACL_MASK:
2847                                 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
2848                                 SIVAL(pdata,2,0xFFFFFFFF);
2849                                 SIVAL(pdata,6,0xFFFFFFFF);
2850                                 break;
2851                         case SMB_ACL_OTHER:
2852                                 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
2853                                 SIVAL(pdata,2,0xFFFFFFFF);
2854                                 SIVAL(pdata,6,0xFFFFFFFF);
2855                                 break;
2856                         default:
2857                                 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
2858                                 return False;
2859                 }
2860                 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
2861         }
2862
2863         return True;
2864 }
2865 #endif
2866
2867 /****************************************************************************
2868  Store the FILE_UNIX_BASIC info.
2869 ****************************************************************************/
2870
2871 static char *store_file_unix_basic(connection_struct *conn,
2872                                 char *pdata,
2873                                 files_struct *fsp,
2874                                 SMB_STRUCT_STAT *psbuf)
2875 {
2876         DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
2877         DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf->st_mode));
2878
2879         SOFF_T(pdata,0,get_file_size(*psbuf));             /* File size 64 Bit */
2880         pdata += 8;
2881
2882         SOFF_T(pdata,0,get_allocation_size(conn,fsp,psbuf)); /* Number of bytes used on disk - 64 Bit */
2883         pdata += 8;
2884
2885         put_long_date_timespec(pdata,get_ctimespec(psbuf));       /* Change Time 64 Bit */
2886         put_long_date_timespec(pdata+8,get_atimespec(psbuf));     /* Last access time 64 Bit */
2887         put_long_date_timespec(pdata+16,get_mtimespec(psbuf));    /* Last modification time 64 Bit */
2888         pdata += 24;
2889
2890         SIVAL(pdata,0,psbuf->st_uid);               /* user id for the owner */
2891         SIVAL(pdata,4,0);
2892         pdata += 8;
2893
2894         SIVAL(pdata,0,psbuf->st_gid);               /* group id of owner */
2895         SIVAL(pdata,4,0);
2896         pdata += 8;
2897
2898         SIVAL(pdata,0,unix_filetype(psbuf->st_mode));
2899         pdata += 4;
2900
2901         SIVAL(pdata,0,unix_dev_major(psbuf->st_rdev));   /* Major device number if type is device */
2902         SIVAL(pdata,4,0);
2903         pdata += 8;
2904
2905         SIVAL(pdata,0,unix_dev_minor(psbuf->st_rdev));   /* Minor device number if type is device */
2906         SIVAL(pdata,4,0);
2907         pdata += 8;
2908
2909         SINO_T_VAL(pdata,0,(SMB_INO_T)psbuf->st_ino);   /* inode number */
2910         pdata += 8;
2911
2912         SIVAL(pdata,0, unix_perms_to_wire(psbuf->st_mode));     /* Standard UNIX file permissions */
2913         SIVAL(pdata,4,0);
2914         pdata += 8;
2915
2916         SIVAL(pdata,0,psbuf->st_nlink);             /* number of hard links */
2917         SIVAL(pdata,4,0);
2918         pdata += 8;
2919
2920         return pdata;
2921 }
2922
2923 /****************************************************************************
2924  Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
2925  file name or file id).
2926 ****************************************************************************/
2927
2928 static int call_trans2qfilepathinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2929                                         unsigned int tran_call,
2930                                         char **pparams, int total_params, char **ppdata, int total_data,
2931                                         unsigned int max_data_bytes)
2932 {
2933         char *params = *pparams;
2934         char *pdata = *ppdata;
2935         uint16 info_level;
2936         int mode=0;
2937         int nlink;
2938         SMB_OFF_T file_size=0;
2939         SMB_BIG_UINT allocation_size=0;
2940         unsigned int data_size = 0;
2941         unsigned int param_size = 2;
2942         SMB_STRUCT_STAT sbuf;
2943         pstring fname, dos_fname;
2944         char *fullpathname;
2945         char *base_name;
2946         char *p;
2947         SMB_OFF_T pos = 0;
2948         BOOL delete_pending = False;
2949         int len;
2950         time_t create_time, mtime, atime;
2951         struct timespec create_time_ts, mtime_ts, atime_ts;
2952         files_struct *fsp = NULL;
2953         TALLOC_CTX *data_ctx = NULL;
2954         struct ea_list *ea_list = NULL;
2955         uint32 access_mask = 0x12019F; /* Default - GENERIC_EXECUTE mapping from Windows */
2956         char *lock_data = NULL;
2957
2958         if (!params)
2959                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2960
2961         ZERO_STRUCT(sbuf);
2962
2963         if (tran_call == TRANSACT2_QFILEINFO) {
2964                 if (total_params < 4) {
2965                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2966                 }
2967
2968                 fsp = file_fsp(params,0);
2969                 info_level = SVAL(params,2);
2970
2971                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
2972
2973                 if(fsp && (fsp->fake_file_handle)) {
2974                         /*
2975                          * This is actually for the QUOTA_FAKE_FILE --metze
2976                          */
2977
2978                         pstrcpy(fname, fsp->fsp_name);
2979                         /* We know this name is ok, it's already passed the checks. */
2980
2981                 } else if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
2982                         /*
2983                          * This is actually a QFILEINFO on a directory
2984                          * handle (returned from an NT SMB). NT5.0 seems
2985                          * to do this call. JRA.
2986                          */
2987                         /* We know this name is ok, it's already passed the checks. */
2988                         pstrcpy(fname, fsp->fsp_name);
2989
2990                         if (INFO_LEVEL_IS_UNIX(info_level)) {
2991                                 /* Always do lstat for UNIX calls. */
2992                                 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
2993                                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
2994                                         return UNIXERROR(ERRDOS,ERRbadpath);
2995                                 }
2996                         } else if (SMB_VFS_STAT(conn,fname,&sbuf)) {
2997                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
2998                                 return UNIXERROR(ERRDOS,ERRbadpath);
2999                         }
3000
3001                         delete_pending = get_delete_on_close_flag(sbuf.st_dev, sbuf.st_ino);
3002                 } else {
3003                         /*
3004                          * Original code - this is an open file.
3005                          */
3006                         CHECK_FSP(fsp,conn);
3007
3008                         pstrcpy(fname, fsp->fsp_name);
3009                         if (SMB_VFS_FSTAT(fsp,fsp->fh->fd,&sbuf) != 0) {
3010                                 DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
3011                                 return(UNIXERROR(ERRDOS,ERRbadfid));
3012                         }
3013                         pos = fsp->fh->position_information;
3014                         delete_pending = get_delete_on_close_flag(sbuf.st_dev, sbuf.st_ino);
3015                         access_mask = fsp->access_mask;
3016                 }
3017         } else {
3018                 NTSTATUS status = NT_STATUS_OK;
3019
3020                 /* qpathinfo */
3021                 if (total_params < 7) {
3022                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3023                 }
3024
3025                 info_level = SVAL(params,0);
3026
3027                 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
3028
3029                 srvstr_get_path(inbuf, fname, &params[6], sizeof(fname), total_params - 6, STR_TERMINATE, &status);
3030                 if (!NT_STATUS_IS_OK(status)) {
3031                         return ERROR_NT(status);
3032                 }
3033
3034                 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
3035
3036                 status = unix_convert(conn, fname, False, NULL, &sbuf);
3037                 if (!NT_STATUS_IS_OK(status)) {
3038                         return ERROR_NT(status);
3039                 }
3040                 status = check_name(conn, fname);
3041                 if (!NT_STATUS_IS_OK(status)) {
3042                         DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,nt_errstr(status)));
3043                         return ERROR_NT(status);
3044                 }
3045
3046                 if (INFO_LEVEL_IS_UNIX(info_level)) {
3047                         /* Always do lstat for UNIX calls. */
3048                         if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
3049                                 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
3050                                 return UNIXERROR(ERRDOS,ERRbadpath);
3051                         }
3052                 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf) && (info_level != SMB_INFO_IS_NAME_VALID)) {
3053                         DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
3054                         return UNIXERROR(ERRDOS,ERRbadpath);
3055                 }
3056
3057                 delete_pending = get_delete_on_close_flag(sbuf.st_dev, sbuf.st_ino);
3058                 if (delete_pending) {
3059                         return ERROR_NT(NT_STATUS_DELETE_PENDING);
3060                 }
3061         }
3062
3063         nlink = sbuf.st_nlink;
3064
3065         if ((nlink > 0) && S_ISDIR(sbuf.st_mode)) {
3066                 /* NTFS does not seem to count ".." */
3067                 nlink -= 1;
3068         }
3069
3070         if ((nlink > 0) && delete_pending) {
3071                 nlink -= 1;
3072         }
3073
3074         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3075                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3076         }
3077
3078         DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d total_data=%d\n",
3079                 fname,fsp ? fsp->fnum : -1, info_level,tran_call,total_data));
3080
3081         p = strrchr_m(fname,'/');
3082         if (!p)
3083                 base_name = fname;
3084         else
3085                 base_name = p+1;
3086
3087         mode = dos_mode(conn,fname,&sbuf);
3088         if (!mode)
3089                 mode = FILE_ATTRIBUTE_NORMAL;
3090
3091         fullpathname = fname;
3092         if (!(mode & aDIR))
3093                 file_size = get_file_size(sbuf);
3094
3095         /* Pull out any data sent here before we realloc. */
3096         switch (info_level) {
3097                 case SMB_INFO_QUERY_EAS_FROM_LIST:
3098                 {
3099                         /* Pull any EA list from the data portion. */
3100                         uint32 ea_size;
3101
3102                         if (total_data < 4) {
3103                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3104                         }
3105                         ea_size = IVAL(pdata,0);
3106
3107                         if (total_data > 0 && ea_size != total_data) {
3108                                 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
3109 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
3110                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3111                         }
3112
3113                         if (!lp_ea_support(SNUM(conn))) {
3114                                 return ERROR_DOS(ERRDOS,ERReasnotsupported);
3115                         }
3116
3117                         if ((data_ctx = talloc_init("ea_list")) == NULL) {
3118                                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3119                         }
3120
3121                         /* Pull out the list of names. */
3122                         ea_list = read_ea_name_list(data_ctx, pdata + 4, ea_size - 4);
3123                         if (!ea_list) {
3124                                 talloc_destroy(data_ctx);
3125                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3126                         }
3127                         break;
3128                 }
3129
3130                 case SMB_QUERY_POSIX_LOCK:
3131                 {
3132                         if (fsp == NULL || fsp->fh->fd == -1) {
3133                                 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
3134                         }
3135
3136                         if (total_data != POSIX_LOCK_DATA_SIZE) {
3137                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3138                         }
3139
3140                         if ((data_ctx = talloc_init("lock_request")) == NULL) {
3141                                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3142                         }
3143
3144                         /* Copy the lock range data. */
3145                         lock_data = (char *)talloc_memdup(
3146                                 data_ctx, pdata, total_data);
3147                         if (!lock_data) {
3148                                 talloc_destroy(data_ctx);
3149                                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3150                         }
3151                 }
3152                 default:
3153                         break;
3154         }
3155
3156         *pparams = (char *)SMB_REALLOC(*pparams,2);
3157         if (*pparams == NULL) {
3158                 talloc_destroy(data_ctx);
3159                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3160         }
3161         params = *pparams;
3162         SSVAL(params,0,0);
3163         data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
3164         *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
3165         if (*ppdata == NULL ) {
3166                 talloc_destroy(data_ctx);
3167                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3168         }
3169         pdata = *ppdata;
3170
3171         create_time_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
3172         mtime_ts = get_mtimespec(&sbuf);
3173         atime_ts = get_atimespec(&sbuf);
3174
3175         allocation_size = get_allocation_size(conn,fsp,&sbuf);
3176
3177         if (fsp) {
3178                 if (fsp->pending_modtime) {
3179                         /* the pending modtime overrides the current modtime */
3180                         mtime_ts.tv_sec = fsp->pending_modtime;
3181                         mtime_ts.tv_nsec = 0;
3182                 }
3183         } else {
3184                 /* Do we have this path open ? */
3185                 files_struct *fsp1 = file_find_di_first(sbuf.st_dev, sbuf.st_ino);
3186                 if (fsp1 && fsp1->pending_modtime) {
3187                         /* the pending modtime overrides the current modtime */
3188                         mtime_ts.tv_sec = fsp1->pending_modtime;
3189                         mtime_ts.tv_nsec = 0;
3190                 }
3191                 if (fsp1 && fsp1->initial_allocation_size) {
3192                         allocation_size = get_allocation_size(conn, fsp1, &sbuf);
3193                 }
3194         }
3195
3196         if (lp_dos_filetime_resolution(SNUM(conn))) {
3197                 dos_filetime_timespec(&create_time_ts);
3198                 dos_filetime_timespec(&mtime_ts);
3199                 dos_filetime_timespec(&atime_ts);
3200         }
3201
3202         create_time = convert_timespec_to_time_t(create_time_ts);
3203         mtime = convert_timespec_to_time_t(mtime_ts);
3204         atime = convert_timespec_to_time_t(atime_ts);
3205
3206         /* NT expects the name to be in an exact form of the *full*
3207            filename. See the trans2 torture test */
3208         if (strequal(base_name,".")) {
3209                 pstrcpy(dos_fname, "\\");
3210         } else {
3211                 pstr_sprintf(dos_fname, "\\%s", fname);
3212                 string_replace(dos_fname, '/', '\\');
3213         }
3214
3215         switch (info_level) {
3216                 case SMB_INFO_STANDARD:
3217                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_STANDARD\n"));
3218                         data_size = 22;
3219                         srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
3220                         srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
3221                         srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
3222                         SIVAL(pdata,l1_cbFile,(uint32)file_size);
3223                         SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
3224                         SSVAL(pdata,l1_attrFile,mode);
3225                         break;
3226
3227                 case SMB_INFO_QUERY_EA_SIZE:
3228                 {
3229                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3230                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
3231                         data_size = 26;
3232                         srv_put_dos_date2(pdata,0,create_time);
3233                         srv_put_dos_date2(pdata,4,atime);
3234                         srv_put_dos_date2(pdata,8,mtime); /* write time */
3235                         SIVAL(pdata,12,(uint32)file_size);
3236                         SIVAL(pdata,16,(uint32)allocation_size);
3237                         SSVAL(pdata,20,mode);
3238                         SIVAL(pdata,22,ea_size);
3239                         break;
3240                 }
3241
3242                 case SMB_INFO_IS_NAME_VALID:
3243                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
3244                         if (tran_call == TRANSACT2_QFILEINFO) {
3245                                 /* os/2 needs this ? really ?*/
3246                                 return ERROR_DOS(ERRDOS,ERRbadfunc);
3247                         }
3248                         data_size = 0;
3249                         param_size = 0;
3250                         break;
3251
3252                 case SMB_INFO_QUERY_EAS_FROM_LIST:
3253                 {
3254                         size_t total_ea_len = 0;
3255                         struct ea_list *ea_file_list = NULL;
3256
3257                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
3258
3259                         ea_file_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3260                         ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
3261
3262                         if (!ea_list || (total_ea_len > data_size)) {
3263                                 talloc_destroy(data_ctx);
3264                                 data_size = 4;
3265                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
3266                                 break;
3267                         }
3268
3269                         data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3270                         talloc_destroy(data_ctx);
3271                         break;
3272                 }
3273
3274                 case SMB_INFO_QUERY_ALL_EAS:
3275                 {
3276                         /* We have data_size bytes to put EA's into. */
3277                         size_t total_ea_len = 0;
3278
3279                         DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
3280
3281                         data_ctx = talloc_init("ea_ctx");
3282                         if (!data_ctx) {
3283                                 return ERROR_NT(NT_STATUS_NO_MEMORY);
3284                         }
3285
3286                         ea_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3287                         if (!ea_list || (total_ea_len > data_size)) {
3288                                 talloc_destroy(data_ctx);
3289                                 data_size = 4;
3290                                 SIVAL(pdata,0,4);   /* EA List Length must be set to 4 if no EA's. */
3291                                 break;
3292                         }
3293
3294                         data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3295                         talloc_destroy(data_ctx);
3296                         break;
3297                 }
3298
3299                 case SMB_FILE_BASIC_INFORMATION:
3300                 case SMB_QUERY_FILE_BASIC_INFO:
3301
3302                         if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
3303                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
3304                                 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
3305                         } else {
3306                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
3307                                 data_size = 40;
3308                                 SIVAL(pdata,36,0);
3309                         }
3310                         put_long_date_timespec(pdata,create_time_ts);
3311                         put_long_date_timespec(pdata+8,atime_ts);
3312                         put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3313                         put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3314                         SIVAL(pdata,32,mode);
3315
3316                         DEBUG(5,("SMB_QFBI - "));
3317                         DEBUG(5,("create: %s ", ctime(&create_time)));
3318                         DEBUG(5,("access: %s ", ctime(&atime)));
3319                         DEBUG(5,("write: %s ", ctime(&mtime)));
3320                         DEBUG(5,("change: %s ", ctime(&mtime)));
3321                         DEBUG(5,("mode: %x\n", mode));
3322                         break;
3323
3324                 case SMB_FILE_STANDARD_INFORMATION:
3325                 case SMB_QUERY_FILE_STANDARD_INFO:
3326
3327                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
3328                         data_size = 24;
3329                         SOFF_T(pdata,0,allocation_size);
3330                         SOFF_T(pdata,8,file_size);
3331                         SIVAL(pdata,16,nlink);
3332                         SCVAL(pdata,20,delete_pending?1:0);
3333                         SCVAL(pdata,21,(mode&aDIR)?1:0);
3334                         SSVAL(pdata,22,0); /* Padding. */
3335                         break;
3336
3337                 case SMB_FILE_EA_INFORMATION:
3338                 case SMB_QUERY_FILE_EA_INFO:
3339                 {
3340                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3341                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
3342                         data_size = 4;
3343                         SIVAL(pdata,0,ea_size);
3344                         break;
3345                 }
3346
3347                 /* Get the 8.3 name - used if NT SMB was negotiated. */
3348                 case SMB_QUERY_FILE_ALT_NAME_INFO:
3349                 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
3350                 {
3351                         pstring short_name;
3352
3353                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
3354                         pstrcpy(short_name,base_name);
3355                         /* Mangle if not already 8.3 */
3356                         if(!mangle_is_8_3(short_name, True, conn->params)) {
3357                                 mangle_map(short_name,True,True,conn->params);
3358                         }
3359                         len = srvstr_push(outbuf, pdata+4, short_name, -1, STR_UNICODE);
3360                         data_size = 4 + len;
3361                         SIVAL(pdata,0,len);
3362                         break;
3363                 }
3364
3365                 case SMB_QUERY_FILE_NAME_INFO:
3366                         /*
3367                           this must be *exactly* right for ACLs on mapped drives to work
3368                          */
3369                         len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
3370                         DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
3371                         data_size = 4 + len;
3372                         SIVAL(pdata,0,len);
3373                         break;
3374
3375                 case SMB_FILE_ALLOCATION_INFORMATION:
3376                 case SMB_QUERY_FILE_ALLOCATION_INFO:
3377                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
3378                         data_size = 8;
3379                         SOFF_T(pdata,0,allocation_size);
3380                         break;
3381
3382                 case SMB_FILE_END_OF_FILE_INFORMATION:
3383                 case SMB_QUERY_FILE_END_OF_FILEINFO:
3384                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
3385                         data_size = 8;
3386                         SOFF_T(pdata,0,file_size);
3387                         break;
3388
3389                 case SMB_QUERY_FILE_ALL_INFO:
3390                 case SMB_FILE_ALL_INFORMATION:
3391                 {
3392                         unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3393                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
3394                         put_long_date_timespec(pdata,create_time_ts);
3395                         put_long_date_timespec(pdata+8,atime_ts);
3396                         put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3397                         put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3398                         SIVAL(pdata,32,mode);
3399                         SIVAL(pdata,36,0); /* padding. */
3400                         pdata += 40;
3401                         SOFF_T(pdata,0,allocation_size);
3402                         SOFF_T(pdata,8,file_size);
3403                         SIVAL(pdata,16,nlink);
3404                         SCVAL(pdata,20,delete_pending);
3405                         SCVAL(pdata,21,(mode&aDIR)?1:0);
3406                         SSVAL(pdata,22,0);
3407                         pdata += 24;
3408                         SIVAL(pdata,0,ea_size);
3409                         pdata += 4; /* EA info */
3410                         len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
3411                         SIVAL(pdata,0,len);
3412                         pdata += 4 + len;
3413                         data_size = PTR_DIFF(pdata,(*ppdata));
3414                         break;
3415                 }
3416                 case SMB_FILE_INTERNAL_INFORMATION:
3417                         /* This should be an index number - looks like
3418                            dev/ino to me :-)
3419
3420                            I think this causes us to fail the IFSKIT
3421                            BasicFileInformationTest. -tpot */
3422
3423                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
3424                         SIVAL(pdata,0,sbuf.st_ino); /* FileIndexLow */
3425                         SIVAL(pdata,4,sbuf.st_dev); /* FileIndexHigh */
3426                         data_size = 8;
3427                         break;
3428
3429                 case SMB_FILE_ACCESS_INFORMATION:
3430                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
3431                         SIVAL(pdata,0,access_mask);
3432                         data_size = 4;
3433                         break;
3434
3435                 case SMB_FILE_NAME_INFORMATION:
3436                         /* Pathname with leading '\'. */
3437                         {
3438                                 size_t byte_len;
3439                                 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
3440                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
3441                                 SIVAL(pdata,0,byte_len);
3442                                 data_size = 4 + byte_len;
3443                                 break;
3444                         }
3445
3446                 case SMB_FILE_DISPOSITION_INFORMATION:
3447                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
3448                         data_size = 1;
3449                         SCVAL(pdata,0,delete_pending);
3450                         break;
3451
3452                 case SMB_FILE_POSITION_INFORMATION:
3453                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
3454                         data_size = 8;
3455                         SOFF_T(pdata,0,pos);
3456                         break;
3457
3458                 case SMB_FILE_MODE_INFORMATION:
3459                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
3460                         SIVAL(pdata,0,mode);
3461                         data_size = 4;
3462                         break;
3463
3464                 case SMB_FILE_ALIGNMENT_INFORMATION:
3465                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
3466                         SIVAL(pdata,0,0); /* No alignment needed. */
3467                         data_size = 4;
3468                         break;
3469
3470 #if 0
3471                 /*
3472                  * NT4 server just returns "invalid query" to this - if we try to answer
3473                  * it then NTws gets a BSOD! (tridge).
3474                  * W2K seems to want this. JRA.
3475                  */
3476                 case SMB_QUERY_FILE_STREAM_INFO:
3477 #endif
3478                 case SMB_FILE_STREAM_INFORMATION:
3479                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STREAM_INFORMATION\n"));
3480                         if (mode & aDIR) {
3481                                 data_size = 0;
3482                         } else {
3483                                 size_t byte_len = dos_PutUniCode(pdata+24,"::$DATA", (size_t)0xE, False);
3484                                 SIVAL(pdata,0,0); /* ??? */
3485                                 SIVAL(pdata,4,byte_len); /* Byte length of unicode string ::$DATA */
3486                                 SOFF_T(pdata,8,file_size);
3487                                 SIVAL(pdata,16,allocation_size);
3488                                 SIVAL(pdata,20,0); /* ??? */
3489                                 data_size = 24 + byte_len;
3490                         }
3491                         break;
3492
3493                 case SMB_QUERY_COMPRESSION_INFO:
3494                 case SMB_FILE_COMPRESSION_INFORMATION:
3495                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
3496                         SOFF_T(pdata,0,file_size);
3497                         SIVAL(pdata,8,0); /* ??? */
3498                         SIVAL(pdata,12,0); /* ??? */
3499                         data_size = 16;
3500                         break;
3501
3502                 case SMB_FILE_NETWORK_OPEN_INFORMATION:
3503                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
3504                         put_long_date_timespec(pdata,create_time_ts);
3505                         put_long_date_timespec(pdata+8,atime_ts);
3506                         put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3507                         put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3508                         SIVAL(pdata,32,allocation_size);
3509                         SOFF_T(pdata,40,file_size);
3510                         SIVAL(pdata,48,mode);
3511                         SIVAL(pdata,52,0); /* ??? */
3512                         data_size = 56;
3513                         break;
3514
3515                 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
3516                         DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
3517                         SIVAL(pdata,0,mode);
3518                         SIVAL(pdata,4,0);
3519                         data_size = 8;
3520                         break;
3521
3522                 /*
3523                  * CIFS UNIX Extensions.
3524                  */
3525
3526                 case SMB_QUERY_FILE_UNIX_BASIC:
3527
3528                         pdata = store_file_unix_basic(conn, pdata, fsp, &sbuf);
3529                         data_size = PTR_DIFF(pdata,(*ppdata));
3530
3531                         {
3532                                 int i;
3533                                 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC "));
3534
3535                                 for (i=0; i<100; i++)
3536                                         DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
3537                                 DEBUG(4,("\n"));
3538                         }
3539
3540                         break;
3541
3542                 case SMB_QUERY_FILE_UNIX_LINK:
3543                         {
3544                                 pstring buffer;
3545
3546                                 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
3547 #ifdef S_ISLNK
3548                                 if(!S_ISLNK(sbuf.st_mode))
3549                                         return(UNIXERROR(ERRSRV,ERRbadlink));
3550 #else
3551                                 return(UNIXERROR(ERRDOS,ERRbadlink));
3552 #endif
3553                                 len = SMB_VFS_READLINK(conn,fullpathname, buffer, sizeof(pstring)-1);     /* read link */
3554                                 if (len == -1)
3555                                         return(UNIXERROR(ERRDOS,ERRnoaccess));
3556                                 buffer[len] = 0;
3557                                 len = srvstr_push(outbuf, pdata, buffer, -1, STR_TERMINATE);
3558                                 pdata += len;
3559                                 data_size = PTR_DIFF(pdata,(*ppdata));
3560
3561                                 break;
3562                         }
3563
3564 #if defined(HAVE_POSIX_ACLS)
3565                 case SMB_QUERY_POSIX_ACL:
3566                         {
3567                                 SMB_ACL_T file_acl = NULL;
3568                                 SMB_ACL_T def_acl = NULL;
3569                                 uint16 num_file_acls = 0;
3570                                 uint16 num_def_acls = 0;
3571
3572                                 if (fsp && !fsp->is_directory && (fsp->fh->fd != -1)) {
3573                                         file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp, fsp->fh->fd);
3574                                 } else {
3575                                         file_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_ACCESS);
3576                                 }
3577
3578                                 if (file_acl == NULL && no_acl_syscall_error(errno)) {
3579                                         DEBUG(5,("call_trans2qfilepathinfo: ACLs not implemented on filesystem containing %s\n",
3580                                                 fname ));
3581                                         return ERROR_NT(NT_STATUS_NOT_IMPLEMENTED);
3582                                 }
3583
3584                                 if (S_ISDIR(sbuf.st_mode)) {
3585                                         if (fsp && fsp->is_directory) {
3586                                                 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fsp->fsp_name, SMB_ACL_TYPE_DEFAULT);
3587                                         } else {
3588                                                 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_DEFAULT);
3589                                         }
3590                                         def_acl = free_empty_sys_acl(conn, def_acl);
3591                                 }
3592
3593                                 num_file_acls = count_acl_entries(conn, file_acl);
3594                                 num_def_acls = count_acl_entries(conn, def_acl);
3595
3596                                 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
3597                                         DEBUG(5,("call_trans2qfilepathinfo: data_size too small (%u) need %u\n",
3598                                                 data_size,
3599                                                 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
3600                                                         SMB_POSIX_ACL_HEADER_SIZE) ));
3601                                         if (file_acl) {
3602                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3603                                         }
3604                                         if (def_acl) {
3605                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3606                                         }
3607                                         return ERROR_NT(NT_STATUS_BUFFER_TOO_SMALL);
3608                                 }
3609
3610                                 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
3611                                 SSVAL(pdata,2,num_file_acls);
3612                                 SSVAL(pdata,4,num_def_acls);
3613                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, &sbuf, file_acl)) {
3614                                         if (file_acl) {
3615                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3616                                         }
3617                                         if (def_acl) {
3618                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3619                                         }
3620                                         return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
3621                                 }
3622                                 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), &sbuf, def_acl)) {
3623                                         if (file_acl) {
3624                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3625                                         }
3626                                         if (def_acl) {
3627                                                 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3628                                         }
3629                                         return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
3630                                 }
3631
3632                                 if (file_acl) {
3633                                         SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3634                                 }
3635                                 if (def_acl) {
3636                                         SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3637                                 }
3638                                 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
3639                                 break;
3640                         }
3641 #endif
3642
3643
3644                 case SMB_QUERY_POSIX_LOCK:
3645                 {
3646                         NTSTATUS status = NT_STATUS_INVALID_LEVEL;
3647                         SMB_BIG_UINT count;
3648                         SMB_BIG_UINT offset;
3649                         uint32 lock_pid;
3650                         enum brl_type lock_type;
3651
3652                         if (total_data != POSIX_LOCK_DATA_SIZE) {
3653                                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3654                         }
3655
3656                         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
3657                                 case POSIX_LOCK_TYPE_READ:
3658                                         lock_type = READ_LOCK;
3659                                         break;
3660                                 case POSIX_LOCK_TYPE_WRITE:
3661                                         lock_type = WRITE_LOCK;
3662                                         break;
3663                                 case POSIX_LOCK_TYPE_UNLOCK:
3664                                 default:
3665                                         /* There's no point in asking for an unlock... */
3666                                         talloc_destroy(data_ctx);
3667                                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3668                         }
3669
3670                         lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
3671 #if defined(HAVE_LONGLONG)
3672                         offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
3673                                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
3674                         count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
3675                                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
3676 #else /* HAVE_LONGLONG */
3677                         offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
3678                         count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
3679 #endif /* HAVE_LONGLONG */
3680
3681                         status = query_lock(fsp,
3682                                         &lock_pid,
3683                                         &count,
3684                                         &offset,
3685                                         &lock_type,
3686                                         POSIX_LOCK);
3687
3688                         if (ERROR_WAS_LOCK_DENIED(status)) {
3689                                 /* Here we need to report who has it locked... */
3690                                 data_size = POSIX_LOCK_DATA_SIZE;
3691
3692                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
3693                                 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
3694                                 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, lock_pid);
3695 #if defined(HAVE_LONGLONG)
3696                                 SIVAL(pdata, POSIX_LOCK_START_OFFSET, (uint32)(offset & 0xFFFFFFFF));
3697                                 SIVAL(pdata, POSIX_LOCK_START_OFFSET + 4, (uint32)((offset >> 32) & 0xFFFFFFFF));
3698                                 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, (uint32)(count & 0xFFFFFFFF));
3699                                 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET + 4, (uint32)((count >> 32) & 0xFFFFFFFF));
3700 #else /* HAVE_LONGLONG */
3701                                 SIVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
3702                                 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
3703 #endif /* HAVE_LONGLONG */
3704
3705                         } else if (NT_STATUS_IS_OK(status)) {
3706                                 /* For success we just return a copy of what we sent
3707                                    with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
3708                                 data_size = POSIX_LOCK_DATA_SIZE;
3709                                 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
3710                                 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
3711                         } else {
3712                                 return ERROR_NT(status);
3713                         }
3714                         break;
3715                 }
3716
3717                 default:
3718                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3719         }
3720
3721         send_trans2_replies(outbuf, bufsize, params, param_size, *ppdata, data_size, max_data_bytes);
3722
3723         return(-1);
3724 }
3725
3726 /****************************************************************************
3727  Set a hard link (called by UNIX extensions and by NT rename with HARD link
3728  code.
3729 ****************************************************************************/
3730
3731 NTSTATUS hardlink_internals(connection_struct *conn, pstring oldname, pstring newname)
3732 {
3733         SMB_STRUCT_STAT sbuf1, sbuf2;
3734         pstring last_component_oldname;
3735         pstring last_component_newname;
3736         NTSTATUS status = NT_STATUS_OK;
3737
3738         ZERO_STRUCT(sbuf1);
3739         ZERO_STRUCT(sbuf2);
3740
3741         status = unix_convert(conn, oldname, False, last_component_oldname, &sbuf1);
3742         if (!NT_STATUS_IS_OK(status)) {
3743                 return status;
3744         }
3745
3746         /* source must already exist. */
3747         if (!VALID_STAT(sbuf1)) {
3748                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3749         }
3750
3751         status = check_name(conn, oldname);
3752         if (!NT_STATUS_IS_OK(status)) {
3753                 return NT_STATUS_ACCESS_DENIED;
3754         }
3755
3756         status = unix_convert(conn, newname, False, last_component_newname, &sbuf2);
3757         if (!NT_STATUS_IS_OK(status)) {
3758                 return status;
3759         }
3760
3761         /* Disallow if newname already exists. */
3762         if (VALID_STAT(sbuf2)) {
3763                 return NT_STATUS_OBJECT_NAME_COLLISION;
3764         }
3765
3766         status = check_name(conn, newname);
3767         if (!NT_STATUS_IS_OK(status)) {
3768                 return NT_STATUS_ACCESS_DENIED;
3769         }
3770
3771         /* No links from a directory. */
3772         if (S_ISDIR(sbuf1.st_mode)) {
3773                 return NT_STATUS_FILE_IS_A_DIRECTORY;
3774         }
3775
3776         /* Ensure this is within the share. */
3777         status = reduce_name(conn, oldname);
3778         if (!NT_STATUS_IS_OK(status)) {
3779                 return status;
3780         }
3781
3782         DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n", newname, oldname ));
3783
3784         if (SMB_VFS_LINK(conn,oldname,newname) != 0) {
3785                 status = map_nt_error_from_unix(errno);
3786                 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
3787                                 nt_errstr(status), newname, oldname));
3788         }
3789
3790         return status;
3791 }
3792
3793 /****************************************************************************
3794  Deal with setting the time from any of the setfilepathinfo functions.
3795 ****************************************************************************/
3796
3797 static NTSTATUS smb_set_file_time(connection_struct *conn,
3798                                 files_struct *fsp,
3799                                 const char *fname,
3800                                 const SMB_STRUCT_STAT *psbuf,
3801                                 struct utimbuf tvs)
3802 {
3803         uint32 action =
3804                 FILE_NOTIFY_CHANGE_LAST_ACCESS
3805                 |FILE_NOTIFY_CHANGE_LAST_WRITE;
3806
3807
3808         if (!VALID_STAT(*psbuf)) {
3809                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3810         }
3811
3812         /* get some defaults (no modifications) if any info is zero or -1. */
3813         if (null_mtime(tvs.actime)) {
3814                 tvs.actime = psbuf->st_atime;
3815                 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
3816         }
3817
3818         if (null_mtime(tvs.modtime)) {
3819                 tvs.modtime = psbuf->st_mtime;
3820                 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
3821         }
3822
3823         DEBUG(6,("smb_set_file_time: actime: %s " , ctime(&tvs.actime)));
3824         DEBUG(6,("smb_set_file_time: modtime: %s ", ctime(&tvs.modtime)));
3825
3826         /*
3827          * Try and set the times of this file if
3828          * they are different from the current values.
3829          */
3830
3831         if (psbuf->st_mtime == tvs.modtime && psbuf->st_atime == tvs.actime) {
3832                 return NT_STATUS_OK;
3833         }
3834
3835         if(fsp != NULL) {
3836                 /*
3837                  * This was a setfileinfo on an open file.
3838                  * NT does this a lot. We also need to
3839                  * set the time here, as it can be read by
3840                  * FindFirst/FindNext and with the patch for bug #2045
3841                  * in smbd/fileio.c it ensures that this timestamp is
3842                  * kept sticky even after a write. We save the request
3843                  * away and will set it on file close and after a write. JRA.
3844                  */
3845
3846                 if (tvs.modtime != (time_t)0 && tvs.modtime != (time_t)-1) {
3847                         DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n", ctime(&tvs.modtime) ));
3848                         fsp_set_pending_modtime(fsp, tvs.modtime);
3849                 }
3850
3851         }
3852         DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
3853
3854         if(file_utime(conn, fname, &tvs)!=0) {
3855                 return map_nt_error_from_unix(errno);
3856         }
3857         if (action != 0) {
3858                 notify_fname(conn, NOTIFY_ACTION_MODIFIED, action, fname);
3859         }
3860         return NT_STATUS_OK;
3861 }
3862
3863 /****************************************************************************
3864  Deal with setting the dosmode from any of the setfilepathinfo functions.
3865 ****************************************************************************/
3866
3867 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
3868                                 const char *fname,
3869                                 SMB_STRUCT_STAT *psbuf,
3870                                 uint32 dosmode)
3871 {
3872         if (!VALID_STAT(*psbuf)) {
3873                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3874         }
3875
3876         if (dosmode) {
3877                 if (S_ISDIR(psbuf->st_mode)) {
3878                         dosmode |= aDIR;
3879                 } else {
3880                         dosmode &= ~aDIR;
3881                 }
3882         }
3883
3884         DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
3885
3886         /* check the mode isn't different, before changing it */
3887         if ((dosmode != 0) && (dosmode != dos_mode(conn, fname, psbuf))) {
3888
3889                 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode 0x%x\n",
3890                                         fname, (unsigned int)dosmode ));
3891
3892                 if(file_set_dosmode(conn, fname, dosmode, psbuf, False)) {
3893                         DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of %s failed (%s)\n",
3894                                                 fname, strerror(errno)));
3895                         return map_nt_error_from_unix(errno);
3896                 }
3897         }
3898         return NT_STATUS_OK;
3899 }
3900
3901 /****************************************************************************
3902  Deal with setting the size from any of the setfilepathinfo functions.
3903 ****************************************************************************/
3904
3905 static NTSTATUS smb_set_file_size(connection_struct *conn,
3906                                 files_struct *fsp,
3907                                 const char *fname,
3908                                 SMB_STRUCT_STAT *psbuf,
3909                                 SMB_OFF_T size)
3910 {
3911         NTSTATUS status = NT_STATUS_OK;
3912         files_struct *new_fsp = NULL;
3913
3914         if (!VALID_STAT(*psbuf)) {
3915                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3916         }
3917
3918         DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
3919
3920         if (size == get_file_size(*psbuf)) {
3921                 return NT_STATUS_OK;
3922         }
3923
3924         DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
3925                 fname, (double)size ));
3926
3927         if (fsp && fsp->fh->fd != -1) {
3928                 /* Handle based call. */
3929                 if (vfs_set_filelen(fsp, size) == -1) {
3930                         return map_nt_error_from_unix(errno);
3931                 }
3932                 return NT_STATUS_OK;
3933         }
3934
3935         status = open_file_ntcreate(conn, fname, psbuf,
3936                                 FILE_WRITE_DATA,
3937                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3938                                 FILE_OPEN,
3939                                 0,
3940                                 FILE_ATTRIBUTE_NORMAL,
3941                                 FORCE_OPLOCK_BREAK_TO_NONE,
3942                                 NULL, &new_fsp);
3943
3944         if (!NT_STATUS_IS_OK(status)) {
3945                 /* NB. We check for open_was_deferred in the caller. */
3946                 return status;
3947         }
3948
3949         if (vfs_set_filelen(new_fsp, size) == -1) {
3950                 status = map_nt_error_from_unix(errno);
3951                 close_file(new_fsp,NORMAL_CLOSE);
3952                 return status;
3953         }
3954
3955         close_file(new_fsp,NORMAL_CLOSE);
3956         return NT_STATUS_OK;
3957 }
3958
3959 /****************************************************************************
3960  Deal with SMB_INFO_SET_EA.
3961 ****************************************************************************/
3962
3963 static NTSTATUS smb_info_set_ea(connection_struct *conn,
3964                                 const char *pdata,
3965                                 int total_data,
3966                                 files_struct *fsp,
3967                                 const char *fname)
3968 {
3969         struct ea_list *ea_list = NULL;
3970         TALLOC_CTX *ctx = NULL;
3971         NTSTATUS status = NT_STATUS_OK;
3972
3973         if (total_data < 10) {
3974
3975                 /* OS/2 workplace shell seems to send SET_EA requests of "null"
3976                    length. They seem to have no effect. Bug #3212. JRA */
3977
3978                 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
3979                         /* We're done. We only get EA info in this call. */
3980                         return NT_STATUS_OK;
3981                 }
3982
3983                 return NT_STATUS_INVALID_PARAMETER;
3984         }
3985
3986         if (IVAL(pdata,0) > total_data) {
3987                 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
3988                         IVAL(pdata,0), (unsigned int)total_data));
3989                 return NT_STATUS_INVALID_PARAMETER;
3990         }
3991
3992         ctx = talloc_init("SMB_INFO_SET_EA");
3993         if (!ctx) {
3994                 return NT_STATUS_NO_MEMORY;
3995         }
3996         ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
3997         if (!ea_list) {
3998                 talloc_destroy(ctx);
3999                 return NT_STATUS_INVALID_PARAMETER;
4000         }
4001         status = set_ea(conn, fsp, fname, ea_list);
4002         talloc_destroy(ctx);
4003
4004         return status;
4005 }
4006
4007 /****************************************************************************
4008  Deal with SMB_SET_FILE_DISPOSITION_INFO.
4009 ****************************************************************************/
4010
4011 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
4012                                 const char *pdata,
4013                                 int total_data,
4014                                 files_struct *fsp,
4015                                 const char *fname,
4016                                 SMB_STRUCT_STAT *psbuf)
4017 {
4018         NTSTATUS status = NT_STATUS_OK;
4019         BOOL delete_on_close;
4020         uint32 dosmode = 0;
4021
4022         if (total_data < 1) {
4023                 return NT_STATUS_INVALID_PARAMETER;
4024         }
4025
4026         if (fsp == NULL) {
4027                 return NT_STATUS_INVALID_HANDLE;
4028         }
4029
4030         delete_on_close = (CVAL(pdata,0) ? True : False);
4031         dosmode = dos_mode(conn, fname, psbuf);
4032
4033         status = can_set_delete_on_close(fsp, delete_on_close, dosmode);
4034
4035         if (!NT_STATUS_IS_OK(status)) {
4036                 return status;
4037         }
4038
4039         /* The set is across all open files on this dev/inode pair. */
4040         if (!set_delete_on_close(fsp, delete_on_close, &current_user.ut)) {
4041                 return NT_STATUS_ACCESS_DENIED;
4042         }
4043         return NT_STATUS_OK;
4044 }
4045
4046 /****************************************************************************
4047  Deal with SMB_FILE_POSITION_INFORMATION.
4048 ****************************************************************************/
4049
4050 static NTSTATUS smb_file_position_information(connection_struct *conn,
4051                                 const char *pdata,
4052                                 int total_data,
4053                                 files_struct *fsp)
4054 {
4055         SMB_BIG_UINT position_information;
4056
4057         if (total_data < 8) {
4058                 return NT_STATUS_INVALID_PARAMETER;
4059         }
4060
4061         if (fsp == NULL) {
4062                 /* Ignore on pathname based set. */
4063                 return NT_STATUS_OK;
4064         }
4065
4066         position_information = (SMB_BIG_UINT)IVAL(pdata,0);
4067 #ifdef LARGE_SMB_OFF_T
4068         position_information |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
4069 #else /* LARGE_SMB_OFF_T */
4070         if (IVAL(pdata,4) != 0) {
4071                 /* more than 32 bits? */
4072                 return NT_STATUS_INVALID_PARAMETER;
4073         }
4074 #endif /* LARGE_SMB_OFF_T */
4075
4076         DEBUG(10,("smb_file_position_information: Set file position information for file %s to %.0f\n",
4077                 fsp->fsp_name, (double)position_information ));
4078         fsp->fh->position_information = position_information;
4079         return NT_STATUS_OK;
4080 }
4081
4082 /****************************************************************************
4083  Deal with SMB_FILE_MODE_INFORMATION.
4084 ****************************************************************************/
4085
4086 static NTSTATUS smb_file_mode_information(connection_struct *conn,
4087                                 const char *pdata,
4088                                 int total_data)
4089 {
4090         uint32 mode;
4091
4092         if (total_data < 4) {
4093                 return NT_STATUS_INVALID_PARAMETER;
4094         }
4095         mode = IVAL(pdata,0);
4096         if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
4097                 return NT_STATUS_INVALID_PARAMETER;
4098         }
4099         return NT_STATUS_OK;
4100 }
4101
4102 /****************************************************************************
4103  Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
4104 ****************************************************************************/
4105
4106 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
4107                                 char *inbuf,
4108                                 const char *pdata,
4109                                 int total_data,
4110                                 const char *fname)
4111 {
4112         pstring link_target;
4113         const char *newname = fname;
4114         NTSTATUS status = NT_STATUS_OK;
4115
4116         /* Set a symbolic link. */
4117         /* Don't allow this if follow links is false. */
4118
4119         if (total_data == 0) {
4120                 return NT_STATUS_INVALID_PARAMETER;
4121         }
4122
4123         if (!lp_symlinks(SNUM(conn))) {
4124                 return NT_STATUS_ACCESS_DENIED;
4125         }
4126
4127         srvstr_pull(inbuf, link_target, pdata, sizeof(link_target), total_data, STR_TERMINATE);
4128
4129         /* !widelinks forces the target path to be within the share. */
4130         /* This means we can interpret the target as a pathname. */
4131         if (!lp_widelinks(SNUM(conn))) {
4132                 pstring rel_name;
4133                 char *last_dirp = NULL;
4134
4135                 unix_format(link_target);
4136                 if (*link_target == '/') {
4137                         /* No absolute paths allowed. */
4138                         return NT_STATUS_ACCESS_DENIED;
4139                 }
4140                 pstrcpy(rel_name, newname);
4141                 last_dirp = strrchr_m(rel_name, '/');
4142                 if (last_dirp) {
4143                         last_dirp[1] = '\0';
4144                 } else {
4145                         pstrcpy(rel_name, "./");
4146                 }
4147                 pstrcat(rel_name, link_target);
4148
4149                 status = check_name(conn, rel_name);
4150                 if (!NT_STATUS_IS_OK(status)) {
4151                         return status;
4152                 }
4153         }
4154
4155         DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
4156                         newname, link_target ));
4157
4158         if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
4159                 return map_nt_error_from_unix(errno);
4160         }
4161
4162         return NT_STATUS_OK;
4163 }
4164
4165 /****************************************************************************
4166  Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
4167 ****************************************************************************/
4168
4169 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
4170                                 char *inbuf,
4171                                 char *outbuf,
4172                                 const char *pdata,
4173                                 int total_data,
4174                                 pstring fname)
4175 {
4176         pstring oldname;
4177         NTSTATUS status = NT_STATUS_OK;
4178
4179         /* Set a hard link. */
4180         if (total_data == 0) {
4181                 return NT_STATUS_INVALID_PARAMETER;
4182         }
4183
4184         srvstr_get_path(inbuf, oldname, pdata, sizeof(oldname), total_data, STR_TERMINATE, &status);
4185         if (!NT_STATUS_IS_OK(status)) {
4186                 return status;
4187         }
4188
4189         RESOLVE_DFSPATH_STATUS(oldname, conn, inbuf, outbuf);
4190
4191         DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
4192                 fname, oldname));
4193
4194         return hardlink_internals(conn, oldname, fname);
4195 }
4196
4197 /****************************************************************************
4198  Deal with SMB_FILE_RENAME_INFORMATION.
4199 ****************************************************************************/
4200
4201 static NTSTATUS smb_file_rename_information(connection_struct *conn,
4202                                 char *inbuf,
4203                                 char *outbuf,
4204                                 const char *pdata,
4205                                 int total_data,
4206                                 files_struct *fsp,
4207                                 pstring fname)
4208 {
4209         BOOL overwrite;
4210         /* uint32 root_fid; */  /* Not used */
4211         uint32 len;
4212         pstring newname;
4213         pstring base_name;
4214         NTSTATUS status = NT_STATUS_OK;
4215         char *p;
4216
4217         if (total_data < 13) {
4218                 return NT_STATUS_INVALID_PARAMETER;
4219         }
4220
4221         overwrite = (CVAL(pdata,0) ? True : False);
4222         /* root_fid = IVAL(pdata,4); */
4223         len = IVAL(pdata,8);
4224
4225         if (len > (total_data - 12) || (len == 0)) {
4226                 return NT_STATUS_INVALID_PARAMETER;
4227         }
4228
4229         srvstr_get_path(inbuf, newname, &pdata[12], sizeof(newname), len, 0, &status);
4230         if (!NT_STATUS_IS_OK(status)) {
4231                 return status;
4232         }
4233
4234         RESOLVE_DFSPATH_STATUS(newname, conn, inbuf, outbuf);
4235
4236         /* Check the new name has no '/' characters. */
4237         if (strchr_m(newname, '/')) {
4238                 return NT_STATUS_NOT_SUPPORTED;
4239         }
4240
4241         /* Create the base directory. */
4242         pstrcpy(base_name, fname);
4243         p = strrchr_m(base_name, '/');
4244         if (p) {
4245                 *p = '\0';
4246         }
4247         /* Append the new name. */
4248         pstrcat(base_name, "/");
4249         pstrcat(base_name, newname);
4250
4251         if (fsp) {
4252                 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
4253                         fsp->fnum, fsp->fsp_name, base_name ));
4254                 status = rename_internals_fsp(conn, fsp, base_name, 0, overwrite);
4255         } else {
4256                 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION %s -> %s\n",
4257                         fname, newname ));
4258                 status = rename_internals(conn, fname, base_name, 0, overwrite, False);
4259         }
4260
4261         return status;
4262 }
4263
4264 /****************************************************************************
4265  Deal with SMB_SET_POSIX_ACL.
4266 ****************************************************************************/
4267
4268 #if defined(HAVE_POSIX_ACLS)
4269 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
4270                                 const char *pdata,
4271                                 int total_data,
4272                                 files_struct *fsp,
4273                                 const char *fname,
4274                                 SMB_STRUCT_STAT *psbuf)
4275 {
4276         uint16 posix_acl_version;
4277         uint16 num_file_acls;
4278         uint16 num_def_acls;
4279         BOOL valid_file_acls = True;
4280         BOOL valid_def_acls = True;
4281
4282         if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
4283                 return NT_STATUS_INVALID_PARAMETER;
4284         }
4285         posix_acl_version = SVAL(pdata,0);
4286         num_file_acls = SVAL(pdata,2);
4287         num_def_acls = SVAL(pdata,4);
4288
4289         if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4290                 valid_file_acls = False;
4291                 num_file_acls = 0;
4292         }
4293
4294         if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4295                 valid_def_acls = False;
4296                 num_def_acls = 0;
4297         }
4298
4299         if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
4300                 return NT_STATUS_INVALID_PARAMETER;
4301         }
4302
4303         if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
4304                         (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
4305                 return NT_STATUS_INVALID_PARAMETER;
4306         }
4307
4308         if (valid_file_acls && !set_unix_posix_acl(conn, fsp, fname, num_file_acls,
4309                         pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
4310                 return map_nt_error_from_unix(errno);
4311         }
4312
4313         if (valid_def_acls && !set_unix_posix_default_acl(conn, fname, psbuf, num_def_acls,
4314                         pdata + SMB_POSIX_ACL_HEADER_SIZE +
4315                         (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
4316                 return map_nt_error_from_unix(errno);
4317         }
4318         return NT_STATUS_OK;
4319 }
4320 #endif
4321
4322 /****************************************************************************
4323  Deal with SMB_SET_POSIX_LOCK.
4324 ****************************************************************************/
4325
4326 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
4327                                 char *inbuf,
4328                                 int length,
4329                                 const char *pdata,
4330                                 int total_data,
4331                                 files_struct *fsp)
4332 {
4333         SMB_BIG_UINT count;
4334         SMB_BIG_UINT offset;
4335         uint32 lock_pid;
4336         BOOL blocking_lock = False;
4337         enum brl_type lock_type;
4338         NTSTATUS status = NT_STATUS_OK;
4339
4340         if (fsp == NULL || fsp->fh->fd == -1) {
4341                 return NT_STATUS_INVALID_HANDLE;
4342         }
4343
4344         if (total_data != POSIX_LOCK_DATA_SIZE) {
4345                 return NT_STATUS_INVALID_PARAMETER;
4346         }
4347
4348         switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4349                 case POSIX_LOCK_TYPE_READ:
4350                         lock_type = READ_LOCK;
4351                         break;
4352                 case POSIX_LOCK_TYPE_WRITE:
4353                         /* Return the right POSIX-mappable error code for files opened read-only. */
4354                         if (!fsp->can_write) {
4355                                 return NT_STATUS_INVALID_HANDLE;
4356                         }
4357                         lock_type = WRITE_LOCK;
4358                         break;
4359                 case POSIX_LOCK_TYPE_UNLOCK:
4360                         lock_type = UNLOCK_LOCK;
4361                         break;
4362                 default:
4363                         return NT_STATUS_INVALID_PARAMETER;
4364         }
4365
4366         if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
4367                 blocking_lock = False;
4368         } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
4369                 blocking_lock = True;
4370         } else {
4371                 return NT_STATUS_INVALID_PARAMETER;
4372         }
4373
4374         if (!lp_blocking_locks(SNUM(conn))) {
4375                 blocking_lock = False;
4376         }
4377
4378         lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4379 #if defined(HAVE_LONGLONG)
4380         offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4381                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4382         count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4383                         ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4384 #else /* HAVE_LONGLONG */
4385         offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4386         count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4387 #endif /* HAVE_LONGLONG */
4388
4389         if (lock_type == UNLOCK_LOCK) {
4390                 status = do_unlock(fsp,
4391                                 lock_pid,
4392                                 count,
4393                                 offset,
4394                                 POSIX_LOCK);
4395         } else {
4396                 struct byte_range_lock *br_lck = do_lock(fsp,
4397                                                         lock_pid,
4398                                                         count,
4399                                                         offset,
4400                                                         lock_type,
4401                                                         POSIX_LOCK,
4402                                                         blocking_lock,
4403                                                         &status);
4404
4405                 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
4406                         /*
4407                          * A blocking lock was requested. Package up
4408                          * this smb into a queued request and push it
4409                          * onto the blocking lock queue.
4410                          */
4411                         if(push_blocking_lock_request(br_lck,
4412                                                 inbuf, length,
4413                                                 fsp,
4414                                                 -1, /* infinite timeout. */
4415                                                 0,
4416                                                 lock_pid,
4417                                                 lock_type,
4418                                                 POSIX_LOCK,
4419                                                 offset,
4420                                                 count)) {
4421                                 TALLOC_FREE(br_lck);
4422                                 return status;
4423                         }
4424                 }
4425                 TALLOC_FREE(br_lck);
4426         }
4427
4428         return status;
4429 }
4430
4431 /****************************************************************************
4432  Deal with SMB_INFO_STANDARD.
4433 ****************************************************************************/
4434
4435 static NTSTATUS smb_set_info_standard(connection_struct *conn,
4436                                         const char *pdata,
4437                                         int total_data,
4438                                         files_struct *fsp,
4439                                         const char *fname,
4440                                         const SMB_STRUCT_STAT *psbuf)
4441 {
4442         struct utimbuf tvs;
4443
4444         if (total_data < 12) {
4445                 return NT_STATUS_INVALID_PARAMETER;
4446         }
4447
4448         /* access time */
4449         tvs.actime = srv_make_unix_date2(pdata+l1_fdateLastAccess);
4450         /* write time */
4451         tvs.modtime = srv_make_unix_date2(pdata+l1_fdateLastWrite);
4452
4453         return smb_set_file_time(conn,
4454                                 fsp,
4455                                 fname,
4456                                 psbuf,
4457                                 tvs);
4458 }
4459
4460 /****************************************************************************
4461  Deal with SMB_SET_FILE_BASIC_INFO.
4462 ****************************************************************************/
4463
4464 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
4465                                         const char *pdata,
4466                                         int total_data,
4467                                         files_struct *fsp,
4468                                         const char *fname,
4469                                         SMB_STRUCT_STAT *psbuf)
4470 {
4471         /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
4472         time_t write_time;
4473         time_t changed_time;
4474         uint32 dosmode = 0;
4475         struct utimbuf tvs;
4476         NTSTATUS status = NT_STATUS_OK;
4477
4478         if (total_data < 36) {
4479                 return NT_STATUS_INVALID_PARAMETER;
4480         }
4481
4482         /* Set the attributes */
4483         dosmode = IVAL(pdata,32);
4484         status = smb_set_file_dosmode(conn,
4485                                         fname,
4486                                         psbuf,
4487                                         dosmode);
4488         if (!NT_STATUS_IS_OK(status)) {
4489                 return status;
4490         }
4491
4492         /* Ignore create time at offset pdata. */
4493
4494         /* access time */
4495         tvs.actime = convert_timespec_to_time_t(interpret_long_date(pdata+8));
4496
4497         write_time = convert_timespec_to_time_t(interpret_long_date(pdata+16));
4498         changed_time = convert_timespec_to_time_t(interpret_long_date(pdata+24));
4499
4500         tvs.modtime = MIN(write_time, changed_time);
4501
4502         if (write_time > tvs.modtime && write_time != (time_t)-1) {
4503                 tvs.modtime = write_time;
4504         }
4505         /* Prefer a defined time to an undefined one. */
4506         if (null_mtime(tvs.modtime)) {
4507                 tvs.modtime = null_mtime(write_time) ? changed_time : write_time;
4508         }
4509
4510         return smb_set_file_time(conn,
4511                                 fsp,
4512                                 fname,
4513                                 psbuf,
4514                                 tvs);
4515 }
4516
4517 /****************************************************************************
4518  Deal with SMB_SET_FILE_ALLOCATION_INFO.
4519 ****************************************************************************/
4520
4521 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
4522                                         const char *pdata,
4523                                         int total_data,
4524                                         files_struct *fsp,
4525                                         const char *fname,
4526                                         SMB_STRUCT_STAT *psbuf)
4527 {
4528         SMB_BIG_UINT allocation_size = 0;
4529         NTSTATUS status = NT_STATUS_OK;
4530         files_struct *new_fsp = NULL;
4531
4532         if (!VALID_STAT(*psbuf)) {
4533                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4534         }
4535
4536         if (total_data < 8) {
4537                 return NT_STATUS_INVALID_PARAMETER;
4538         }
4539
4540         allocation_size = (SMB_BIG_UINT)IVAL(pdata,0);
4541 #ifdef LARGE_SMB_OFF_T
4542         allocation_size |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
4543 #else /* LARGE_SMB_OFF_T */
4544         if (IVAL(pdata,4) != 0) {
4545                 /* more than 32 bits? */
4546                 return NT_STATUS_INVALID_PARAMETER;
4547         }
4548 #endif /* LARGE_SMB_OFF_T */
4549
4550         DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for file %s to %.0f\n",
4551                         fname, (double)allocation_size ));
4552
4553         if (allocation_size) {
4554                 allocation_size = smb_roundup(conn, allocation_size);
4555         }
4556
4557         if(allocation_size == get_file_size(*psbuf)) {
4558                 return NT_STATUS_OK;
4559         }
4560
4561         DEBUG(10,("smb_set_file_allocation_info: file %s : setting new allocation size to %.0f\n",
4562                         fname, (double)allocation_size ));
4563
4564         if (fsp && fsp->fh->fd != -1) {
4565                 /* Open file handle. */
4566                 if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
4567                         return map_nt_error_from_unix(errno);
4568                 }
4569                 return NT_STATUS_OK;
4570         }
4571
4572         /* Pathname or stat or directory file. */
4573
4574         status = open_file_ntcreate(conn, fname, psbuf,
4575                                 FILE_WRITE_DATA,
4576                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4577                                 FILE_OPEN,
4578                                 0,
4579                                 FILE_ATTRIBUTE_NORMAL,
4580                                 FORCE_OPLOCK_BREAK_TO_NONE,
4581                                 NULL, &new_fsp);
4582
4583         if (!NT_STATUS_IS_OK(status)) {
4584                 /* NB. We check for open_was_deferred in the caller. */
4585                 return status;
4586         }
4587         if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
4588                 status = map_nt_error_from_unix(errno);
4589                 close_file(new_fsp,NORMAL_CLOSE);
4590                 return status;
4591         }
4592
4593         close_file(new_fsp,NORMAL_CLOSE);
4594         return NT_STATUS_OK;
4595 }
4596
4597 /****************************************************************************
4598  Deal with SMB_SET_FILE_END_OF_FILE_INFO.
4599 ****************************************************************************/
4600
4601 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
4602                                         const char *pdata,
4603                                         int total_data,
4604                                         files_struct *fsp,
4605                                         const char *fname,
4606                                         SMB_STRUCT_STAT *psbuf)
4607 {
4608         SMB_OFF_T size;
4609
4610         if (total_data < 8) {
4611                 return NT_STATUS_INVALID_PARAMETER;
4612         }
4613
4614         size = IVAL(pdata,0);
4615 #ifdef LARGE_SMB_OFF_T
4616         size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
4617 #else /* LARGE_SMB_OFF_T */
4618         if (IVAL(pdata,4) != 0) {
4619                 /* more than 32 bits? */
4620                 return NT_STATUS_INVALID_PARAMETER;
4621         }
4622 #endif /* LARGE_SMB_OFF_T */
4623         DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
4624                 "file %s to %.0f\n", fname, (double)size ));
4625
4626         return smb_set_file_size(conn,
4627                                 fsp,
4628                                 fname,
4629                                 psbuf,
4630                                 size);
4631 }
4632
4633 /****************************************************************************
4634  Allow a UNIX info mknod.
4635 ****************************************************************************/
4636
4637 static NTSTATUS smb_unix_mknod(connection_struct *conn,
4638                                         const char *pdata,
4639                                         int total_data,
4640                                         const char *fname,
4641                                         SMB_STRUCT_STAT *psbuf)
4642 {
4643         uint32 file_type = IVAL(pdata,56);
4644 #if defined(HAVE_MAKEDEV)
4645         uint32 dev_major = IVAL(pdata,60);
4646         uint32 dev_minor = IVAL(pdata,68);
4647 #endif
4648         SMB_DEV_T dev = (SMB_DEV_T)0;
4649         uint32 raw_unixmode = IVAL(pdata,84);
4650         NTSTATUS status;
4651         mode_t unixmode;
4652
4653         if (total_data < 100) {
4654                 return NT_STATUS_INVALID_PARAMETER;
4655         }
4656
4657         status = unix_perms_from_wire(conn, psbuf, raw_unixmode, PERM_NEW_FILE, &unixmode);
4658         if (!NT_STATUS_IS_OK(status)) {
4659                 return status;
4660         }
4661
4662 #if defined(HAVE_MAKEDEV)
4663         dev = makedev(dev_major, dev_minor);
4664 #endif
4665
4666         switch (file_type) {
4667 #if defined(S_IFIFO)
4668                 case UNIX_TYPE_FIFO:
4669                         unixmode |= S_IFIFO;
4670                         break;
4671 #endif
4672 #if defined(S_IFSOCK)
4673                 case UNIX_TYPE_SOCKET:
4674                         unixmode |= S_IFSOCK;
4675                         break;
4676 #endif
4677 #if defined(S_IFCHR)
4678                 case UNIX_TYPE_CHARDEV:
4679                         unixmode |= S_IFCHR;
4680                         break;
4681 #endif
4682 #if defined(S_IFBLK)
4683                 case UNIX_TYPE_BLKDEV:
4684                         unixmode |= S_IFBLK;
4685                         break;
4686 #endif
4687                 default:
4688                         return NT_STATUS_INVALID_PARAMETER;
4689         }
4690
4691         DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev %.0f mode \
4692 0%o for file %s\n", (double)dev, (unsigned int)unixmode, fname ));
4693
4694         /* Ok - do the mknod. */
4695         if (SMB_VFS_MKNOD(conn, fname, unixmode, dev) != 0) {
4696                 return map_nt_error_from_unix(errno);
4697         }
4698
4699         /* If any of the other "set" calls fail we
4700          * don't want to end up with a half-constructed mknod.
4701          */
4702
4703         if (lp_inherit_perms(SNUM(conn))) {
4704                 inherit_access_acl(
4705                         conn, parent_dirname(fname),
4706                         fname, unixmode);
4707         }
4708
4709         if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
4710                 status = map_nt_error_from_unix(errno);
4711                 SMB_VFS_UNLINK(conn,fname);
4712                 return status;
4713         }
4714         return NT_STATUS_OK;
4715 }
4716
4717 /****************************************************************************
4718  Deal with SMB_SET_FILE_UNIX_BASIC.
4719 ****************************************************************************/
4720
4721 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
4722                                         const char *pdata,
4723                                         int total_data,
4724                                         files_struct *fsp,
4725                                         const char *fname,
4726                                         SMB_STRUCT_STAT *psbuf)
4727 {
4728         struct utimbuf tvs;
4729         uint32 raw_unixmode;
4730         mode_t unixmode;
4731         SMB_OFF_T size = 0;
4732         uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
4733         gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
4734         NTSTATUS status = NT_STATUS_OK;
4735         BOOL delete_on_fail = False;
4736         enum perm_type ptype;
4737
4738         if (total_data < 100) {
4739                 return NT_STATUS_INVALID_PARAMETER;
4740         }
4741
4742         if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
4743            IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
4744                 size=IVAL(pdata,0); /* first 8 Bytes are size */
4745 #ifdef LARGE_SMB_OFF_T
4746                 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
4747 #else /* LARGE_SMB_OFF_T */
4748                 if (IVAL(pdata,4) != 0) {
4749                         /* more than 32 bits? */
4750                         return NT_STATUS_INVALID_PARAMETER;
4751                 }
4752 #endif /* LARGE_SMB_OFF_T */
4753         }
4754
4755         tvs.actime = convert_timespec_to_time_t(interpret_long_date(pdata+24)); /* access_time */
4756         tvs.modtime = convert_timespec_to_time_t(interpret_long_date(pdata+32)); /* modification_time */
4757         set_owner = (uid_t)IVAL(pdata,40);
4758         set_grp = (gid_t)IVAL(pdata,48);
4759         raw_unixmode = IVAL(pdata,84);
4760
4761         if (VALID_STAT(*psbuf)) {
4762                 if (S_ISDIR(psbuf->st_mode)) {
4763                         ptype = PERM_EXISTING_DIR;
4764                 } else {
4765                         ptype = PERM_EXISTING_FILE;
4766                 }
4767         } else {
4768                 ptype = PERM_NEW_FILE;
4769         }
4770
4771         status = unix_perms_from_wire(conn, psbuf, raw_unixmode, ptype, &unixmode);
4772         if (!NT_STATUS_IS_OK(status)) {
4773                 return status;
4774         }
4775
4776         DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = %s \
4777 size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
4778                 fname, (double)size, (unsigned int)set_owner, (unsigned int)set_grp, (int)raw_unixmode));
4779
4780         if (!VALID_STAT(*psbuf)) {
4781                 /*
4782                  * The only valid use of this is to create character and block
4783                  * devices, and named pipes. This is deprecated (IMHO) and
4784                  * a new info level should be used for mknod. JRA.
4785                  */
4786
4787                 status = smb_unix_mknod(conn,
4788                                         pdata,
4789                                         total_data,
4790                                         fname,
4791                                         psbuf);
4792                 if (!NT_STATUS_IS_OK(status)) {
4793                         return status;
4794                 }
4795
4796                 /* Ensure we don't try and change anything else. */
4797                 raw_unixmode = SMB_MODE_NO_CHANGE;
4798                 size = get_file_size(*psbuf);
4799                 tvs.modtime = psbuf->st_mtime;
4800                 tvs.actime = psbuf->st_atime;
4801                 /*
4802                  * We continue here as we might want to change the
4803                  * owner uid/gid.
4804                  */
4805                 delete_on_fail = True;
4806         }
4807
4808 #if 1
4809         /* Horrible backwards compatibility hack as an old server bug
4810          * allowed a CIFS client bug to remain unnoticed :-(. JRA.
4811          * */
4812
4813         if (!size) {
4814                 size = get_file_size(*psbuf);
4815         }
4816 #endif
4817
4818         /*
4819          * Deal with the UNIX specific mode set.
4820          */
4821
4822         if (raw_unixmode != SMB_MODE_NO_CHANGE) {
4823                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
4824                         (unsigned int)unixmode, fname ));
4825                 if (SMB_VFS_CHMOD(conn, fname, unixmode) != 0) {
4826                         return map_nt_error_from_unix(errno);
4827                 }
4828         }
4829
4830         /*
4831          * Deal with the UNIX specific uid set.
4832          */
4833
4834         if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) && (psbuf->st_uid != set_owner)) {
4835                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing owner %u for file %s\n",
4836                         (unsigned int)set_owner, fname ));
4837                 if (SMB_VFS_CHOWN(conn, fname, set_owner, (gid_t)-1) != 0) {
4838                         status = map_nt_error_from_unix(errno);
4839                         if (delete_on_fail) {
4840                                 SMB_VFS_UNLINK(conn,fname);
4841                         }
4842                         return status;
4843                 }
4844         }
4845
4846         /*
4847          * Deal with the UNIX specific gid set.
4848          */
4849
4850         if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) && (psbuf->st_gid != set_grp)) {
4851                 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
4852                         (unsigned int)set_owner, fname ));
4853                 if (SMB_VFS_CHOWN(conn, fname, (uid_t)-1, set_grp) != 0) {
4854                         status = map_nt_error_from_unix(errno);
4855                         if (delete_on_fail) {
4856                                 SMB_VFS_UNLINK(conn,fname);
4857                         }
4858                         return status;
4859                 }
4860         }
4861
4862         /* Deal with any size changes. */
4863
4864         status = smb_set_file_size(conn,
4865                                 fsp,
4866                                 fname,
4867                                 psbuf,
4868                                 size);
4869         if (!NT_STATUS_IS_OK(status)) {
4870                 return status;
4871         }
4872
4873         /* Deal with any time changes. */
4874
4875         return smb_set_file_time(conn,
4876                                 fsp,
4877                                 fname,
4878                                 psbuf,
4879                                 tvs);
4880 }
4881
4882 /****************************************************************************
4883  Create a directory with POSIX semantics.
4884 ****************************************************************************/
4885
4886 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
4887                                 char **ppdata,
4888                                 int total_data,
4889                                 const char *fname,
4890                                 SMB_STRUCT_STAT *psbuf,
4891                                 int *pdata_return_size)
4892 {
4893         NTSTATUS status = NT_STATUS_OK;
4894         uint32 raw_unixmode = 0;
4895         uint32 mod_unixmode = 0;
4896         mode_t unixmode = (mode_t)0;
4897         files_struct *fsp = NULL;
4898         uint16 info_level_return = 0;
4899         char *pdata = *ppdata;
4900
4901         if (total_data < 10) {
4902                 return NT_STATUS_INVALID_PARAMETER;
4903         }
4904
4905         raw_unixmode = IVAL(pdata,8);
4906         status = unix_perms_from_wire(conn, psbuf, raw_unixmode, PERM_NEW_DIR, &unixmode);
4907         if (!NT_STATUS_IS_OK(status)) {
4908                 return status;
4909         }
4910
4911         mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
4912
4913         status = open_directory(conn,
4914                                 fname,
4915                                 psbuf,
4916                                 FILE_READ_ATTRIBUTES, /* Just a stat open */
4917                                 FILE_SHARE_NONE, /* Ignored for stat opens */
4918                                 FILE_CREATE,
4919                                 0,
4920                                 mod_unixmode,
4921                                 NULL,
4922                                 &fsp);
4923
4924         if (NT_STATUS_IS_OK(status)) {
4925                 close_file(fsp, NORMAL_CLOSE);
4926         }
4927
4928         info_level_return = SVAL(pdata,12);
4929
4930         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
4931                 *pdata_return_size = 8 + SMB_FILE_UNIX_BASIC_SIZE;
4932         } else {
4933                 *pdata_return_size = 8;
4934         }
4935
4936         /* Realloc the data size */
4937         *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
4938         if (*ppdata == NULL) {
4939                 *pdata_return_size = 0;
4940                 return NT_STATUS_NO_MEMORY;
4941         }
4942
4943         SSVAL(pdata,0,NO_OPLOCK_RETURN);
4944         SSVAL(pdata,2,0);
4945
4946         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
4947                 SSVAL(pdata,4,SMB_QUERY_FILE_UNIX_BASIC);
4948                 SSVAL(pdata,6,0); /* Padding. */
4949                 store_file_unix_basic(conn, pdata + 8, fsp, psbuf);
4950         } else {
4951                 SSVAL(pdata,4,SMB_NO_INFO_LEVEL_RETURNED);
4952                 SSVAL(pdata,6,0); /* Padding. */
4953         }
4954
4955         return status;
4956 }
4957
4958 /****************************************************************************
4959  Open/Create a file with POSIX semantics.
4960 ****************************************************************************/
4961
4962 static NTSTATUS smb_posix_open(connection_struct *conn,
4963                                 char **ppdata,
4964                                 int total_data,
4965                                 const char *fname,
4966                                 SMB_STRUCT_STAT *psbuf,
4967                                 int *pdata_return_size)
4968 {
4969         BOOL extended_oplock_granted = False;
4970         char *pdata = *ppdata;
4971         uint32 flags = 0;
4972         uint32 wire_open_mode = 0;
4973         uint32 raw_unixmode = 0;
4974         uint32 mod_unixmode = 0;
4975         uint32 create_disp = 0;
4976         uint32 access_mask = 0;
4977         uint32 create_options = 0;
4978         NTSTATUS status = NT_STATUS_OK;
4979         mode_t unixmode = (mode_t)0;
4980         files_struct *fsp = NULL;
4981         int oplock_request = 0;
4982         int info = 0;
4983         uint16 info_level_return = 0;
4984
4985         if (total_data < 14) {
4986                 return NT_STATUS_INVALID_PARAMETER;
4987         }
4988
4989         flags = IVAL(pdata,0);
4990         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
4991         if (oplock_request) {
4992                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
4993         }
4994
4995         wire_open_mode = IVAL(pdata,4);
4996
4997         if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
4998                 return smb_posix_mkdir(conn,
4999                                         ppdata,
5000                                         total_data,
5001                                         fname,
5002                                         psbuf,
5003                                         pdata_return_size);
5004         }
5005
5006         switch (wire_open_mode & SMB_ACCMODE) {
5007                 case SMB_O_RDONLY:
5008                         access_mask = FILE_READ_DATA;
5009                         break;
5010                 case SMB_O_WRONLY:
5011                         access_mask = FILE_WRITE_DATA;
5012                         break;
5013                 case SMB_O_RDWR:
5014                         access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
5015                         break;
5016                 default:
5017                         DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
5018                                 (unsigned int)wire_open_mode ));
5019                         return NT_STATUS_INVALID_PARAMETER;
5020         }
5021
5022         wire_open_mode &= ~SMB_ACCMODE;
5023
5024         if((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) == (SMB_O_CREAT | SMB_O_EXCL)) {
5025                 create_disp = FILE_CREATE;
5026         } else if((wire_open_mode & (SMB_O_CREAT | SMB_O_TRUNC)) == (SMB_O_CREAT | SMB_O_TRUNC)) {
5027                 create_disp = FILE_OVERWRITE_IF;
5028         } else if((wire_open_mode & SMB_O_CREAT) == SMB_O_CREAT) {
5029                 create_disp = FILE_OPEN_IF;
5030         } else {
5031                 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
5032                         (unsigned int)wire_open_mode ));
5033                 return NT_STATUS_INVALID_PARAMETER;
5034         }
5035
5036         raw_unixmode = IVAL(pdata,8);
5037         status = unix_perms_from_wire(conn,
5038                                 psbuf,
5039                                 raw_unixmode,
5040                                 VALID_STAT(*psbuf) ? PERM_EXISTING_FILE : PERM_NEW_FILE,
5041                                 &unixmode);
5042
5043         if (!NT_STATUS_IS_OK(status)) {
5044                 return status;
5045         }
5046
5047         mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
5048
5049         if (wire_open_mode & SMB_O_SYNC) {
5050                 create_options |= FILE_WRITE_THROUGH;
5051         }
5052         if (wire_open_mode & SMB_O_APPEND) {
5053                 access_mask |= FILE_APPEND_DATA;
5054         }
5055         if (wire_open_mode & SMB_O_DIRECT) {
5056                 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
5057         }
5058
5059         status = open_file_ntcreate(conn,
5060                                 fname,
5061                                 psbuf,
5062                                 access_mask,
5063                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5064                                 create_disp,
5065                                 0,              /* no create options yet. */
5066                                 mod_unixmode,
5067                                 oplock_request,
5068                                 &info,
5069                                 &fsp);
5070
5071         if (!NT_STATUS_IS_OK(status)) {
5072                 return status;
5073         }
5074
5075         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
5076                 extended_oplock_granted = True;
5077         }
5078
5079         if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
5080                 extended_oplock_granted = True;
5081         }
5082
5083         info_level_return = SVAL(pdata,12);
5084
5085         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
5086                 *pdata_return_size = 8 + SMB_FILE_UNIX_BASIC_SIZE;
5087         } else {
5088                 *pdata_return_size = 8;
5089         }
5090
5091         /* Realloc the data size */
5092         *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
5093         if (*ppdata == NULL) {
5094                 close_file(fsp,ERROR_CLOSE);
5095                 *pdata_return_size = 0;
5096                 return NT_STATUS_NO_MEMORY;
5097         }
5098
5099         if (extended_oplock_granted) {
5100                 if (flags & REQUEST_BATCH_OPLOCK) {
5101                         SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
5102                 } else {
5103                         SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
5104                 }
5105         } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
5106                 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
5107         } else {
5108                 SSVAL(pdata,0,NO_OPLOCK_RETURN);
5109         }
5110
5111         SSVAL(pdata,2,fsp->fnum);
5112         if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
5113                 SSVAL(pdata,4,SMB_QUERY_FILE_UNIX_BASIC);
5114                 SSVAL(pdata,6,0); /* padding. */
5115                 store_file_unix_basic(conn, pdata + 8, fsp, psbuf);
5116         } else {
5117                 SSVAL(pdata,4,SMB_NO_INFO_LEVEL_RETURNED);
5118                 SSVAL(pdata,6,0); /* padding. */
5119         }
5120         return NT_STATUS_OK;
5121 }
5122
5123 /****************************************************************************
5124  Delete a file with POSIX semantics.
5125 ****************************************************************************/
5126
5127 static NTSTATUS smb_posix_unlink(connection_struct *conn,
5128                                 const char *pdata,
5129                                 int total_data,
5130                                 const char *fname,
5131                                 SMB_STRUCT_STAT *psbuf)
5132 {
5133         NTSTATUS status = NT_STATUS_OK;
5134         files_struct *fsp = NULL;
5135         int info = 0;
5136
5137         if (!VALID_STAT(*psbuf)) {
5138                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5139         }
5140
5141         if (VALID_STAT_OF_DIR(*psbuf)) {
5142                 status = open_directory(conn,
5143                                         fname,
5144                                         psbuf,
5145                                         DELETE_ACCESS,
5146                                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5147                                         FILE_OPEN,
5148                                         FILE_DELETE_ON_CLOSE,
5149                                         FILE_FLAG_POSIX_SEMANTICS|0777,
5150                                         &info,
5151                                         &fsp);
5152         } else {
5153                 status = open_file_ntcreate(conn,
5154                                 fname,
5155                                 psbuf,
5156                                 DELETE_ACCESS,
5157                                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5158                                 FILE_OPEN,
5159                                 FILE_DELETE_ON_CLOSE,
5160                                 FILE_FLAG_POSIX_SEMANTICS|0777,
5161                                 INTERNAL_OPEN_ONLY,
5162                                 &info,
5163                                 &fsp);
5164         }
5165
5166         if (!NT_STATUS_IS_OK(status)) {
5167                 return status;
5168         }
5169         return close_file(fsp, NORMAL_CLOSE);
5170 }
5171
5172 /****************************************************************************
5173  Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
5174 ****************************************************************************/
5175
5176 static int call_trans2setfilepathinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
5177                                         unsigned int tran_call,
5178                                         char **pparams, int total_params, char **ppdata, int total_data,
5179                                         unsigned int max_data_bytes)
5180 {
5181         char *params = *pparams;
5182         char *pdata = *ppdata;
5183         uint16 info_level;
5184         SMB_STRUCT_STAT sbuf;
5185         pstring fname;
5186         files_struct *fsp = NULL;
5187         NTSTATUS status = NT_STATUS_OK;
5188         int data_return_size = 0;
5189
5190         if (!params) {
5191                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5192         }
5193
5194         ZERO_STRUCT(sbuf);
5195
5196         if (tran_call == TRANSACT2_SETFILEINFO) {
5197                 if (total_params < 4) {
5198                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5199                 }
5200
5201                 fsp = file_fsp(params,0);
5202                 info_level = SVAL(params,2);
5203
5204                 if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
5205                         /*
5206                          * This is actually a SETFILEINFO on a directory
5207                          * handle (returned from an NT SMB). NT5.0 seems
5208                          * to do this call. JRA.
5209                          */
5210                         pstrcpy(fname, fsp->fsp_name);
5211                         if (SMB_VFS_STAT(conn,fname,&sbuf) != 0) {
5212                                 DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
5213                                 return UNIXERROR(ERRDOS,ERRbadpath);
5214                         }
5215                 } else if (fsp && fsp->print_file) {
5216                         /*
5217                          * Doing a DELETE_ON_CLOSE should cancel a print job.
5218                          */
5219                         if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
5220                                 fsp->fh->private_options |= FILE_DELETE_ON_CLOSE;
5221
5222                                 DEBUG(3,("call_trans2setfilepathinfo: Cancelling print job (%s)\n", fsp->fsp_name ));
5223
5224                                 SSVAL(params,0,0);
5225                                 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
5226                                 return(-1);
5227                         } else
5228                                 return (UNIXERROR(ERRDOS,ERRbadpath));
5229             } else {
5230                         /*
5231                          * Original code - this is an open file.
5232                          */
5233                         CHECK_FSP(fsp,conn);
5234
5235                         pstrcpy(fname, fsp->fsp_name);
5236
5237                         if (SMB_VFS_FSTAT(fsp, fsp->fh->fd, &sbuf) != 0) {
5238                                 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
5239                                 return(UNIXERROR(ERRDOS,ERRbadfid));
5240                         }
5241                 }
5242         } else {
5243                 /* set path info */
5244                 if (total_params < 7) {
5245                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5246                 }
5247
5248                 info_level = SVAL(params,0);
5249                 srvstr_get_path(inbuf, fname, &params[6], sizeof(fname), total_params - 6, STR_TERMINATE, &status);
5250                 if (!NT_STATUS_IS_OK(status)) {
5251                         return ERROR_NT(status);
5252                 }
5253
5254                 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
5255
5256                 status = unix_convert(conn, fname, False, NULL, &sbuf);
5257                 if (!NT_STATUS_IS_OK(status)) {
5258                         return ERROR_NT(status);
5259                 }
5260
5261                 /*
5262                  * For CIFS UNIX extensions the target name may not exist.
5263                  */
5264
5265                 if(!VALID_STAT(sbuf) && !INFO_LEVEL_IS_UNIX(info_level)) {
5266                         DEBUG(3,("call_trans2setfilepathinfo: stat of %s failed (%s)\n", fname, strerror(errno)));
5267                         return UNIXERROR(ERRDOS,ERRbadpath);
5268                 }
5269
5270                 status = check_name(conn, fname);
5271                 if (!NT_STATUS_IS_OK(status)) {
5272                         return ERROR_NT(status);
5273                 }
5274
5275         }
5276
5277         if (!CAN_WRITE(conn)) {
5278                 return ERROR_DOS(ERRSRV,ERRaccess);
5279         }
5280
5281         if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
5282                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5283         }
5284
5285         DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d totdata=%d\n",
5286                 tran_call,fname, fsp ? fsp->fnum : -1, info_level,total_data));
5287
5288         /* Realloc the parameter size */
5289         *pparams = (char *)SMB_REALLOC(*pparams,2);
5290         if (*pparams == NULL) {
5291                 return ERROR_NT(NT_STATUS_NO_MEMORY);
5292         }
5293         params = *pparams;
5294
5295         SSVAL(params,0,0);
5296
5297         if (fsp && fsp->pending_modtime) {
5298                 /* the pending modtime overrides the current modtime */
5299                 sbuf.st_mtime = fsp->pending_modtime;
5300         }
5301
5302         switch (info_level) {
5303
5304                 case SMB_INFO_STANDARD:
5305                 {
5306                         status = smb_set_info_standard(conn,
5307                                         pdata,
5308                                         total_data,
5309                                         fsp,
5310                                         fname,
5311                                         &sbuf);
5312                         break;
5313                 }
5314
5315                 case SMB_INFO_SET_EA:
5316                 {
5317                         status = smb_info_set_ea(conn,
5318                                                 pdata,
5319                                                 total_data,
5320                                                 fsp,
5321                                                 fname);
5322                         break;
5323                 }
5324
5325                 case SMB_SET_FILE_BASIC_INFO:
5326                 case SMB_FILE_BASIC_INFORMATION:
5327                 {
5328                         status = smb_set_file_basic_info(conn,
5329                                                         pdata,
5330                                                         total_data,
5331                                                         fsp,
5332                                                         fname,
5333                                                         &sbuf);
5334                         break;
5335                 }
5336
5337                 case SMB_FILE_ALLOCATION_INFORMATION:
5338                 case SMB_SET_FILE_ALLOCATION_INFO:
5339                 {
5340                         status = smb_set_file_allocation_info(conn,
5341                                                                 pdata,
5342                                                                 total_data,
5343                                                                 fsp,
5344                                                                 fname,
5345                                                                 &sbuf);
5346                         break;
5347                 }
5348
5349                 case SMB_FILE_END_OF_FILE_INFORMATION:
5350                 case SMB_SET_FILE_END_OF_FILE_INFO:
5351                 {
5352                         status = smb_set_file_end_of_file_info(conn,
5353                                                                 pdata,
5354                                                                 total_data,
5355                                                                 fsp,
5356                                                                 fname,
5357                                                                 &sbuf);
5358                         break;
5359                 }
5360
5361                 case SMB_FILE_DISPOSITION_INFORMATION:
5362                 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
5363                 {
5364 #if 0
5365                         /* JRA - We used to just ignore this on a path ?
5366                          * Shouldn't this be invalid level on a pathname
5367                          * based call ?
5368                          */
5369                         if (tran_call != TRANSACT2_SETFILEINFO) {
5370                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5371                         }
5372 #endif
5373                         status = smb_set_file_disposition_info(conn,
5374                                                 pdata,
5375                                                 total_data,
5376                                                 fsp,
5377                                                 fname,
5378                                                 &sbuf);
5379                         break;
5380                 }
5381
5382                 case SMB_FILE_POSITION_INFORMATION:
5383                 {
5384                         status = smb_file_position_information(conn,
5385                                                 pdata,
5386                                                 total_data,
5387                                                 fsp);
5388                         break;
5389                 }
5390
5391                 /* From tridge Samba4 :
5392                  * MODE_INFORMATION in setfileinfo (I have no
5393                  * idea what "mode information" on a file is - it takes a value of 0,
5394                  * 2, 4 or 6. What could it be?).
5395                  */
5396
5397                 case SMB_FILE_MODE_INFORMATION:
5398                 {
5399                         status = smb_file_mode_information(conn,
5400                                                 pdata,
5401                                                 total_data);
5402                         break;
5403                 }
5404
5405                 /*
5406                  * CIFS UNIX extensions.
5407                  */
5408
5409                 case SMB_SET_FILE_UNIX_BASIC:
5410                 {
5411                         status = smb_set_file_unix_basic(conn,
5412                                                         pdata,
5413                                                         total_data,
5414                                                         fsp,
5415                                                         fname,
5416                                                         &sbuf);
5417                         break;
5418                 }
5419
5420                 case SMB_SET_FILE_UNIX_LINK:
5421                 {
5422                         if (tran_call != TRANSACT2_SETPATHINFO) {
5423                                 /* We must have a pathname for this. */
5424                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5425                         }
5426                         status = smb_set_file_unix_link(conn,
5427                                                 inbuf,
5428                                                 pdata,
5429                                                 total_data,
5430                                                 fname);
5431                         break;
5432                 }
5433
5434                 case SMB_SET_FILE_UNIX_HLINK:
5435                 {
5436                         if (tran_call != TRANSACT2_SETPATHINFO) {
5437                                 /* We must have a pathname for this. */
5438                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5439                         }
5440                         status = smb_set_file_unix_hlink(conn,
5441                                                 inbuf,
5442                                                 outbuf,
5443                                                 pdata,
5444                                                 total_data,
5445                                                 fname);
5446                         break;
5447                 }
5448
5449                 case SMB_FILE_RENAME_INFORMATION:
5450                 {
5451                         status = smb_file_rename_information(conn,
5452                                                         inbuf,
5453                                                         outbuf,
5454                                                         pdata,
5455                                                         total_data,
5456                                                         fsp,
5457                                                         fname);
5458                         break;
5459                 }
5460
5461 #if defined(HAVE_POSIX_ACLS)
5462                 case SMB_SET_POSIX_ACL:
5463                 {
5464                         status = smb_set_posix_acl(conn,
5465                                                 pdata,
5466                                                 total_data,
5467                                                 fsp,
5468                                                 fname,
5469                                                 &sbuf);
5470                         break;
5471                 }
5472 #endif
5473
5474                 case SMB_SET_POSIX_LOCK:
5475                 {
5476                         if (tran_call != TRANSACT2_SETFILEINFO) {
5477                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5478                         }
5479                         status = smb_set_posix_lock(conn,
5480                                                 inbuf,
5481                                                 length,
5482                                                 pdata,
5483                                                 total_data,
5484                                                 fsp);
5485                         break;
5486                 }
5487
5488                 case SMB_POSIX_PATH_OPEN:
5489                 {
5490                         if (tran_call != TRANSACT2_SETPATHINFO) {
5491                                 /* We must have a pathname for this. */
5492                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5493                         }
5494
5495                         status = smb_posix_open(conn,
5496                                                 ppdata,
5497                                                 total_data,
5498                                                 fname,
5499                                                 &sbuf,
5500                                                 &data_return_size);
5501                         break;
5502                 }
5503
5504                 case SMB_POSIX_PATH_UNLINK:
5505                 {
5506                         if (tran_call != TRANSACT2_SETPATHINFO) {
5507                                 /* We must have a pathname for this. */
5508                                 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5509                         }
5510
5511                         status = smb_posix_unlink(conn,
5512                                                 pdata,
5513                                                 total_data,
5514                                                 fname,
5515                                                 &sbuf);
5516                         break;
5517                 }
5518
5519                 default:
5520                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5521         }
5522
5523
5524         if (!NT_STATUS_IS_OK(status)) {
5525                 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
5526                         /* We have re-scheduled this call. */
5527                         return -1;
5528                 }
5529                 if (blocking_lock_was_deferred(SVAL(inbuf,smb_mid))) {
5530                         /* We have re-scheduled this call. */
5531                         return -1;
5532                 }
5533                 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5534                         return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
5535                 }
5536                 return ERROR_NT(status);
5537         }
5538
5539         SSVAL(params,0,0);
5540         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, data_return_size, max_data_bytes);
5541
5542         return -1;
5543 }
5544
5545 /****************************************************************************
5546  Reply to a TRANS2_MKDIR (make directory with extended attributes).
5547 ****************************************************************************/
5548
5549 static int call_trans2mkdir(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
5550                                         char **pparams, int total_params, char **ppdata, int total_data,
5551                                         unsigned int max_data_bytes)
5552 {
5553         char *params = *pparams;
5554         char *pdata = *ppdata;
5555         pstring directory;
5556         SMB_STRUCT_STAT sbuf;
5557         NTSTATUS status = NT_STATUS_OK;
5558         struct ea_list *ea_list = NULL;
5559
5560         if (!CAN_WRITE(conn))
5561                 return ERROR_DOS(ERRSRV,ERRaccess);
5562
5563         if (total_params < 5) {
5564                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5565         }
5566
5567         srvstr_get_path(inbuf, directory, &params[4], sizeof(directory), total_params - 4, STR_TERMINATE, &status);
5568         if (!NT_STATUS_IS_OK(status)) {
5569                 return ERROR_NT(status);
5570         }
5571
5572         DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
5573
5574         status = unix_convert(conn, directory, False, NULL, &sbuf);
5575         if (!NT_STATUS_IS_OK(status)) {
5576                 return ERROR_NT(status);
5577         }
5578
5579         /* Any data in this call is an EA list. */
5580         if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
5581                 return ERROR_NT(NT_STATUS_EAS_NOT_SUPPORTED);
5582         }
5583
5584         /*
5585          * OS/2 workplace shell seems to send SET_EA requests of "null"
5586          * length (4 bytes containing IVAL 4).
5587          * They seem to have no effect. Bug #3212. JRA.
5588          */
5589
5590         if (total_data != 4) {
5591                 if (total_data < 10) {
5592                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5593                 }
5594
5595                 if (IVAL(pdata,0) > total_data) {
5596                         DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
5597                                 IVAL(pdata,0), (unsigned int)total_data));
5598                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5599                 }
5600
5601                 ea_list = read_ea_list(tmp_talloc_ctx(), pdata + 4,
5602                                        total_data - 4);
5603                 if (!ea_list) {
5604                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5605                 }
5606         } else if (IVAL(pdata,0) != 4) {
5607                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5608         }
5609
5610         status = check_name(conn, directory);
5611         if (!NT_STATUS_IS_OK(status)) {
5612                 DEBUG(5,("call_trans2mkdir error (%s)\n", nt_errstr(status)));
5613                 return ERROR_NT(status);
5614         }
5615
5616         status = create_directory(conn, directory);
5617
5618         if (!NT_STATUS_IS_OK(status)) {
5619                 return ERROR_NT(status);
5620         }
5621
5622         /* Try and set any given EA. */
5623         if (ea_list) {
5624                 status = set_ea(conn, NULL, directory, ea_list);
5625                 if (!NT_STATUS_IS_OK(status)) {
5626                         return ERROR_NT(status);
5627                 }
5628         }
5629
5630         /* Realloc the parameter and data sizes */
5631         *pparams = (char *)SMB_REALLOC(*pparams,2);
5632         if(*pparams == NULL) {
5633                 return ERROR_NT(NT_STATUS_NO_MEMORY);
5634         }
5635         params = *pparams;
5636
5637         SSVAL(params,0,0);
5638
5639         send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
5640
5641         return(-1);
5642 }
5643
5644 /****************************************************************************
5645  Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
5646  We don't actually do this - we just send a null response.
5647 ****************************************************************************/
5648
5649 static int call_trans2findnotifyfirst(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
5650                                         char **pparams, int total_params, char **ppdata, int total_data,
5651                                         unsigned int max_data_bytes)
5652 {
5653         static uint16 fnf_handle = 257;
5654         char *params = *pparams;
5655         uint16 info_level;
5656
5657         if (total_params < 6) {
5658                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5659         }
5660
5661         info_level = SVAL(params,4);
5662         DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
5663
5664         switch (info_level) {
5665                 case 1:
5666                 case 2:
5667                         break;
5668                 default:
5669                         return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5670         }
5671
5672         /* Realloc the parameter and data sizes */
5673         *pparams = (char *)SMB_REALLOC(*pparams,6);
5674         if (*pparams == NULL) {
5675                 return ERROR_NT(NT_STATUS_NO_MEMORY);
5676         }
5677         params = *pparams;
5678
5679         SSVAL(params,0,fnf_handle);
5680         SSVAL(params,2,0); /* No changes */
5681         SSVAL(params,4,0); /* No EA errors */
5682
5683         fnf_handle++;
5684
5685         if(fnf_handle == 0)
5686                 fnf_handle = 257;
5687
5688         send_trans2_replies(outbuf, bufsize, params, 6, *ppdata, 0, max_data_bytes);
5689
5690         return(-1);
5691 }
5692
5693 /****************************************************************************
5694  Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
5695  changes). Currently this does nothing.
5696 ****************************************************************************/
5697
5698 static int call_trans2findnotifynext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
5699                                         char **pparams, int total_params, char **ppdata, int total_data,
5700                                         unsigned int max_data_bytes)
5701 {
5702         char *params = *pparams;
5703
5704         DEBUG(3,("call_trans2findnotifynext\n"));
5705
5706         /* Realloc the parameter and data sizes */
5707         *pparams = (char *)SMB_REALLOC(*pparams,4);
5708         if (*pparams == NULL) {
5709                 return ERROR_NT(NT_STATUS_NO_MEMORY);
5710         }
5711         params = *pparams;
5712
5713         SSVAL(params,0,0); /* No changes */
5714         SSVAL(params,2,0); /* No EA errors */
5715
5716         send_trans2_replies(outbuf, bufsize, params, 4, *ppdata, 0, max_data_bytes);
5717
5718         return(-1);
5719 }
5720
5721 /****************************************************************************
5722  Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
5723 ****************************************************************************/
5724
5725 static int call_trans2getdfsreferral(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
5726                                         char **pparams, int total_params, char **ppdata, int total_data,
5727                                         unsigned int max_data_bytes)
5728 {
5729         char *params = *pparams;
5730         pstring pathname;
5731         int reply_size = 0;
5732         int max_referral_level;
5733
5734         DEBUG(10,("call_trans2getdfsreferral\n"));
5735
5736         if (total_params < 3) {
5737                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5738         }
5739
5740         max_referral_level = SVAL(params,0);
5741
5742         if(!lp_host_msdfs())
5743                 return ERROR_DOS(ERRDOS,ERRbadfunc);
5744
5745         srvstr_pull(inbuf, pathname, &params[2], sizeof(pathname), total_params - 2, STR_TERMINATE);
5746         if((reply_size = setup_dfs_referral(conn, pathname,max_referral_level,ppdata)) < 0)
5747                 return UNIXERROR(ERRDOS,ERRbadfile);
5748
5749         SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
5750         send_trans2_replies(outbuf,bufsize,0,0,*ppdata,reply_size, max_data_bytes);
5751
5752         return(-1);
5753 }
5754
5755 #define LMCAT_SPL       0x53
5756 #define LMFUNC_GETJOBID 0x60
5757
5758 /****************************************************************************
5759  Reply to a TRANS2_IOCTL - used for OS/2 printing.
5760 ****************************************************************************/
5761
5762 static int call_trans2ioctl(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
5763                                         char **pparams, int total_params, char **ppdata, int total_data,
5764                                         unsigned int max_data_bytes)
5765 {
5766         char *pdata = *ppdata;
5767         files_struct *fsp = file_fsp(inbuf,smb_vwv15);
5768
5769         /* check for an invalid fid before proceeding */
5770
5771         if (!fsp)
5772                 return(ERROR_DOS(ERRDOS,ERRbadfid));
5773
5774         if ((SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
5775                         (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
5776                 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
5777                 if (*ppdata == NULL) {
5778                         return ERROR_NT(NT_STATUS_NO_MEMORY);
5779                 }
5780                 pdata = *ppdata;
5781
5782                 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
5783                         CAN ACCEPT THIS IN UNICODE. JRA. */
5784
5785                 SSVAL(pdata,0,fsp->rap_print_jobid);                     /* Job number */
5786                 srvstr_push( outbuf, pdata + 2, global_myname(), 15, STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
5787                 srvstr_push( outbuf, pdata+18, lp_servicename(SNUM(conn)), 13, STR_ASCII|STR_TERMINATE); /* Service name */
5788                 send_trans2_replies(outbuf,bufsize,*pparams,0,*ppdata,32, max_data_bytes);
5789                 return(-1);
5790         } else {
5791                 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
5792                 return ERROR_DOS(ERRSRV,ERRerror);
5793         }
5794 }
5795
5796 /****************************************************************************
5797  Reply to a SMBfindclose (stop trans2 directory search).
5798 ****************************************************************************/
5799
5800 int reply_findclose(connection_struct *conn,
5801                     char *inbuf,char *outbuf,int length,int bufsize)
5802 {
5803         int outsize = 0;
5804         int dptr_num=SVALS(inbuf,smb_vwv0);
5805         START_PROFILE(SMBfindclose);
5806
5807         DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
5808
5809         dptr_close(&dptr_num);
5810
5811         outsize = set_message(outbuf,0,0,False);
5812
5813         DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
5814
5815         END_PROFILE(SMBfindclose);
5816         return(outsize);
5817 }
5818
5819 /****************************************************************************
5820  Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
5821 ****************************************************************************/
5822
5823 int reply_findnclose(connection_struct *conn,
5824                      char *inbuf,char *outbuf,int length,int bufsize)
5825 {
5826         int outsize = 0;
5827         int dptr_num= -1;
5828         START_PROFILE(SMBfindnclose);
5829
5830         dptr_num = SVAL(inbuf,smb_vwv0);
5831
5832         DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
5833
5834         /* We never give out valid handles for a
5835            findnotifyfirst - so any dptr_num is ok here.
5836            Just ignore it. */
5837
5838         outsize = set_message(outbuf,0,0,False);
5839
5840         DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
5841
5842         END_PROFILE(SMBfindnclose);
5843         return(outsize);
5844 }
5845
5846 int handle_trans2(connection_struct *conn,
5847                   struct trans_state *state,
5848                   char *inbuf, char *outbuf, int size, int bufsize)
5849 {
5850         int outsize;
5851
5852         if (Protocol >= PROTOCOL_NT1) {
5853                 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | 0x40); /* IS_LONG_NAME */
5854         }
5855
5856         /* Now we must call the relevant TRANS2 function */
5857         switch(state->call)  {
5858         case TRANSACT2_OPEN:
5859         {
5860                 START_PROFILE(Trans2_open);
5861                 outsize = call_trans2open(
5862                         conn, inbuf, outbuf, bufsize,
5863                         &state->param, state->total_param,
5864                         &state->data, state->total_data,
5865                         state->max_data_return);
5866                 END_PROFILE(Trans2_open);
5867                 break;
5868         }
5869
5870         case TRANSACT2_FINDFIRST:
5871         {
5872                 START_PROFILE(Trans2_findfirst);
5873                 outsize = call_trans2findfirst(
5874                         conn, inbuf, outbuf, bufsize,
5875                         &state->param, state->total_param,
5876                         &state->data, state->total_data,
5877                         state->max_data_return);
5878                 END_PROFILE(Trans2_findfirst);
5879                 break;
5880         }
5881
5882         case TRANSACT2_FINDNEXT:
5883         {
5884                 START_PROFILE(Trans2_findnext);
5885                 outsize = call_trans2findnext(
5886                         conn, inbuf, outbuf, size, bufsize,
5887                         &state->param, state->total_param,
5888                         &state->data, state->total_data,
5889                         state->max_data_return);
5890                 END_PROFILE(Trans2_findnext);
5891                 break;
5892         }
5893
5894         case TRANSACT2_QFSINFO:
5895         {
5896                 START_PROFILE(Trans2_qfsinfo);
5897                 outsize = call_trans2qfsinfo(
5898                         conn, inbuf, outbuf, size, bufsize,
5899                         &state->param, state->total_param,
5900                         &state->data, state->total_data,
5901                         state->max_data_return);
5902                 END_PROFILE(Trans2_qfsinfo);
5903             break;
5904         }
5905
5906         case TRANSACT2_SETFSINFO:
5907         {
5908                 START_PROFILE(Trans2_setfsinfo);
5909                 outsize = call_trans2setfsinfo(
5910                         conn, inbuf, outbuf, size, bufsize,
5911                         &state->param, state->total_param,
5912                         &state->data, state->total_data,
5913                         state->max_data_return);
5914                 END_PROFILE(Trans2_setfsinfo);
5915                 break;
5916         }
5917
5918         case TRANSACT2_QPATHINFO:
5919         case TRANSACT2_QFILEINFO:
5920         {
5921                 START_PROFILE(Trans2_qpathinfo);
5922                 outsize = call_trans2qfilepathinfo(
5923                         conn, inbuf, outbuf, size, bufsize, state->call,
5924                         &state->param, state->total_param,
5925                         &state->data, state->total_data,
5926                         state->max_data_return);
5927                 END_PROFILE(Trans2_qpathinfo);
5928                 break;
5929         }
5930
5931         case TRANSACT2_SETPATHINFO:
5932         case TRANSACT2_SETFILEINFO:
5933         {
5934                 START_PROFILE(Trans2_setpathinfo);
5935                 outsize = call_trans2setfilepathinfo(
5936                         conn, inbuf, outbuf, size, bufsize, state->call,
5937                         &state->param, state->total_param,
5938                         &state->data, state->total_data,
5939                         state->max_data_return);
5940                 END_PROFILE(Trans2_setpathinfo);
5941                 break;
5942         }
5943
5944         case TRANSACT2_FINDNOTIFYFIRST:
5945         {
5946                 START_PROFILE(Trans2_findnotifyfirst);
5947                 outsize = call_trans2findnotifyfirst(
5948                         conn, inbuf, outbuf, size, bufsize,
5949                         &state->param, state->total_param,
5950                         &state->data, state->total_data,
5951                         state->max_data_return);
5952                 END_PROFILE(Trans2_findnotifyfirst);
5953                 break;
5954         }
5955
5956         case TRANSACT2_FINDNOTIFYNEXT:
5957         {
5958                 START_PROFILE(Trans2_findnotifynext);
5959                 outsize = call_trans2findnotifynext(
5960                         conn, inbuf, outbuf, size, bufsize,
5961                         &state->param, state->total_param,
5962                         &state->data, state->total_data,
5963                         state->max_data_return);
5964                 END_PROFILE(Trans2_findnotifynext);
5965                 break;
5966         }
5967
5968         case TRANSACT2_MKDIR:
5969         {
5970                 START_PROFILE(Trans2_mkdir);
5971                 outsize = call_trans2mkdir(
5972                         conn, inbuf, outbuf, size, bufsize,
5973                         &state->param, state->total_param,
5974                         &state->data, state->total_data,
5975                         state->max_data_return);
5976                 END_PROFILE(Trans2_mkdir);
5977                 break;
5978         }
5979
5980         case TRANSACT2_GET_DFS_REFERRAL:
5981         {
5982                 START_PROFILE(Trans2_get_dfs_referral);
5983                 outsize = call_trans2getdfsreferral(
5984                         conn, inbuf, outbuf, size, bufsize,
5985                         &state->param, state->total_param,
5986                         &state->data, state->total_data,
5987                         state->max_data_return);
5988                 END_PROFILE(Trans2_get_dfs_referral);
5989                 break;
5990         }
5991
5992         case TRANSACT2_IOCTL:
5993         {
5994                 START_PROFILE(Trans2_ioctl);
5995                 outsize = call_trans2ioctl(
5996                         conn, inbuf, outbuf, size, bufsize,
5997                         &state->param, state->total_param,
5998                         &state->data, state->total_data,
5999                         state->max_data_return);
6000                 END_PROFILE(Trans2_ioctl);
6001                 break;
6002         }
6003
6004         default:
6005                 /* Error in request */
6006                 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
6007                 outsize = ERROR_DOS(ERRSRV,ERRerror);
6008         }
6009
6010         return outsize;
6011 }
6012
6013 /****************************************************************************
6014  Reply to a SMBtrans2.
6015  ****************************************************************************/
6016
6017 int reply_trans2(connection_struct *conn, char *inbuf,char *outbuf,
6018                  int size, int bufsize)
6019 {
6020         int outsize = 0;
6021         unsigned int dsoff = SVAL(inbuf, smb_dsoff);
6022         unsigned int dscnt = SVAL(inbuf, smb_dscnt);
6023         unsigned int psoff = SVAL(inbuf, smb_psoff);
6024         unsigned int pscnt = SVAL(inbuf, smb_pscnt);
6025         unsigned int tran_call = SVAL(inbuf, smb_setup0);
6026         struct trans_state *state;
6027         NTSTATUS result;
6028
6029         START_PROFILE(SMBtrans2);
6030
6031         result = allow_new_trans(conn->pending_trans, SVAL(inbuf, smb_mid));
6032         if (!NT_STATUS_IS_OK(result)) {
6033                 DEBUG(2, ("Got invalid trans2 request: %s\n",
6034                           nt_errstr(result)));
6035                 END_PROFILE(SMBtrans2);
6036                 return ERROR_NT(result);
6037         }
6038
6039         if (IS_IPC(conn) && (tran_call != TRANSACT2_OPEN)
6040             && (tran_call != TRANSACT2_GET_DFS_REFERRAL)) {
6041                 END_PROFILE(SMBtrans2);
6042                 return ERROR_DOS(ERRSRV,ERRaccess);
6043         }
6044
6045         if ((state = TALLOC_P(conn->mem_ctx, struct trans_state)) == NULL) {
6046                 DEBUG(0, ("talloc failed\n"));
6047                 END_PROFILE(SMBtrans2);
6048                 return ERROR_NT(NT_STATUS_NO_MEMORY);
6049         }
6050
6051         state->cmd = SMBtrans2;
6052
6053         state->mid = SVAL(inbuf, smb_mid);
6054         state->vuid = SVAL(inbuf, smb_uid);
6055         state->setup_count = SVAL(inbuf, smb_suwcnt);
6056         state->setup = NULL;
6057         state->total_param = SVAL(inbuf, smb_tpscnt);
6058         state->param = NULL;
6059         state->total_data =  SVAL(inbuf, smb_tdscnt);
6060         state->data = NULL;
6061         state->max_param_return = SVAL(inbuf, smb_mprcnt);
6062         state->max_data_return  = SVAL(inbuf, smb_mdrcnt);
6063         state->max_setup_return = SVAL(inbuf, smb_msrcnt);
6064         state->close_on_completion = BITSETW(inbuf+smb_vwv5,0);
6065         state->one_way = BITSETW(inbuf+smb_vwv5,1);
6066
6067         state->call = tran_call;
6068
6069         /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
6070            is so as a sanity check */
6071         if (state->setup_count != 1) {
6072                 /*
6073                  * Need to have rc=0 for ioctl to get job id for OS/2.
6074                  *  Network printing will fail if function is not successful.
6075                  *  Similar function in reply.c will be used if protocol
6076                  *  is LANMAN1.0 instead of LM1.2X002.
6077                  *  Until DosPrintSetJobInfo with PRJINFO3 is supported,
6078                  *  outbuf doesn't have to be set(only job id is used).
6079                  */
6080                 if ( (state->setup_count == 4) && (tran_call == TRANSACT2_IOCTL) &&
6081                                 (SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
6082                                 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
6083                         DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
6084                 } else {
6085                         DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
6086                         DEBUG(2,("Transaction is %d\n",tran_call));
6087                         TALLOC_FREE(state);
6088                         END_PROFILE(SMBtrans2);
6089                         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6090                 }
6091         }
6092
6093         if ((dscnt > state->total_data) || (pscnt > state->total_param))
6094                 goto bad_param;
6095
6096         if (state->total_data) {
6097                 /* Can't use talloc here, the core routines do realloc on the
6098                  * params and data. */
6099                 state->data = (char *)SMB_MALLOC(state->total_data);
6100                 if (state->data == NULL) {
6101                         DEBUG(0,("reply_trans2: data malloc fail for %u "
6102                                  "bytes !\n", (unsigned int)state->total_data));
6103                         TALLOC_FREE(state);
6104                         END_PROFILE(SMBtrans2);
6105                         return(ERROR_DOS(ERRDOS,ERRnomem));
6106                 }
6107                 if ((dsoff+dscnt < dsoff) || (dsoff+dscnt < dscnt))
6108                         goto bad_param;
6109                 if ((smb_base(inbuf)+dsoff+dscnt > inbuf + size) ||
6110                     (smb_base(inbuf)+dsoff+dscnt < smb_base(inbuf)))
6111                         goto bad_param;
6112
6113                 memcpy(state->data,smb_base(inbuf)+dsoff,dscnt);
6114         }
6115
6116         if (state->total_param) {
6117                 /* Can't use talloc here, the core routines do realloc on the
6118                  * params and data. */
6119                 state->param = (char *)SMB_MALLOC(state->total_param);
6120                 if (state->param == NULL) {
6121                         DEBUG(0,("reply_trans: param malloc fail for %u "
6122                                  "bytes !\n", (unsigned int)state->total_param));
6123                         SAFE_FREE(state->data);
6124                         TALLOC_FREE(state);
6125                         END_PROFILE(SMBtrans2);
6126                         return(ERROR_DOS(ERRDOS,ERRnomem));
6127                 }
6128                 if ((psoff+pscnt < psoff) || (psoff+pscnt < pscnt))
6129                         goto bad_param;
6130                 if ((smb_base(inbuf)+psoff+pscnt > inbuf + size) ||
6131                     (smb_base(inbuf)+psoff+pscnt < smb_base(inbuf)))
6132                         goto bad_param;
6133
6134                 memcpy(state->param,smb_base(inbuf)+psoff,pscnt);
6135         }
6136
6137         state->received_data  = dscnt;
6138         state->received_param = pscnt;
6139
6140         if ((state->received_param == state->total_param) &&
6141             (state->received_data == state->total_data)) {
6142
6143                 outsize = handle_trans2(conn, state, inbuf, outbuf,
6144                                         size, bufsize);
6145                 SAFE_FREE(state->data);
6146                 SAFE_FREE(state->param);
6147                 TALLOC_FREE(state);
6148                 END_PROFILE(SMBtrans2);
6149                 return outsize;
6150         }
6151
6152         DLIST_ADD(conn->pending_trans, state);
6153
6154         /* We need to send an interim response then receive the rest
6155            of the parameter/data bytes */
6156         outsize = set_message(outbuf,0,0,False);
6157         show_msg(outbuf);
6158         END_PROFILE(SMBtrans2);
6159         return outsize;
6160
6161   bad_param:
6162
6163         DEBUG(0,("reply_trans2: invalid trans parameters\n"));
6164         SAFE_FREE(state->data);
6165         SAFE_FREE(state->param);
6166         TALLOC_FREE(state);
6167         END_PROFILE(SMBtrans2);
6168         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6169 }
6170
6171
6172 /****************************************************************************
6173  Reply to a SMBtranss2
6174  ****************************************************************************/
6175
6176 int reply_transs2(connection_struct *conn,
6177                   char *inbuf,char *outbuf,int size,int bufsize)
6178 {
6179         int outsize = 0;
6180         unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
6181         struct trans_state *state;
6182
6183         START_PROFILE(SMBtranss2);
6184
6185         show_msg(inbuf);
6186
6187         for (state = conn->pending_trans; state != NULL;
6188              state = state->next) {
6189                 if (state->mid == SVAL(inbuf,smb_mid)) {
6190                         break;
6191                 }
6192         }
6193
6194         if ((state == NULL) || (state->cmd != SMBtrans2)) {
6195                 END_PROFILE(SMBtranss2);
6196                 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6197         }
6198
6199         /* Revise state->total_param and state->total_data in case they have
6200            changed downwards */
6201
6202         if (SVAL(inbuf, smb_tpscnt) < state->total_param)
6203                 state->total_param = SVAL(inbuf, smb_tpscnt);
6204         if (SVAL(inbuf, smb_tdscnt) < state->total_data)
6205                 state->total_data = SVAL(inbuf, smb_tdscnt);
6206
6207         pcnt = SVAL(inbuf, smb_spscnt);
6208         poff = SVAL(inbuf, smb_spsoff);
6209         pdisp = SVAL(inbuf, smb_spsdisp);
6210
6211         dcnt = SVAL(inbuf, smb_sdscnt);
6212         doff = SVAL(inbuf, smb_sdsoff);
6213         ddisp = SVAL(inbuf, smb_sdsdisp);
6214
6215         state->received_param += pcnt;
6216         state->received_data += dcnt;
6217
6218         if ((state->received_data > state->total_data) ||
6219             (state->received_param > state->total_param))
6220                 goto bad_param;
6221
6222         if (pcnt) {
6223                 if (pdisp+pcnt > state->total_param)
6224                         goto bad_param;
6225                 if ((pdisp+pcnt < pdisp) || (pdisp+pcnt < pcnt))
6226                         goto bad_param;
6227                 if (pdisp > state->total_param)
6228                         goto bad_param;
6229                 if ((smb_base(inbuf) + poff + pcnt > inbuf + size) ||
6230                     (smb_base(inbuf) + poff + pcnt < smb_base(inbuf)))
6231                         goto bad_param;
6232                 if (state->param + pdisp < state->param)
6233                         goto bad_param;
6234
6235                 memcpy(state->param+pdisp,smb_base(inbuf)+poff,
6236                        pcnt);
6237         }
6238
6239         if (dcnt) {
6240                 if (ddisp+dcnt > state->total_data)
6241                         goto bad_param;
6242                 if ((ddisp+dcnt < ddisp) || (ddisp+dcnt < dcnt))
6243                         goto bad_param;
6244                 if (ddisp > state->total_data)
6245                         goto bad_param;
6246                 if ((smb_base(inbuf) + doff + dcnt > inbuf + size) ||
6247                     (smb_base(inbuf) + doff + dcnt < smb_base(inbuf)))
6248                         goto bad_param;
6249                 if (state->data + ddisp < state->data)
6250                         goto bad_param;
6251
6252                 memcpy(state->data+ddisp, smb_base(inbuf)+doff,
6253                        dcnt);
6254         }
6255
6256         if ((state->received_param < state->total_param) ||
6257             (state->received_data < state->total_data)) {
6258                 END_PROFILE(SMBtranss2);
6259                 return -1;
6260         }
6261
6262         /* construct_reply_common has done us the favor to pre-fill the
6263          * command field with SMBtranss2 which is wrong :-)
6264          */
6265         SCVAL(outbuf,smb_com,SMBtrans2);
6266
6267         outsize = handle_trans2(conn, state, inbuf, outbuf, size, bufsize);
6268
6269         DLIST_REMOVE(conn->pending_trans, state);
6270         SAFE_FREE(state->data);
6271         SAFE_FREE(state->param);
6272         TALLOC_FREE(state);
6273
6274         if (outsize == 0) {
6275                 END_PROFILE(SMBtranss2);
6276                 return(ERROR_DOS(ERRSRV,ERRnosupport));
6277         }
6278
6279         END_PROFILE(SMBtranss2);
6280         return(outsize);
6281
6282   bad_param:
6283
6284         DEBUG(0,("reply_transs2: invalid trans parameters\n"));
6285         DLIST_REMOVE(conn->pending_trans, state);
6286         SAFE_FREE(state->data);
6287         SAFE_FREE(state->param);
6288         TALLOC_FREE(state);
6289         END_PROFILE(SMBtranss2);
6290         return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6291 }