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-2007
7 Copyright (C) Steve French 2005
8 Copyright (C) James Peach 2006-2007
10 Extensively modified by Andrew Tridgell, 1995
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>.
27 #include "system/filesys.h"
29 #include "smbd/smbd.h"
30 #include "smbd/globals.h"
31 #include "../libcli/auth/libcli_auth.h"
32 #include "../librpc/gen_ndr/xattr.h"
33 #include "../librpc/gen_ndr/ndr_security.h"
34 #include "libcli/security/security.h"
37 #include "smbprofile.h"
38 #include "rpc_server/srv_pipe_hnd.h"
40 #define DIR_ENTRY_SAFETY_MARGIN 4096
42 static char *store_file_unix_basic(connection_struct *conn,
45 const SMB_STRUCT_STAT *psbuf);
47 static char *store_file_unix_basic_info2(connection_struct *conn,
50 const SMB_STRUCT_STAT *psbuf);
52 /********************************************************************
53 Roundup a value to the nearest allocation roundup size boundary.
54 Only do this for Windows clients.
55 ********************************************************************/
57 uint64_t smb_roundup(connection_struct *conn, uint64_t val)
59 uint64_t rval = lp_allocation_roundup_size(SNUM(conn));
61 /* Only roundup for Windows clients. */
62 enum remote_arch_types ra_type = get_remote_arch();
63 if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
64 val = SMB_ROUNDUP(val,rval);
69 /********************************************************************
70 Create a 64 bit FileIndex. If the file is on the same device as
71 the root of the share, just return the 64-bit inode. If it isn't,
72 mangle as we used to do.
73 ********************************************************************/
75 uint64_t get_FileIndex(connection_struct *conn, const SMB_STRUCT_STAT *psbuf)
78 if (conn->base_share_dev == psbuf->st_ex_dev) {
79 return (uint64_t)psbuf->st_ex_ino;
81 file_index = ((psbuf->st_ex_ino) & UINT32_MAX); /* FileIndexLow */
82 file_index |= ((uint64_t)((psbuf->st_ex_dev) & UINT32_MAX)) << 32; /* FileIndexHigh */
86 /****************************************************************************
87 Utility functions for dealing with extended attributes.
88 ****************************************************************************/
90 /****************************************************************************
91 Refuse to allow clients to overwrite our private xattrs.
92 ****************************************************************************/
94 static bool samba_private_attr_name(const char *unix_ea_name)
96 static const char * const prohibited_ea_names[] = {
97 SAMBA_POSIX_INHERITANCE_EA_NAME,
98 SAMBA_XATTR_DOS_ATTRIB,
106 for (i = 0; prohibited_ea_names[i]; i++) {
107 if (strequal( prohibited_ea_names[i], unix_ea_name))
110 if (strncasecmp_m(unix_ea_name, SAMBA_XATTR_DOSSTREAM_PREFIX,
111 strlen(SAMBA_XATTR_DOSSTREAM_PREFIX)) == 0) {
117 /****************************************************************************
118 Get one EA value. Fill in a struct ea_struct.
119 ****************************************************************************/
121 NTSTATUS get_ea_value(TALLOC_CTX *mem_ctx, connection_struct *conn,
122 files_struct *fsp, const char *fname,
123 const char *ea_name, struct ea_struct *pea)
125 /* Get the value of this xattr. Max size is 64k. */
126 size_t attr_size = 256;
132 val = talloc_realloc(mem_ctx, val, char, attr_size);
134 return NT_STATUS_NO_MEMORY;
137 if (fsp && fsp->fh->fd != -1) {
138 sizeret = SMB_VFS_FGETXATTR(fsp, ea_name, val, attr_size);
140 sizeret = SMB_VFS_GETXATTR(conn, fname, ea_name, val, attr_size);
143 if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
149 return map_nt_error_from_unix(errno);
152 DEBUG(10,("get_ea_value: EA %s is of length %u\n", ea_name, (unsigned int)sizeret));
153 dump_data(10, (uint8 *)val, sizeret);
156 if (strnequal(ea_name, "user.", 5)) {
157 pea->name = talloc_strdup(mem_ctx, &ea_name[5]);
159 pea->name = talloc_strdup(mem_ctx, ea_name);
161 if (pea->name == NULL) {
163 return NT_STATUS_NO_MEMORY;
165 pea->value.data = (unsigned char *)val;
166 pea->value.length = (size_t)sizeret;
170 NTSTATUS get_ea_names_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn,
171 files_struct *fsp, const char *fname,
172 char ***pnames, size_t *pnum_names)
174 /* Get a list of all xattrs. Max namesize is 64k. */
175 size_t ea_namelist_size = 1024;
176 char *ea_namelist = NULL;
181 ssize_t sizeret = -1;
183 if (!lp_ea_support(SNUM(conn))) {
192 * TALLOC the result early to get the talloc hierarchy right.
195 names = talloc_array(mem_ctx, char *, 1);
197 DEBUG(0, ("talloc failed\n"));
198 return NT_STATUS_NO_MEMORY;
201 while (ea_namelist_size <= 65536) {
203 ea_namelist = talloc_realloc(
204 names, ea_namelist, char, ea_namelist_size);
205 if (ea_namelist == NULL) {
206 DEBUG(0, ("talloc failed\n"));
208 return NT_STATUS_NO_MEMORY;
211 if (fsp && fsp->fh->fd != -1) {
212 sizeret = SMB_VFS_FLISTXATTR(fsp, ea_namelist,
215 sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist,
219 if ((sizeret == -1) && (errno == ERANGE)) {
220 ea_namelist_size *= 2;
229 return map_nt_error_from_unix(errno);
232 DEBUG(10, ("get_ea_list_from_file: ea_namelist size = %u\n",
233 (unsigned int)sizeret));
245 * Ensure the result is 0-terminated
248 if (ea_namelist[sizeret-1] != '\0') {
250 return NT_STATUS_INTERNAL_ERROR;
258 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
262 tmp = talloc_realloc(mem_ctx, names, char *, num_names);
264 DEBUG(0, ("talloc failed\n"));
266 return NT_STATUS_NO_MEMORY;
272 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
273 names[num_names++] = p;
281 *pnum_names = num_names;
285 /****************************************************************************
286 Return a linked list of the total EA's. Plus the total size
287 ****************************************************************************/
289 static struct ea_list *get_ea_list_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
290 const char *fname, size_t *pea_total_len)
292 /* Get a list of all xattrs. Max namesize is 64k. */
295 struct ea_list *ea_list_head = NULL;
300 if (!lp_ea_support(SNUM(conn))) {
304 status = get_ea_names_from_file(talloc_tos(), conn, fsp, fname,
307 if (!NT_STATUS_IS_OK(status) || (num_names == 0)) {
311 for (i=0; i<num_names; i++) {
312 struct ea_list *listp;
315 if (strnequal(names[i], "system.", 7)
316 || samba_private_attr_name(names[i]))
319 listp = talloc(mem_ctx, struct ea_list);
324 if (!NT_STATUS_IS_OK(get_ea_value(mem_ctx, conn, fsp,
330 push_ascii_fstring(dos_ea_name, listp->ea.name);
333 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
335 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len "
336 "= %u\n", (unsigned int)*pea_total_len, dos_ea_name,
337 (unsigned int)listp->ea.value.length));
339 DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
343 /* Add on 4 for total length. */
344 if (*pea_total_len) {
348 DEBUG(10, ("get_ea_list_from_file: total_len = %u\n",
349 (unsigned int)*pea_total_len));
354 /****************************************************************************
355 Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
357 ****************************************************************************/
359 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
360 connection_struct *conn, struct ea_list *ea_list)
362 unsigned int ret_data_size = 4;
365 SMB_ASSERT(total_data_size >= 4);
367 if (!lp_ea_support(SNUM(conn))) {
372 for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
375 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
376 dos_namelen = strlen(dos_ea_name);
377 if (dos_namelen > 255 || dos_namelen == 0) {
380 if (ea_list->ea.value.length > 65535) {
383 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
387 /* We know we have room. */
388 SCVAL(p,0,ea_list->ea.flags);
389 SCVAL(p,1,dos_namelen);
390 SSVAL(p,2,ea_list->ea.value.length);
391 strlcpy(p+4, dos_ea_name, dos_namelen+1);
392 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
394 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
395 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
398 ret_data_size = PTR_DIFF(p, pdata);
399 DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
400 SIVAL(pdata,0,ret_data_size);
401 return ret_data_size;
404 static NTSTATUS fill_ea_chained_buffer(TALLOC_CTX *mem_ctx,
406 unsigned int total_data_size,
407 unsigned int *ret_data_size,
408 connection_struct *conn,
409 struct ea_list *ea_list)
411 uint8_t *p = (uint8_t *)pdata;
412 uint8_t *last_start = NULL;
416 if (!lp_ea_support(SNUM(conn))) {
417 return NT_STATUS_NO_EAS_ON_FILE;
420 for (; ea_list; ea_list = ea_list->next) {
426 SIVAL(last_start, 0, PTR_DIFF(p, last_start));
430 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
431 dos_namelen = strlen(dos_ea_name);
432 if (dos_namelen > 255 || dos_namelen == 0) {
433 return NT_STATUS_INTERNAL_ERROR;
435 if (ea_list->ea.value.length > 65535) {
436 return NT_STATUS_INTERNAL_ERROR;
439 this_size = 0x08 + dos_namelen + 1 + ea_list->ea.value.length;
442 size_t pad = 4 - (this_size % 4);
446 if (this_size > total_data_size) {
447 return NT_STATUS_INFO_LENGTH_MISMATCH;
450 /* We know we have room. */
451 SIVAL(p, 0x00, 0); /* next offset */
452 SCVAL(p, 0x04, ea_list->ea.flags);
453 SCVAL(p, 0x05, dos_namelen);
454 SSVAL(p, 0x06, ea_list->ea.value.length);
455 strlcpy((char *)(p+0x08), dos_ea_name, dos_namelen+1);
456 memcpy(p + 0x08 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
458 total_data_size -= this_size;
462 *ret_data_size = PTR_DIFF(p, pdata);
463 DEBUG(10,("fill_ea_chained_buffer: data_size = %u\n", *ret_data_size));
467 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
469 size_t total_ea_len = 0;
470 TALLOC_CTX *mem_ctx = NULL;
472 if (!lp_ea_support(SNUM(conn))) {
475 mem_ctx = talloc_tos();
476 (void)get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
480 /****************************************************************************
481 Ensure the EA name is case insensitive by matching any existing EA name.
482 ****************************************************************************/
484 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
487 TALLOC_CTX *mem_ctx = talloc_tos();
488 struct ea_list *ea_list = get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
490 for (; ea_list; ea_list = ea_list->next) {
491 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
492 DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
493 &unix_ea_name[5], ea_list->ea.name));
494 strlcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-5);
500 /****************************************************************************
501 Set or delete an extended attribute.
502 ****************************************************************************/
504 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp,
505 const struct smb_filename *smb_fname, struct ea_list *ea_list)
509 if (!lp_ea_support(SNUM(conn))) {
510 return NT_STATUS_EAS_NOT_SUPPORTED;
513 if (fsp && !(fsp->access_mask & FILE_WRITE_EA)) {
514 return NT_STATUS_ACCESS_DENIED;
517 /* For now setting EAs on streams isn't supported. */
518 fname = smb_fname->base_name;
520 for (;ea_list; ea_list = ea_list->next) {
522 fstring unix_ea_name;
524 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
525 fstrcat(unix_ea_name, ea_list->ea.name);
527 canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
529 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
531 if (samba_private_attr_name(unix_ea_name)) {
532 DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
533 return NT_STATUS_ACCESS_DENIED;
536 if (ea_list->ea.value.length == 0) {
537 /* Remove the attribute. */
538 if (fsp && (fsp->fh->fd != -1)) {
539 DEBUG(10,("set_ea: deleting ea name %s on "
540 "file %s by file descriptor.\n",
541 unix_ea_name, fsp_str_dbg(fsp)));
542 ret = SMB_VFS_FREMOVEXATTR(fsp, unix_ea_name);
544 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
545 unix_ea_name, fname));
546 ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
549 /* Removing a non existent attribute always succeeds. */
550 if (ret == -1 && errno == ENOATTR) {
551 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
557 if (fsp && (fsp->fh->fd != -1)) {
558 DEBUG(10,("set_ea: setting ea name %s on file "
559 "%s by file descriptor.\n",
560 unix_ea_name, fsp_str_dbg(fsp)));
561 ret = SMB_VFS_FSETXATTR(fsp, unix_ea_name,
562 ea_list->ea.value.data, ea_list->ea.value.length, 0);
564 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
565 unix_ea_name, fname));
566 ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name,
567 ea_list->ea.value.data, ea_list->ea.value.length, 0);
573 if (errno == ENOTSUP) {
574 return NT_STATUS_EAS_NOT_SUPPORTED;
577 return map_nt_error_from_unix(errno);
583 /****************************************************************************
584 Read a list of EA names from an incoming data buffer. Create an ea_list with them.
585 ****************************************************************************/
587 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
589 struct ea_list *ea_list_head = NULL;
590 size_t converted_size, offset = 0;
592 while (offset + 2 < data_size) {
593 struct ea_list *eal = talloc_zero(ctx, struct ea_list);
594 unsigned int namelen = CVAL(pdata,offset);
596 offset++; /* Go past the namelen byte. */
598 /* integer wrap paranioa. */
599 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
600 (offset > data_size) || (namelen > data_size) ||
601 (offset + namelen >= data_size)) {
604 /* Ensure the name is null terminated. */
605 if (pdata[offset + namelen] != '\0') {
608 if (!pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset],
610 DEBUG(0,("read_ea_name_list: pull_ascii_talloc "
611 "failed: %s", strerror(errno)));
617 offset += (namelen + 1); /* Go past the name + terminating zero. */
618 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
619 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
625 /****************************************************************************
626 Read one EA list entry from the buffer.
627 ****************************************************************************/
629 struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
631 struct ea_list *eal = talloc_zero(ctx, struct ea_list);
633 unsigned int namelen;
634 size_t converted_size;
644 eal->ea.flags = CVAL(pdata,0);
645 namelen = CVAL(pdata,1);
646 val_len = SVAL(pdata,2);
648 if (4 + namelen + 1 + val_len > data_size) {
652 /* Ensure the name is null terminated. */
653 if (pdata[namelen + 4] != '\0') {
656 if (!pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4, &converted_size)) {
657 DEBUG(0,("read_ea_list_entry: pull_ascii_talloc failed: %s",
664 eal->ea.value = data_blob_talloc(eal, NULL, (size_t)val_len + 1);
665 if (!eal->ea.value.data) {
669 memcpy(eal->ea.value.data, pdata + 4 + namelen + 1, val_len);
671 /* Ensure we're null terminated just in case we print the value. */
672 eal->ea.value.data[val_len] = '\0';
673 /* But don't count the null. */
674 eal->ea.value.length--;
677 *pbytes_used = 4 + namelen + 1 + val_len;
680 DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal->ea.name));
681 dump_data(10, eal->ea.value.data, eal->ea.value.length);
686 /****************************************************************************
687 Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
688 ****************************************************************************/
690 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
692 struct ea_list *ea_list_head = NULL;
694 size_t bytes_used = 0;
696 while (offset < data_size) {
697 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
703 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
704 offset += bytes_used;
710 /****************************************************************************
711 Count the total EA size needed.
712 ****************************************************************************/
714 static size_t ea_list_size(struct ea_list *ealist)
717 struct ea_list *listp;
720 for (listp = ealist; listp; listp = listp->next) {
721 push_ascii_fstring(dos_ea_name, listp->ea.name);
722 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
724 /* Add on 4 for total length. */
732 /****************************************************************************
733 Return a union of EA's from a file list and a list of names.
734 The TALLOC context for the two lists *MUST* be identical as we steal
735 memory from one list to add to another. JRA.
736 ****************************************************************************/
738 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
740 struct ea_list *nlistp, *flistp;
742 for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
743 for (flistp = file_list; flistp; flistp = flistp->next) {
744 if (strequal(nlistp->ea.name, flistp->ea.name)) {
750 /* Copy the data from this entry. */
751 nlistp->ea.flags = flistp->ea.flags;
752 nlistp->ea.value = flistp->ea.value;
755 nlistp->ea.flags = 0;
756 ZERO_STRUCT(nlistp->ea.value);
760 *total_ea_len = ea_list_size(name_list);
764 /****************************************************************************
765 Send the required number of replies back.
766 We assume all fields other than the data fields are
767 set correctly for the type of call.
768 HACK ! Always assumes smb_setup field is zero.
769 ****************************************************************************/
771 void send_trans2_replies(connection_struct *conn,
772 struct smb_request *req,
779 /* As we are using a protocol > LANMAN1 then the max_send
780 variable must have been set in the sessetupX call.
781 This takes precedence over the max_xmit field in the
782 global struct. These different max_xmit variables should
783 be merged as this is now too confusing */
785 int data_to_send = datasize;
786 int params_to_send = paramsize;
788 const char *pp = params;
789 const char *pd = pdata;
790 int params_sent_thistime, data_sent_thistime, total_sent_thistime;
791 int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
792 int data_alignment_offset = 0;
793 bool overflow = False;
794 struct smbd_server_connection *sconn = req->sconn;
795 int max_send = sconn->smb1.sessions.max_send;
797 /* Modify the data_to_send and datasize and set the error if
798 we're trying to send more than max_data_bytes. We still send
799 the part of the packet(s) that fit. Strange, but needed
802 if (max_data_bytes > 0 && datasize > max_data_bytes) {
803 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
804 max_data_bytes, datasize ));
805 datasize = data_to_send = max_data_bytes;
809 /* If there genuinely are no parameters or data to send just send the empty packet */
811 if(params_to_send == 0 && data_to_send == 0) {
812 reply_outbuf(req, 10, 0);
813 show_msg((char *)req->outbuf);
814 if (!srv_send_smb(sconn,
817 IS_CONN_ENCRYPTED(conn),
819 exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
821 TALLOC_FREE(req->outbuf);
825 /* When sending params and data ensure that both are nicely aligned */
826 /* Only do this alignment when there is also data to send - else
827 can cause NT redirector problems. */
829 if (((params_to_send % 4) != 0) && (data_to_send != 0))
830 data_alignment_offset = 4 - (params_to_send % 4);
832 /* Space is bufsize minus Netbios over TCP header minus SMB header */
833 /* The alignment_offset is to align the param bytes on an even byte
834 boundary. NT 4.0 Beta needs this to work correctly. */
836 useable_space = max_send - (smb_size
839 + data_alignment_offset);
841 if (useable_space < 0) {
842 DEBUG(0, ("send_trans2_replies failed sanity useable_space "
843 "= %d!!!", useable_space));
844 exit_server_cleanly("send_trans2_replies: Not enough space");
847 while (params_to_send || data_to_send) {
848 /* Calculate whether we will totally or partially fill this packet */
850 total_sent_thistime = params_to_send + data_to_send;
852 /* We can never send more than useable_space */
854 * Note that 'useable_space' does not include the alignment offsets,
855 * but we must include the alignment offsets in the calculation of
856 * the length of the data we send over the wire, as the alignment offsets
857 * are sent here. Fix from Marc_Jacobsen@hp.com.
860 total_sent_thistime = MIN(total_sent_thistime, useable_space);
862 reply_outbuf(req, 10, total_sent_thistime + alignment_offset
863 + data_alignment_offset);
866 * We might have SMBtrans2s in req which was transferred to
867 * the outbuf, fix that.
869 SCVAL(req->outbuf, smb_com, SMBtrans2);
871 /* Set total params and data to be sent */
872 SSVAL(req->outbuf,smb_tprcnt,paramsize);
873 SSVAL(req->outbuf,smb_tdrcnt,datasize);
875 /* Calculate how many parameters and data we can fit into
876 * this packet. Parameters get precedence
879 params_sent_thistime = MIN(params_to_send,useable_space);
880 data_sent_thistime = useable_space - params_sent_thistime;
881 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
883 SSVAL(req->outbuf,smb_prcnt, params_sent_thistime);
885 /* smb_proff is the offset from the start of the SMB header to the
886 parameter bytes, however the first 4 bytes of outbuf are
887 the Netbios over TCP header. Thus use smb_base() to subtract
888 them from the calculation */
890 SSVAL(req->outbuf,smb_proff,
891 ((smb_buf(req->outbuf)+alignment_offset)
892 - smb_base(req->outbuf)));
894 if(params_sent_thistime == 0)
895 SSVAL(req->outbuf,smb_prdisp,0);
897 /* Absolute displacement of param bytes sent in this packet */
898 SSVAL(req->outbuf,smb_prdisp,pp - params);
900 SSVAL(req->outbuf,smb_drcnt, data_sent_thistime);
901 if(data_sent_thistime == 0) {
902 SSVAL(req->outbuf,smb_droff,0);
903 SSVAL(req->outbuf,smb_drdisp, 0);
905 /* The offset of the data bytes is the offset of the
906 parameter bytes plus the number of parameters being sent this time */
907 SSVAL(req->outbuf, smb_droff,
908 ((smb_buf(req->outbuf)+alignment_offset)
909 - smb_base(req->outbuf))
910 + params_sent_thistime + data_alignment_offset);
911 SSVAL(req->outbuf,smb_drdisp, pd - pdata);
914 /* Initialize the padding for alignment */
916 if (alignment_offset != 0) {
917 memset(smb_buf(req->outbuf), 0, alignment_offset);
920 /* Copy the param bytes into the packet */
922 if(params_sent_thistime) {
923 memcpy((smb_buf(req->outbuf)+alignment_offset), pp,
924 params_sent_thistime);
927 /* Copy in the data bytes */
928 if(data_sent_thistime) {
929 if (data_alignment_offset != 0) {
930 memset((smb_buf(req->outbuf)+alignment_offset+
931 params_sent_thistime), 0,
932 data_alignment_offset);
934 memcpy(smb_buf(req->outbuf)+alignment_offset
935 +params_sent_thistime+data_alignment_offset,
936 pd,data_sent_thistime);
939 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
940 params_sent_thistime, data_sent_thistime, useable_space));
941 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
942 params_to_send, data_to_send, paramsize, datasize));
945 error_packet_set((char *)req->outbuf,
946 ERRDOS,ERRbufferoverflow,
947 STATUS_BUFFER_OVERFLOW,
951 /* Send the packet */
952 show_msg((char *)req->outbuf);
953 if (!srv_send_smb(sconn,
956 IS_CONN_ENCRYPTED(conn),
958 exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
960 TALLOC_FREE(req->outbuf);
962 pp += params_sent_thistime;
963 pd += data_sent_thistime;
965 params_to_send -= params_sent_thistime;
966 data_to_send -= data_sent_thistime;
969 if(params_to_send < 0 || data_to_send < 0) {
970 DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
971 params_to_send, data_to_send));
979 /****************************************************************************
980 Reply to a TRANSACT2_OPEN.
981 ****************************************************************************/
983 static void call_trans2open(connection_struct *conn,
984 struct smb_request *req,
985 char **pparams, int total_params,
986 char **ppdata, int total_data,
987 unsigned int max_data_bytes)
989 struct smb_filename *smb_fname = NULL;
990 char *params = *pparams;
991 char *pdata = *ppdata;
996 bool return_additional_info;
1005 int fattr=0,mtime=0;
1006 SMB_INO_T inode = 0;
1009 struct ea_list *ea_list = NULL;
1014 uint32 create_disposition;
1015 uint32 create_options = 0;
1016 uint32_t private_flags = 0;
1017 TALLOC_CTX *ctx = talloc_tos();
1020 * Ensure we have enough parameters to perform the operation.
1023 if (total_params < 29) {
1024 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1028 flags = SVAL(params, 0);
1029 deny_mode = SVAL(params, 2);
1030 open_attr = SVAL(params,6);
1031 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
1032 if (oplock_request) {
1033 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
1037 return_additional_info = BITSETW(params,0);
1038 open_sattr = SVAL(params, 4);
1039 open_time = make_unix_date3(params+8);
1041 open_ofun = SVAL(params,12);
1042 open_size = IVAL(params,14);
1043 pname = ¶ms[28];
1046 reply_nterror(req, NT_STATUS_NETWORK_ACCESS_DENIED);
1050 srvstr_get_path(ctx, params, req->flags2, &fname, pname,
1051 total_params - 28, STR_TERMINATE,
1053 if (!NT_STATUS_IS_OK(status)) {
1054 reply_nterror(req, status);
1058 DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
1059 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
1060 (unsigned int)open_ofun, open_size));
1062 status = filename_convert(ctx,
1064 req->flags2 & FLAGS2_DFS_PATHNAMES,
1069 if (!NT_STATUS_IS_OK(status)) {
1070 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
1071 reply_botherror(req,
1072 NT_STATUS_PATH_NOT_COVERED,
1073 ERRSRV, ERRbadpath);
1076 reply_nterror(req, status);
1080 if (open_ofun == 0) {
1081 reply_nterror(req, NT_STATUS_OBJECT_NAME_COLLISION);
1085 if (!map_open_params_to_ntcreate(smb_fname->base_name, deny_mode,
1087 &access_mask, &share_mode,
1088 &create_disposition,
1091 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
1095 /* Any data in this call is an EA list. */
1096 if (total_data && (total_data != 4)) {
1097 if (total_data < 10) {
1098 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1102 if (IVAL(pdata,0) > total_data) {
1103 DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
1104 IVAL(pdata,0), (unsigned int)total_data));
1105 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1109 ea_list = read_ea_list(talloc_tos(), pdata + 4,
1112 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1116 if (!lp_ea_support(SNUM(conn))) {
1117 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
1122 status = SMB_VFS_CREATE_FILE(
1125 0, /* root_dir_fid */
1126 smb_fname, /* fname */
1127 access_mask, /* access_mask */
1128 share_mode, /* share_access */
1129 create_disposition, /* create_disposition*/
1130 create_options, /* create_options */
1131 open_attr, /* file_attributes */
1132 oplock_request, /* oplock_request */
1133 open_size, /* allocation_size */
1136 ea_list, /* ea_list */
1138 &smb_action); /* psbuf */
1140 if (!NT_STATUS_IS_OK(status)) {
1141 if (open_was_deferred(req->sconn, req->mid)) {
1142 /* We have re-scheduled this call. */
1145 reply_openerror(req, status);
1149 size = get_file_size_stat(&smb_fname->st);
1150 fattr = dos_mode(conn, smb_fname);
1151 mtime = convert_timespec_to_time_t(smb_fname->st.st_ex_mtime);
1152 inode = smb_fname->st.st_ex_ino;
1153 if (fattr & FILE_ATTRIBUTE_DIRECTORY) {
1154 close_file(req, fsp, ERROR_CLOSE);
1155 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
1159 /* Realloc the size of parameters and data we will return */
1160 *pparams = (char *)SMB_REALLOC(*pparams, 30);
1161 if(*pparams == NULL ) {
1162 reply_nterror(req, NT_STATUS_NO_MEMORY);
1167 SSVAL(params,0,fsp->fnum);
1168 SSVAL(params,2,fattr);
1169 srv_put_dos_date2(params,4, mtime);
1170 SIVAL(params,8, (uint32)size);
1171 SSVAL(params,12,deny_mode);
1172 SSVAL(params,14,0); /* open_type - file or directory. */
1173 SSVAL(params,16,0); /* open_state - only valid for IPC device. */
1175 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1176 smb_action |= EXTENDED_OPLOCK_GRANTED;
1179 SSVAL(params,18,smb_action);
1182 * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
1184 SIVAL(params,20,inode);
1185 SSVAL(params,24,0); /* Padding. */
1187 uint32 ea_size = estimate_ea_size(conn, fsp,
1188 fsp->fsp_name->base_name);
1189 SIVAL(params, 26, ea_size);
1191 SIVAL(params, 26, 0);
1194 /* Send the required number of replies */
1195 send_trans2_replies(conn, req, params, 30, *ppdata, 0, max_data_bytes);
1197 TALLOC_FREE(smb_fname);
1200 /*********************************************************
1201 Routine to check if a given string matches exactly.
1202 as a special case a mask of "." does NOT match. That
1203 is required for correct wildcard semantics
1204 Case can be significant or not.
1205 **********************************************************/
1207 static bool exact_match(bool has_wild,
1208 bool case_sensitive,
1212 if (mask[0] == '.' && mask[1] == 0) {
1220 if (case_sensitive) {
1221 return strcmp(str,mask)==0;
1223 return strcasecmp_m(str,mask) == 0;
1227 /****************************************************************************
1228 Return the filetype for UNIX extensions.
1229 ****************************************************************************/
1231 static uint32 unix_filetype(mode_t mode)
1234 return UNIX_TYPE_FILE;
1235 else if(S_ISDIR(mode))
1236 return UNIX_TYPE_DIR;
1238 else if(S_ISLNK(mode))
1239 return UNIX_TYPE_SYMLINK;
1242 else if(S_ISCHR(mode))
1243 return UNIX_TYPE_CHARDEV;
1246 else if(S_ISBLK(mode))
1247 return UNIX_TYPE_BLKDEV;
1250 else if(S_ISFIFO(mode))
1251 return UNIX_TYPE_FIFO;
1254 else if(S_ISSOCK(mode))
1255 return UNIX_TYPE_SOCKET;
1258 DEBUG(0,("unix_filetype: unknown filetype %u\n", (unsigned)mode));
1259 return UNIX_TYPE_UNKNOWN;
1262 /****************************************************************************
1263 Map wire perms onto standard UNIX permissions. Obey share restrictions.
1264 ****************************************************************************/
1266 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1268 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1269 const SMB_STRUCT_STAT *psbuf,
1271 enum perm_type ptype,
1276 if (perms == SMB_MODE_NO_CHANGE) {
1277 if (!VALID_STAT(*psbuf)) {
1278 return NT_STATUS_INVALID_PARAMETER;
1280 *ret_perms = psbuf->st_ex_mode;
1281 return NT_STATUS_OK;
1285 ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1286 ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1287 ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1288 ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1289 ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1290 ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1291 ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1292 ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1293 ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1295 ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1298 ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1301 ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1306 /* Apply mode mask */
1307 ret &= lp_create_mask(SNUM(conn));
1308 /* Add in force bits */
1309 ret |= lp_force_create_mode(SNUM(conn));
1312 ret &= lp_dir_mask(SNUM(conn));
1313 /* Add in force bits */
1314 ret |= lp_force_dir_mode(SNUM(conn));
1316 case PERM_EXISTING_FILE:
1317 /* Apply mode mask */
1318 ret &= lp_security_mask(SNUM(conn));
1319 /* Add in force bits */
1320 ret |= lp_force_security_mode(SNUM(conn));
1322 case PERM_EXISTING_DIR:
1323 /* Apply mode mask */
1324 ret &= lp_dir_security_mask(SNUM(conn));
1325 /* Add in force bits */
1326 ret |= lp_force_dir_security_mode(SNUM(conn));
1331 return NT_STATUS_OK;
1334 /****************************************************************************
1335 Needed to show the msdfs symlinks as directories. Modifies psbuf
1336 to be a directory if it's a msdfs link.
1337 ****************************************************************************/
1339 static bool check_msdfs_link(connection_struct *conn,
1340 const char *pathname,
1341 SMB_STRUCT_STAT *psbuf)
1343 int saved_errno = errno;
1344 if(lp_host_msdfs() &&
1345 lp_msdfs_root(SNUM(conn)) &&
1346 is_msdfs_link(conn, pathname, psbuf)) {
1348 DEBUG(5,("check_msdfs_link: Masquerading msdfs link %s "
1351 psbuf->st_ex_mode = (psbuf->st_ex_mode & 0xFFF) | S_IFDIR;
1352 errno = saved_errno;
1355 errno = saved_errno;
1360 /****************************************************************************
1361 Get a level dependent lanman2 dir entry.
1362 ****************************************************************************/
1364 struct smbd_dirptr_lanman2_state {
1365 connection_struct *conn;
1366 uint32_t info_level;
1367 bool check_mangled_names;
1369 bool got_exact_match;
1372 static bool smbd_dirptr_lanman2_match_fn(TALLOC_CTX *ctx,
1378 struct smbd_dirptr_lanman2_state *state =
1379 (struct smbd_dirptr_lanman2_state *)private_data;
1381 char mangled_name[13]; /* mangled 8.3 name. */
1385 /* Mangle fname if it's an illegal name. */
1386 if (mangle_must_mangle(dname, state->conn->params)) {
1387 ok = name_to_8_3(dname, mangled_name,
1388 true, state->conn->params);
1392 fname = mangled_name;
1397 got_match = exact_match(state->has_wild,
1398 state->conn->case_sensitive,
1400 state->got_exact_match = got_match;
1402 got_match = mask_match(fname, mask,
1403 state->conn->case_sensitive);
1406 if(!got_match && state->check_mangled_names &&
1407 !mangle_is_8_3(fname, false, state->conn->params)) {
1409 * It turns out that NT matches wildcards against
1410 * both long *and* short names. This may explain some
1411 * of the wildcard wierdness from old DOS clients
1412 * that some people have been seeing.... JRA.
1414 /* Force the mangling into 8.3. */
1415 ok = name_to_8_3(fname, mangled_name,
1416 false, state->conn->params);
1421 got_match = exact_match(state->has_wild,
1422 state->conn->case_sensitive,
1423 mangled_name, mask);
1424 state->got_exact_match = got_match;
1426 got_match = mask_match(mangled_name, mask,
1427 state->conn->case_sensitive);
1435 *_fname = talloc_strdup(ctx, fname);
1436 if (*_fname == NULL) {
1443 static bool smbd_dirptr_lanman2_mode_fn(TALLOC_CTX *ctx,
1445 struct smb_filename *smb_fname,
1448 struct smbd_dirptr_lanman2_state *state =
1449 (struct smbd_dirptr_lanman2_state *)private_data;
1450 bool ms_dfs_link = false;
1453 if (INFO_LEVEL_IS_UNIX(state->info_level)) {
1454 if (SMB_VFS_LSTAT(state->conn, smb_fname) != 0) {
1455 DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1456 "Couldn't lstat [%s] (%s)\n",
1457 smb_fname_str_dbg(smb_fname),
1461 } else if (!VALID_STAT(smb_fname->st) &&
1462 SMB_VFS_STAT(state->conn, smb_fname) != 0) {
1463 /* Needed to show the msdfs symlinks as
1466 ms_dfs_link = check_msdfs_link(state->conn,
1467 smb_fname->base_name,
1470 DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1471 "Couldn't stat [%s] (%s)\n",
1472 smb_fname_str_dbg(smb_fname),
1479 mode = dos_mode_msdfs(state->conn, smb_fname);
1481 mode = dos_mode(state->conn, smb_fname);
1488 static bool smbd_marshall_dir_entry(TALLOC_CTX *ctx,
1489 connection_struct *conn,
1491 uint32_t info_level,
1492 struct ea_list *name_list,
1493 bool check_mangled_names,
1494 bool requires_resume_key,
1497 const struct smb_filename *smb_fname,
1498 int space_remaining,
1505 uint64_t *last_entry_off)
1507 char *p, *q, *pdata = *ppdata;
1509 uint64_t file_size = 0;
1510 uint64_t allocation_size = 0;
1511 uint64_t file_index = 0;
1513 struct timespec mdate_ts, adate_ts, cdate_ts, create_date_ts;
1514 time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1515 time_t c_date = (time_t)0;
1517 char *last_entry_ptr;
1522 *out_of_space = false;
1524 ZERO_STRUCT(mdate_ts);
1525 ZERO_STRUCT(adate_ts);
1526 ZERO_STRUCT(create_date_ts);
1527 ZERO_STRUCT(cdate_ts);
1529 if (!(mode & FILE_ATTRIBUTE_DIRECTORY)) {
1530 file_size = get_file_size_stat(&smb_fname->st);
1532 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, NULL, &smb_fname->st);
1534 file_index = get_FileIndex(conn, &smb_fname->st);
1536 mdate_ts = smb_fname->st.st_ex_mtime;
1537 adate_ts = smb_fname->st.st_ex_atime;
1538 create_date_ts = get_create_timespec(conn, NULL, smb_fname);
1539 cdate_ts = get_change_timespec(conn, NULL, smb_fname);
1541 if (lp_dos_filetime_resolution(SNUM(conn))) {
1542 dos_filetime_timespec(&create_date_ts);
1543 dos_filetime_timespec(&mdate_ts);
1544 dos_filetime_timespec(&adate_ts);
1545 dos_filetime_timespec(&cdate_ts);
1548 create_date = convert_timespec_to_time_t(create_date_ts);
1549 mdate = convert_timespec_to_time_t(mdate_ts);
1550 adate = convert_timespec_to_time_t(adate_ts);
1551 c_date = convert_timespec_to_time_t(cdate_ts);
1553 /* align the record */
1554 SMB_ASSERT(align >= 1);
1556 off = (int)PTR_DIFF(pdata, base_data);
1557 pad = (off + (align-1)) & ~(align-1);
1560 if (pad && pad > space_remaining) {
1561 *out_of_space = true;
1562 DEBUG(9,("smbd_marshall_dir_entry: out of space "
1563 "for padding (wanted %u, had %d)\n",
1566 return false; /* Not finished - just out of space */
1570 /* initialize padding to 0 */
1572 memset(pdata, 0, pad);
1574 space_remaining -= pad;
1576 DEBUG(10,("smbd_marshall_dir_entry: space_remaining = %d\n",
1586 switch (info_level) {
1587 case SMB_FIND_INFO_STANDARD:
1588 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1589 if(requires_resume_key) {
1593 srv_put_dos_date2(p,0,create_date);
1594 srv_put_dos_date2(p,4,adate);
1595 srv_put_dos_date2(p,8,mdate);
1596 SIVAL(p,12,(uint32)file_size);
1597 SIVAL(p,16,(uint32)allocation_size);
1601 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1602 p += ucs2_align(base_data, p, 0);
1604 len = srvstr_push(base_data, flags2, p,
1605 fname, PTR_DIFF(end_data, p),
1607 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1609 SCVAL(nameptr, -1, len - 2);
1611 SCVAL(nameptr, -1, 0);
1615 SCVAL(nameptr, -1, len - 1);
1617 SCVAL(nameptr, -1, 0);
1623 case SMB_FIND_EA_SIZE:
1624 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_SIZE\n"));
1625 if (requires_resume_key) {
1629 srv_put_dos_date2(p,0,create_date);
1630 srv_put_dos_date2(p,4,adate);
1631 srv_put_dos_date2(p,8,mdate);
1632 SIVAL(p,12,(uint32)file_size);
1633 SIVAL(p,16,(uint32)allocation_size);
1636 unsigned int ea_size = estimate_ea_size(conn, NULL,
1637 smb_fname->base_name);
1638 SIVAL(p,22,ea_size); /* Extended attributes */
1642 len = srvstr_push(base_data, flags2,
1643 p, fname, PTR_DIFF(end_data, p),
1644 STR_TERMINATE | STR_NOALIGN);
1645 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1658 SCVAL(nameptr,0,len);
1660 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1663 case SMB_FIND_EA_LIST:
1665 struct ea_list *file_list = NULL;
1668 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_LIST\n"));
1672 if (requires_resume_key) {
1676 srv_put_dos_date2(p,0,create_date);
1677 srv_put_dos_date2(p,4,adate);
1678 srv_put_dos_date2(p,8,mdate);
1679 SIVAL(p,12,(uint32)file_size);
1680 SIVAL(p,16,(uint32)allocation_size);
1682 p += 22; /* p now points to the EA area. */
1684 file_list = get_ea_list_from_file(ctx, conn, NULL,
1685 smb_fname->base_name,
1687 name_list = ea_list_union(name_list, file_list, &ea_len);
1689 /* We need to determine if this entry will fit in the space available. */
1690 /* Max string size is 255 bytes. */
1691 if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1692 *out_of_space = true;
1693 DEBUG(9,("smbd_marshall_dir_entry: out of space "
1694 "(wanted %u, had %d)\n",
1695 (unsigned int)PTR_DIFF(p + 255 + ea_len,pdata),
1697 return False; /* Not finished - just out of space */
1700 /* Push the ea_data followed by the name. */
1701 p += fill_ea_buffer(ctx, p, space_remaining, conn, name_list);
1703 len = srvstr_push(base_data, flags2,
1704 p + 1, fname, PTR_DIFF(end_data, p+1),
1705 STR_TERMINATE | STR_NOALIGN);
1706 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1719 SCVAL(nameptr,0,len);
1721 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1725 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1726 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1727 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1729 SIVAL(p,0,reskey); p += 4;
1730 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1731 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1732 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1733 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1734 SOFF_T(p,0,file_size); p += 8;
1735 SOFF_T(p,0,allocation_size); p += 8;
1736 SIVAL(p,0,mode); p += 4;
1737 q = p; p += 4; /* q is placeholder for name length. */
1739 unsigned int ea_size = estimate_ea_size(conn, NULL,
1740 smb_fname->base_name);
1741 SIVAL(p,0,ea_size); /* Extended attributes */
1744 /* Clear the short name buffer. This is
1745 * IMPORTANT as not doing so will trigger
1746 * a Win2k client bug. JRA.
1748 if (!was_8_3 && check_mangled_names) {
1749 char mangled_name[13]; /* mangled 8.3 name. */
1750 if (!name_to_8_3(fname,mangled_name,True,
1752 /* Error - mangle failed ! */
1753 memset(mangled_name,'\0',12);
1755 mangled_name[12] = 0;
1756 len = srvstr_push(base_data, flags2,
1757 p+2, mangled_name, 24,
1758 STR_UPPER|STR_UNICODE);
1760 memset(p + 2 + len,'\0',24 - len);
1767 len = srvstr_push(base_data, flags2, p,
1768 fname, PTR_DIFF(end_data, p),
1769 STR_TERMINATE_ASCII);
1773 len = PTR_DIFF(p, pdata);
1774 pad = (len + (align-1)) & ~(align-1);
1776 * offset to the next entry, the caller
1777 * will overwrite it for the last entry
1778 * that's why we always include the padding
1782 * set padding to zero
1785 memset(p, 0, pad - len);
1792 case SMB_FIND_FILE_DIRECTORY_INFO:
1793 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1795 SIVAL(p,0,reskey); p += 4;
1796 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1797 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1798 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1799 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1800 SOFF_T(p,0,file_size); p += 8;
1801 SOFF_T(p,0,allocation_size); p += 8;
1802 SIVAL(p,0,mode); p += 4;
1803 len = srvstr_push(base_data, flags2,
1804 p + 4, fname, PTR_DIFF(end_data, p+4),
1805 STR_TERMINATE_ASCII);
1809 len = PTR_DIFF(p, pdata);
1810 pad = (len + (align-1)) & ~(align-1);
1812 * offset to the next entry, the caller
1813 * will overwrite it for the last entry
1814 * that's why we always include the padding
1818 * set padding to zero
1821 memset(p, 0, pad - len);
1828 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1829 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1831 SIVAL(p,0,reskey); p += 4;
1832 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1833 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1834 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1835 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1836 SOFF_T(p,0,file_size); p += 8;
1837 SOFF_T(p,0,allocation_size); p += 8;
1838 SIVAL(p,0,mode); p += 4;
1839 q = p; p += 4; /* q is placeholder for name length. */
1841 unsigned int ea_size = estimate_ea_size(conn, NULL,
1842 smb_fname->base_name);
1843 SIVAL(p,0,ea_size); /* Extended attributes */
1846 len = srvstr_push(base_data, flags2, p,
1847 fname, PTR_DIFF(end_data, p),
1848 STR_TERMINATE_ASCII);
1852 len = PTR_DIFF(p, pdata);
1853 pad = (len + (align-1)) & ~(align-1);
1855 * offset to the next entry, the caller
1856 * will overwrite it for the last entry
1857 * that's why we always include the padding
1861 * set padding to zero
1864 memset(p, 0, pad - len);
1871 case SMB_FIND_FILE_NAMES_INFO:
1872 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1874 SIVAL(p,0,reskey); p += 4;
1876 /* this must *not* be null terminated or w2k gets in a loop trying to set an
1877 acl on a dir (tridge) */
1878 len = srvstr_push(base_data, flags2, p,
1879 fname, PTR_DIFF(end_data, p),
1880 STR_TERMINATE_ASCII);
1884 len = PTR_DIFF(p, pdata);
1885 pad = (len + (align-1)) & ~(align-1);
1887 * offset to the next entry, the caller
1888 * will overwrite it for the last entry
1889 * that's why we always include the padding
1893 * set padding to zero
1896 memset(p, 0, pad - len);
1903 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1904 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1906 SIVAL(p,0,reskey); p += 4;
1907 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1908 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1909 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1910 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1911 SOFF_T(p,0,file_size); p += 8;
1912 SOFF_T(p,0,allocation_size); p += 8;
1913 SIVAL(p,0,mode); p += 4;
1914 q = p; p += 4; /* q is placeholder for name length. */
1916 unsigned int ea_size = estimate_ea_size(conn, NULL,
1917 smb_fname->base_name);
1918 SIVAL(p,0,ea_size); /* Extended attributes */
1921 SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1922 SBVAL(p,0,file_index); p += 8;
1923 len = srvstr_push(base_data, flags2, p,
1924 fname, PTR_DIFF(end_data, p),
1925 STR_TERMINATE_ASCII);
1929 len = PTR_DIFF(p, pdata);
1930 pad = (len + (align-1)) & ~(align-1);
1932 * offset to the next entry, the caller
1933 * will overwrite it for the last entry
1934 * that's why we always include the padding
1938 * set padding to zero
1941 memset(p, 0, pad - len);
1948 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1949 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1950 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1952 SIVAL(p,0,reskey); p += 4;
1953 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1954 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1955 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1956 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1957 SOFF_T(p,0,file_size); p += 8;
1958 SOFF_T(p,0,allocation_size); p += 8;
1959 SIVAL(p,0,mode); p += 4;
1960 q = p; p += 4; /* q is placeholder for name length */
1962 unsigned int ea_size = estimate_ea_size(conn, NULL,
1963 smb_fname->base_name);
1964 SIVAL(p,0,ea_size); /* Extended attributes */
1967 /* Clear the short name buffer. This is
1968 * IMPORTANT as not doing so will trigger
1969 * a Win2k client bug. JRA.
1971 if (!was_8_3 && check_mangled_names) {
1972 char mangled_name[13]; /* mangled 8.3 name. */
1973 if (!name_to_8_3(fname,mangled_name,True,
1975 /* Error - mangle failed ! */
1976 memset(mangled_name,'\0',12);
1978 mangled_name[12] = 0;
1979 len = srvstr_push(base_data, flags2,
1980 p+2, mangled_name, 24,
1981 STR_UPPER|STR_UNICODE);
1984 memset(p + 2 + len,'\0',24 - len);
1991 SSVAL(p,0,0); p += 2; /* Reserved ? */
1992 SBVAL(p,0,file_index); p += 8;
1993 len = srvstr_push(base_data, flags2, p,
1994 fname, PTR_DIFF(end_data, p),
1995 STR_TERMINATE_ASCII);
1999 len = PTR_DIFF(p, pdata);
2000 pad = (len + (align-1)) & ~(align-1);
2002 * offset to the next entry, the caller
2003 * will overwrite it for the last entry
2004 * that's why we always include the padding
2008 * set padding to zero
2011 memset(p, 0, pad - len);
2018 /* CIFS UNIX Extension. */
2020 case SMB_FIND_FILE_UNIX:
2021 case SMB_FIND_FILE_UNIX_INFO2:
2023 SIVAL(p,0,reskey); p+= 4; /* Used for continuing search. */
2025 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
2027 if (info_level == SMB_FIND_FILE_UNIX) {
2028 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX\n"));
2029 p = store_file_unix_basic(conn, p,
2030 NULL, &smb_fname->st);
2031 len = srvstr_push(base_data, flags2, p,
2032 fname, PTR_DIFF(end_data, p),
2035 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
2036 p = store_file_unix_basic_info2(conn, p,
2037 NULL, &smb_fname->st);
2040 len = srvstr_push(base_data, flags2, p, fname,
2041 PTR_DIFF(end_data, p), 0);
2042 SIVAL(nameptr, 0, len);
2047 len = PTR_DIFF(p, pdata);
2048 pad = (len + (align-1)) & ~(align-1);
2050 * offset to the next entry, the caller
2051 * will overwrite it for the last entry
2052 * that's why we always include the padding
2056 * set padding to zero
2059 memset(p, 0, pad - len);
2064 /* End of SMB_QUERY_FILE_UNIX_BASIC */
2072 if (PTR_DIFF(p,pdata) > space_remaining) {
2073 *out_of_space = true;
2074 DEBUG(9,("smbd_marshall_dir_entry: out of space "
2075 "(wanted %u, had %d)\n",
2076 (unsigned int)PTR_DIFF(p,pdata),
2078 return false; /* Not finished - just out of space */
2081 /* Setup the last entry pointer, as an offset from base_data */
2082 *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
2083 /* Advance the data pointer to the next slot */
2089 bool smbd_dirptr_lanman2_entry(TALLOC_CTX *ctx,
2090 connection_struct *conn,
2091 struct dptr_struct *dirptr,
2093 const char *path_mask,
2096 int requires_resume_key,
2104 int space_remaining,
2106 bool *got_exact_match,
2107 int *_last_entry_off,
2108 struct ea_list *name_list)
2111 const char *mask = NULL;
2112 long prev_dirpos = 0;
2115 struct smb_filename *smb_fname = NULL;
2116 struct smbd_dirptr_lanman2_state state;
2118 uint64_t last_entry_off = 0;
2122 state.info_level = info_level;
2123 state.check_mangled_names = lp_manglednames(conn->params);
2124 state.has_wild = dptr_has_wild(dirptr);
2125 state.got_exact_match = false;
2127 *out_of_space = false;
2128 *got_exact_match = false;
2130 p = strrchr_m(path_mask,'/');
2141 ok = smbd_dirptr_get_entry(ctx,
2147 smbd_dirptr_lanman2_match_fn,
2148 smbd_dirptr_lanman2_mode_fn,
2158 *got_exact_match = state.got_exact_match;
2160 ok = smbd_marshall_dir_entry(ctx,
2165 state.check_mangled_names,
2166 requires_resume_key,
2179 TALLOC_FREE(smb_fname);
2180 if (*out_of_space) {
2181 dptr_SeekDir(dirptr, prev_dirpos);
2188 *_last_entry_off = last_entry_off;
2192 static bool get_lanman2_dir_entry(TALLOC_CTX *ctx,
2193 connection_struct *conn,
2194 struct dptr_struct *dirptr,
2196 const char *path_mask,
2199 bool requires_resume_key,
2205 int space_remaining,
2207 bool *got_exact_match,
2208 int *last_entry_off,
2209 struct ea_list *name_list)
2212 const bool do_pad = true;
2214 if (info_level >= 1 && info_level <= 3) {
2215 /* No alignment on earlier info levels. */
2219 return smbd_dirptr_lanman2_entry(ctx, conn, dirptr, flags2,
2220 path_mask, dirtype, info_level,
2221 requires_resume_key, dont_descend, ask_sharemode,
2223 ppdata, base_data, end_data,
2225 out_of_space, got_exact_match,
2226 last_entry_off, name_list);
2229 /****************************************************************************
2230 Reply to a TRANS2_FINDFIRST.
2231 ****************************************************************************/
2233 static void call_trans2findfirst(connection_struct *conn,
2234 struct smb_request *req,
2235 char **pparams, int total_params,
2236 char **ppdata, int total_data,
2237 unsigned int max_data_bytes)
2239 /* We must be careful here that we don't return more than the
2240 allowed number of data bytes. If this means returning fewer than
2241 maxentries then so be it. We assume that the redirector has
2242 enough room for the fixed number of parameter bytes it has
2244 struct smb_filename *smb_dname = NULL;
2245 char *params = *pparams;
2246 char *pdata = *ppdata;
2250 uint16 findfirst_flags;
2251 bool close_after_first;
2253 bool requires_resume_key;
2255 char *directory = NULL;
2258 int last_entry_off=0;
2262 bool finished = False;
2263 bool dont_descend = False;
2264 bool out_of_space = False;
2265 int space_remaining;
2266 bool mask_contains_wcard = False;
2267 struct ea_list *ea_list = NULL;
2268 NTSTATUS ntstatus = NT_STATUS_OK;
2269 bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2270 TALLOC_CTX *ctx = talloc_tos();
2271 struct dptr_struct *dirptr = NULL;
2272 struct smbd_server_connection *sconn = req->sconn;
2273 uint32_t ucf_flags = (UCF_SAVE_LCOMP | UCF_ALWAYS_ALLOW_WCARD_LCOMP);
2275 if (total_params < 13) {
2276 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2280 dirtype = SVAL(params,0);
2281 maxentries = SVAL(params,2);
2282 findfirst_flags = SVAL(params,4);
2283 close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
2284 close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2285 requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2286 info_level = SVAL(params,6);
2288 DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
2289 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
2290 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
2291 info_level, max_data_bytes));
2294 /* W2K3 seems to treat zero as 1. */
2298 switch (info_level) {
2299 case SMB_FIND_INFO_STANDARD:
2300 case SMB_FIND_EA_SIZE:
2301 case SMB_FIND_EA_LIST:
2302 case SMB_FIND_FILE_DIRECTORY_INFO:
2303 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2304 case SMB_FIND_FILE_NAMES_INFO:
2305 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2306 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2307 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2309 case SMB_FIND_FILE_UNIX:
2310 case SMB_FIND_FILE_UNIX_INFO2:
2311 /* Always use filesystem for UNIX mtime query. */
2312 ask_sharemode = false;
2313 if (!lp_unix_extensions()) {
2314 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2317 ucf_flags |= UCF_UNIX_NAME_LOOKUP;
2320 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2324 srvstr_get_path_wcard(ctx, params, req->flags2, &directory,
2325 params+12, total_params - 12,
2326 STR_TERMINATE, &ntstatus, &mask_contains_wcard);
2327 if (!NT_STATUS_IS_OK(ntstatus)) {
2328 reply_nterror(req, ntstatus);
2332 ntstatus = filename_convert(ctx, conn,
2333 req->flags2 & FLAGS2_DFS_PATHNAMES,
2336 &mask_contains_wcard,
2338 if (!NT_STATUS_IS_OK(ntstatus)) {
2339 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_PATH_NOT_COVERED)) {
2340 reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
2341 ERRSRV, ERRbadpath);
2344 reply_nterror(req, ntstatus);
2348 mask = smb_dname->original_lcomp;
2350 directory = smb_dname->base_name;
2352 p = strrchr_m(directory,'/');
2354 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
2355 if((directory[0] == '.') && (directory[1] == '\0')) {
2356 mask = talloc_strdup(ctx,"*");
2358 reply_nterror(req, NT_STATUS_NO_MEMORY);
2361 mask_contains_wcard = True;
2367 if (p == NULL || p == directory) {
2368 /* Ensure we don't have a directory name of "". */
2369 directory = talloc_strdup(talloc_tos(), ".");
2371 reply_nterror(req, NT_STATUS_NO_MEMORY);
2376 DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
2378 if (info_level == SMB_FIND_EA_LIST) {
2381 if (total_data < 4) {
2382 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2386 ea_size = IVAL(pdata,0);
2387 if (ea_size != total_data) {
2388 DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
2389 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2390 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2394 if (!lp_ea_support(SNUM(conn))) {
2395 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
2399 /* Pull out the list of names. */
2400 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2402 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2407 *ppdata = (char *)SMB_REALLOC(
2408 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2409 if(*ppdata == NULL ) {
2410 reply_nterror(req, NT_STATUS_NO_MEMORY);
2414 data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2416 /* Realloc the params space */
2417 *pparams = (char *)SMB_REALLOC(*pparams, 10);
2418 if (*pparams == NULL) {
2419 reply_nterror(req, NT_STATUS_NO_MEMORY);
2424 /* Save the wildcard match and attribs we are using on this directory -
2425 needed as lanman2 assumes these are being saved between calls */
2427 ntstatus = dptr_create(conn,
2434 mask_contains_wcard,
2438 if (!NT_STATUS_IS_OK(ntstatus)) {
2439 reply_nterror(req, ntstatus);
2443 dptr_num = dptr_dnum(dirptr);
2444 DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
2446 /* Initialize per TRANS2_FIND_FIRST operation data */
2447 dptr_init_search_op(dirptr);
2449 /* We don't need to check for VOL here as this is returned by
2450 a different TRANS2 call. */
2452 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2453 directory,lp_dontdescend(SNUM(conn))));
2454 if (in_list(directory,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2455 dont_descend = True;
2458 space_remaining = max_data_bytes;
2459 out_of_space = False;
2461 for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
2462 bool got_exact_match = False;
2464 /* this is a heuristic to avoid seeking the dirptr except when
2465 absolutely necessary. It allows for a filename of about 40 chars */
2466 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2467 out_of_space = True;
2470 finished = !get_lanman2_dir_entry(ctx,
2474 mask,dirtype,info_level,
2475 requires_resume_key,dont_descend,
2478 space_remaining, &out_of_space,
2480 &last_entry_off, ea_list);
2483 if (finished && out_of_space)
2486 if (!finished && !out_of_space)
2490 * As an optimisation if we know we aren't looking
2491 * for a wildcard name (ie. the name matches the wildcard exactly)
2492 * then we can finish on any (first) match.
2493 * This speeds up large directory searches. JRA.
2499 /* Ensure space_remaining never goes -ve. */
2500 if (PTR_DIFF(p,pdata) > max_data_bytes) {
2501 space_remaining = 0;
2502 out_of_space = true;
2504 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2508 /* Check if we can close the dirptr */
2509 if(close_after_first || (finished && close_if_end)) {
2510 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
2511 dptr_close(sconn, &dptr_num);
2515 * If there are no matching entries we must return ERRDOS/ERRbadfile -
2516 * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2517 * the protocol level is less than NT1. Tested with smbclient. JRA.
2518 * This should fix the OS/2 client bug #2335.
2521 if(numentries == 0) {
2522 dptr_close(sconn, &dptr_num);
2523 if (get_Protocol() < PROTOCOL_NT1) {
2524 reply_force_doserror(req, ERRDOS, ERRnofiles);
2527 reply_botherror(req, NT_STATUS_NO_SUCH_FILE,
2528 ERRDOS, ERRbadfile);
2533 /* At this point pdata points to numentries directory entries. */
2535 /* Set up the return parameter block */
2536 SSVAL(params,0,dptr_num);
2537 SSVAL(params,2,numentries);
2538 SSVAL(params,4,finished);
2539 SSVAL(params,6,0); /* Never an EA error */
2540 SSVAL(params,8,last_entry_off);
2542 send_trans2_replies(conn, req, params, 10, pdata, PTR_DIFF(p,pdata),
2545 if ((! *directory) && dptr_path(sconn, dptr_num)) {
2546 directory = talloc_strdup(talloc_tos(),dptr_path(sconn, dptr_num));
2548 reply_nterror(req, NT_STATUS_NO_MEMORY);
2552 DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2553 smb_fn_name(req->cmd),
2554 mask, directory, dirtype, numentries ) );
2557 * Force a name mangle here to ensure that the
2558 * mask as an 8.3 name is top of the mangled cache.
2559 * The reasons for this are subtle. Don't remove
2560 * this code unless you know what you are doing
2561 * (see PR#13758). JRA.
2564 if(!mangle_is_8_3_wildcards( mask, False, conn->params)) {
2565 char mangled_name[13];
2566 name_to_8_3(mask, mangled_name, True, conn->params);
2569 TALLOC_FREE(smb_dname);
2573 /****************************************************************************
2574 Reply to a TRANS2_FINDNEXT.
2575 ****************************************************************************/
2577 static void call_trans2findnext(connection_struct *conn,
2578 struct smb_request *req,
2579 char **pparams, int total_params,
2580 char **ppdata, int total_data,
2581 unsigned int max_data_bytes)
2583 /* We must be careful here that we don't return more than the
2584 allowed number of data bytes. If this means returning fewer than
2585 maxentries then so be it. We assume that the redirector has
2586 enough room for the fixed number of parameter bytes it has
2588 char *params = *pparams;
2589 char *pdata = *ppdata;
2595 uint16 findnext_flags;
2596 bool close_after_request;
2598 bool requires_resume_key;
2600 bool mask_contains_wcard = False;
2601 char *resume_name = NULL;
2602 const char *mask = NULL;
2603 const char *directory = NULL;
2607 int i, last_entry_off=0;
2608 bool finished = False;
2609 bool dont_descend = False;
2610 bool out_of_space = False;
2611 int space_remaining;
2612 struct ea_list *ea_list = NULL;
2613 NTSTATUS ntstatus = NT_STATUS_OK;
2614 bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2615 TALLOC_CTX *ctx = talloc_tos();
2616 struct dptr_struct *dirptr;
2617 struct smbd_server_connection *sconn = req->sconn;
2619 if (total_params < 13) {
2620 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2624 dptr_num = SVAL(params,0);
2625 maxentries = SVAL(params,2);
2626 info_level = SVAL(params,4);
2627 resume_key = IVAL(params,6);
2628 findnext_flags = SVAL(params,10);
2629 close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
2630 close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2631 requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2632 continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
2634 if (!continue_bit) {
2635 /* We only need resume_name if continue_bit is zero. */
2636 srvstr_get_path_wcard(ctx, params, req->flags2, &resume_name,
2638 total_params - 12, STR_TERMINATE, &ntstatus,
2639 &mask_contains_wcard);
2640 if (!NT_STATUS_IS_OK(ntstatus)) {
2641 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2642 complain (it thinks we're asking for the directory above the shared
2643 path or an invalid name). Catch this as the resume name is only compared, never used in
2644 a file access. JRA. */
2645 srvstr_pull_talloc(ctx, params, req->flags2,
2646 &resume_name, params+12,
2650 if (!resume_name || !(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
2651 reply_nterror(req, ntstatus);
2657 DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2658 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2659 resume_key = %d resume name = %s continue=%d level = %d\n",
2660 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
2661 requires_resume_key, resume_key,
2662 resume_name ? resume_name : "(NULL)", continue_bit, info_level));
2665 /* W2K3 seems to treat zero as 1. */
2669 switch (info_level) {
2670 case SMB_FIND_INFO_STANDARD:
2671 case SMB_FIND_EA_SIZE:
2672 case SMB_FIND_EA_LIST:
2673 case SMB_FIND_FILE_DIRECTORY_INFO:
2674 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2675 case SMB_FIND_FILE_NAMES_INFO:
2676 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2677 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2678 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2680 case SMB_FIND_FILE_UNIX:
2681 case SMB_FIND_FILE_UNIX_INFO2:
2682 /* Always use filesystem for UNIX mtime query. */
2683 ask_sharemode = false;
2684 if (!lp_unix_extensions()) {
2685 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2690 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2694 if (info_level == SMB_FIND_EA_LIST) {
2697 if (total_data < 4) {
2698 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2702 ea_size = IVAL(pdata,0);
2703 if (ea_size != total_data) {
2704 DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2705 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2706 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2710 if (!lp_ea_support(SNUM(conn))) {
2711 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
2715 /* Pull out the list of names. */
2716 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2718 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2723 *ppdata = (char *)SMB_REALLOC(
2724 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2725 if(*ppdata == NULL) {
2726 reply_nterror(req, NT_STATUS_NO_MEMORY);
2731 data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2733 /* Realloc the params space */
2734 *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2735 if(*pparams == NULL ) {
2736 reply_nterror(req, NT_STATUS_NO_MEMORY);
2742 /* Check that the dptr is valid */
2743 if(!(dirptr = dptr_fetch_lanman2(sconn, dptr_num))) {
2744 reply_nterror(req, STATUS_NO_MORE_FILES);
2748 directory = dptr_path(sconn, dptr_num);
2750 /* Get the wildcard mask from the dptr */
2751 if((p = dptr_wcard(sconn, dptr_num))== NULL) {
2752 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2753 reply_nterror(req, STATUS_NO_MORE_FILES);
2759 /* Get the attr mask from the dptr */
2760 dirtype = dptr_attr(sconn, dptr_num);
2762 DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2763 dptr_num, mask, dirtype,
2765 dptr_TellDir(dirptr)));
2767 /* Initialize per TRANS2_FIND_NEXT operation data */
2768 dptr_init_search_op(dirptr);
2770 /* We don't need to check for VOL here as this is returned by
2771 a different TRANS2 call. */
2773 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2774 directory,lp_dontdescend(SNUM(conn))));
2775 if (in_list(directory,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2776 dont_descend = True;
2779 space_remaining = max_data_bytes;
2780 out_of_space = False;
2783 * Seek to the correct position. We no longer use the resume key but
2784 * depend on the last file name instead.
2787 if(!continue_bit && resume_name && *resume_name) {
2790 long current_pos = 0;
2792 * Remember, name_to_8_3 is called by
2793 * get_lanman2_dir_entry(), so the resume name
2794 * could be mangled. Ensure we check the unmangled name.
2797 if (mangle_is_mangled(resume_name, conn->params)) {
2798 char *new_resume_name = NULL;
2799 mangle_lookup_name_from_8_3(ctx,
2803 if (new_resume_name) {
2804 resume_name = new_resume_name;
2809 * Fix for NT redirector problem triggered by resume key indexes
2810 * changing between directory scans. We now return a resume key of 0
2811 * and instead look for the filename to continue from (also given
2812 * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2813 * findfirst/findnext (as is usual) then the directory pointer
2814 * should already be at the correct place.
2817 finished = !dptr_SearchDir(dirptr, resume_name, ¤t_pos, &st);
2818 } /* end if resume_name && !continue_bit */
2820 for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2821 bool got_exact_match = False;
2823 /* this is a heuristic to avoid seeking the dirptr except when
2824 absolutely necessary. It allows for a filename of about 40 chars */
2825 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2826 out_of_space = True;
2829 finished = !get_lanman2_dir_entry(ctx,
2833 mask,dirtype,info_level,
2834 requires_resume_key,dont_descend,
2837 space_remaining, &out_of_space,
2839 &last_entry_off, ea_list);
2842 if (finished && out_of_space)
2845 if (!finished && !out_of_space)
2849 * As an optimisation if we know we aren't looking
2850 * for a wildcard name (ie. the name matches the wildcard exactly)
2851 * then we can finish on any (first) match.
2852 * This speeds up large directory searches. JRA.
2858 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2861 DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2862 smb_fn_name(req->cmd),
2863 mask, directory, dirtype, numentries ) );
2865 /* Check if we can close the dirptr */
2866 if(close_after_request || (finished && close_if_end)) {
2867 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2868 dptr_close(sconn, &dptr_num); /* This frees up the saved mask */
2871 /* Set up the return parameter block */
2872 SSVAL(params,0,numentries);
2873 SSVAL(params,2,finished);
2874 SSVAL(params,4,0); /* Never an EA error */
2875 SSVAL(params,6,last_entry_off);
2877 send_trans2_replies(conn, req, params, 8, pdata, PTR_DIFF(p,pdata),
2883 unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
2885 E_md4hash(lp_servicename(SNUM(conn)),objid);
2889 static void samba_extended_info_version(struct smb_extended_info *extended_info)
2891 SMB_ASSERT(extended_info != NULL);
2893 extended_info->samba_magic = SAMBA_EXTENDED_INFO_MAGIC;
2894 extended_info->samba_version = ((SAMBA_VERSION_MAJOR & 0xff) << 24)
2895 | ((SAMBA_VERSION_MINOR & 0xff) << 16)
2896 | ((SAMBA_VERSION_RELEASE & 0xff) << 8);
2897 #ifdef SAMBA_VERSION_REVISION
2898 extended_info->samba_version |= (tolower(*SAMBA_VERSION_REVISION) - 'a' + 1) & 0xff;
2900 extended_info->samba_subversion = 0;
2901 #ifdef SAMBA_VERSION_RC_RELEASE
2902 extended_info->samba_subversion |= (SAMBA_VERSION_RC_RELEASE & 0xff) << 24;
2904 #ifdef SAMBA_VERSION_PRE_RELEASE
2905 extended_info->samba_subversion |= (SAMBA_VERSION_PRE_RELEASE & 0xff) << 16;
2908 #ifdef SAMBA_VERSION_VENDOR_PATCH
2909 extended_info->samba_subversion |= (SAMBA_VERSION_VENDOR_PATCH & 0xffff);
2911 extended_info->samba_gitcommitdate = 0;
2912 #ifdef SAMBA_VERSION_COMMIT_TIME
2913 unix_to_nt_time(&extended_info->samba_gitcommitdate, SAMBA_VERSION_COMMIT_TIME);
2916 memset(extended_info->samba_version_string, 0,
2917 sizeof(extended_info->samba_version_string));
2919 snprintf (extended_info->samba_version_string,
2920 sizeof(extended_info->samba_version_string),
2921 "%s", samba_version_string());
2924 NTSTATUS smbd_do_qfsinfo(connection_struct *conn,
2925 TALLOC_CTX *mem_ctx,
2926 uint16_t info_level,
2928 unsigned int max_data_bytes,
2932 char *pdata, *end_data;
2933 int data_len = 0, len;
2934 const char *vname = volume_label(SNUM(conn));
2935 int snum = SNUM(conn);
2936 char *fstype = lp_fstype(SNUM(conn));
2937 uint32 additional_flags = 0;
2938 struct smb_filename smb_fname_dot;
2942 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
2943 DEBUG(0,("smbd_do_qfsinfo: not an allowed "
2944 "info level (0x%x) on IPC$.\n",
2945 (unsigned int)info_level));
2946 return NT_STATUS_ACCESS_DENIED;
2950 DEBUG(3,("smbd_do_qfsinfo: level = %d\n", info_level));
2952 ZERO_STRUCT(smb_fname_dot);
2953 smb_fname_dot.base_name = discard_const_p(char, ".");
2955 if(SMB_VFS_STAT(conn, &smb_fname_dot) != 0) {
2956 DEBUG(2,("stat of . failed (%s)\n", strerror(errno)));
2957 return map_nt_error_from_unix(errno);
2960 st = smb_fname_dot.st;
2962 *ppdata = (char *)SMB_REALLOC(
2963 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2964 if (*ppdata == NULL) {
2965 return NT_STATUS_NO_MEMORY;
2969 memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2970 end_data = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2972 switch (info_level) {
2973 case SMB_INFO_ALLOCATION:
2975 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2977 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
2978 return map_nt_error_from_unix(errno);
2981 block_size = lp_block_size(snum);
2982 if (bsize < block_size) {
2983 uint64_t factor = block_size/bsize;
2988 if (bsize > block_size) {
2989 uint64_t factor = bsize/block_size;
2994 bytes_per_sector = 512;
2995 sectors_per_unit = bsize/bytes_per_sector;
2997 DEBUG(5,("smbd_do_qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2998 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_ex_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2999 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3001 SIVAL(pdata,l1_idFileSystem,st.st_ex_dev);
3002 SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
3003 SIVAL(pdata,l1_cUnit,dsize);
3004 SIVAL(pdata,l1_cUnitAvail,dfree);
3005 SSVAL(pdata,l1_cbSector,bytes_per_sector);
3009 case SMB_INFO_VOLUME:
3010 /* Return volume name */
3012 * Add volume serial number - hash of a combination of
3013 * the called hostname and the service name.
3015 SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
3017 * Win2k3 and previous mess this up by sending a name length
3018 * one byte short. I believe only older clients (OS/2 Win9x) use
3019 * this call so try fixing this by adding a terminating null to
3020 * the pushed string. The change here was adding the STR_TERMINATE. JRA.
3024 pdata+l2_vol_szVolLabel, vname,
3025 PTR_DIFF(end_data, pdata+l2_vol_szVolLabel),
3026 STR_NOALIGN|STR_TERMINATE);
3027 SCVAL(pdata,l2_vol_cch,len);
3028 data_len = l2_vol_szVolLabel + len;
3029 DEBUG(5,("smbd_do_qfsinfo : time = %x, namelen = %d, name = %s\n",
3030 (unsigned)convert_timespec_to_time_t(st.st_ex_ctime),
3034 case SMB_QUERY_FS_ATTRIBUTE_INFO:
3035 case SMB_FS_ATTRIBUTE_INFORMATION:
3037 additional_flags = 0;
3038 #if defined(HAVE_SYS_QUOTAS)
3039 additional_flags |= FILE_VOLUME_QUOTAS;
3042 if(lp_nt_acl_support(SNUM(conn))) {
3043 additional_flags |= FILE_PERSISTENT_ACLS;
3046 /* Capabilities are filled in at connection time through STATVFS call */
3047 additional_flags |= conn->fs_capabilities;
3048 additional_flags |= lp_parm_int(conn->params->service,
3049 "share", "fake_fscaps",
3052 SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
3053 FILE_SUPPORTS_OBJECT_IDS|FILE_UNICODE_ON_DISK|
3054 additional_flags); /* FS ATTRIBUTES */
3056 SIVAL(pdata,4,255); /* Max filename component length */
3057 /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
3058 and will think we can't do long filenames */
3059 len = srvstr_push(pdata, flags2, pdata+12, fstype,
3060 PTR_DIFF(end_data, pdata+12),
3063 data_len = 12 + len;
3066 case SMB_QUERY_FS_LABEL_INFO:
3067 case SMB_FS_LABEL_INFORMATION:
3068 len = srvstr_push(pdata, flags2, pdata+4, vname,
3069 PTR_DIFF(end_data, pdata+4), 0);
3074 case SMB_QUERY_FS_VOLUME_INFO:
3075 case SMB_FS_VOLUME_INFORMATION:
3078 * Add volume serial number - hash of a combination of
3079 * the called hostname and the service name.
3081 SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
3082 (str_checksum(get_local_machine_name())<<16));
3084 /* Max label len is 32 characters. */
3085 len = srvstr_push(pdata, flags2, pdata+18, vname,
3086 PTR_DIFF(end_data, pdata+18),
3088 SIVAL(pdata,12,len);
3091 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
3092 (int)strlen(vname),vname, lp_servicename(snum)));
3095 case SMB_QUERY_FS_SIZE_INFO:
3096 case SMB_FS_SIZE_INFORMATION:
3098 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3100 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3101 return map_nt_error_from_unix(errno);
3103 block_size = lp_block_size(snum);
3104 if (bsize < block_size) {
3105 uint64_t factor = block_size/bsize;
3110 if (bsize > block_size) {
3111 uint64_t factor = bsize/block_size;
3116 bytes_per_sector = 512;
3117 sectors_per_unit = bsize/bytes_per_sector;
3118 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3119 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3120 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3121 SBIG_UINT(pdata,0,dsize);
3122 SBIG_UINT(pdata,8,dfree);
3123 SIVAL(pdata,16,sectors_per_unit);
3124 SIVAL(pdata,20,bytes_per_sector);
3128 case SMB_FS_FULL_SIZE_INFORMATION:
3130 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3132 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3133 return map_nt_error_from_unix(errno);
3135 block_size = lp_block_size(snum);
3136 if (bsize < block_size) {
3137 uint64_t factor = block_size/bsize;
3142 if (bsize > block_size) {
3143 uint64_t factor = bsize/block_size;
3148 bytes_per_sector = 512;
3149 sectors_per_unit = bsize/bytes_per_sector;
3150 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3151 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3152 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3153 SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
3154 SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
3155 SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
3156 SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
3157 SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
3161 case SMB_QUERY_FS_DEVICE_INFO:
3162 case SMB_FS_DEVICE_INFORMATION:
3164 uint32_t characteristics = FILE_DEVICE_IS_MOUNTED;
3166 if (!CAN_WRITE(conn)) {
3167 characteristics |= FILE_READ_ONLY_DEVICE;
3170 SIVAL(pdata,0,FILE_DEVICE_DISK); /* dev type */
3171 SIVAL(pdata,4,characteristics);
3175 #ifdef HAVE_SYS_QUOTAS
3176 case SMB_FS_QUOTA_INFORMATION:
3178 * what we have to send --metze:
3180 * Unknown1: 24 NULL bytes
3181 * Soft Quota Treshold: 8 bytes seems like uint64_t or so
3182 * Hard Quota Limit: 8 bytes seems like uint64_t or so
3183 * Quota Flags: 2 byte :
3184 * Unknown3: 6 NULL bytes
3188 * details for Quota Flags:
3190 * 0x0020 Log Limit: log if the user exceeds his Hard Quota
3191 * 0x0010 Log Warn: log if the user exceeds his Soft Quota
3192 * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
3193 * 0x0001 Enable Quotas: enable quota for this fs
3197 /* we need to fake up a fsp here,
3198 * because its not send in this call
3201 SMB_NTQUOTA_STRUCT quotas;
3204 ZERO_STRUCT(quotas);
3210 if (get_current_uid(conn) != 0) {
3211 DEBUG(0,("set_user_quota: access_denied "
3212 "service [%s] user [%s]\n",
3213 lp_servicename(SNUM(conn)),
3214 conn->session_info->unix_info->unix_name));
3215 return NT_STATUS_ACCESS_DENIED;
3218 if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, "as)!=0) {
3219 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3220 return map_nt_error_from_unix(errno);
3225 DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",
3226 lp_servicename(SNUM(conn))));
3228 /* Unknown1 24 NULL bytes*/
3229 SBIG_UINT(pdata,0,(uint64_t)0);
3230 SBIG_UINT(pdata,8,(uint64_t)0);
3231 SBIG_UINT(pdata,16,(uint64_t)0);
3233 /* Default Soft Quota 8 bytes */
3234 SBIG_UINT(pdata,24,quotas.softlim);
3236 /* Default Hard Quota 8 bytes */
3237 SBIG_UINT(pdata,32,quotas.hardlim);
3239 /* Quota flag 2 bytes */
3240 SSVAL(pdata,40,quotas.qflags);
3242 /* Unknown3 6 NULL bytes */
3248 #endif /* HAVE_SYS_QUOTAS */
3249 case SMB_FS_OBJECTID_INFORMATION:
3251 unsigned char objid[16];
3252 struct smb_extended_info extended_info;
3253 memcpy(pdata,create_volume_objectid(conn, objid),16);
3254 samba_extended_info_version (&extended_info);
3255 SIVAL(pdata,16,extended_info.samba_magic);
3256 SIVAL(pdata,20,extended_info.samba_version);
3257 SIVAL(pdata,24,extended_info.samba_subversion);
3258 SBIG_UINT(pdata,28,extended_info.samba_gitcommitdate);
3259 memcpy(pdata+36,extended_info.samba_version_string,28);
3265 * Query the version and capabilities of the CIFS UNIX extensions
3269 case SMB_QUERY_CIFS_UNIX_INFO:
3271 bool large_write = lp_min_receive_file_size() &&
3272 !srv_is_signing_active(conn->sconn);
3273 bool large_read = !srv_is_signing_active(conn->sconn);
3274 int encrypt_caps = 0;
3276 if (!lp_unix_extensions()) {
3277 return NT_STATUS_INVALID_LEVEL;
3280 switch (conn->encrypt_level) {
3286 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP;
3289 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP|
3290 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP;
3291 large_write = false;
3297 SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
3298 SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
3300 /* We have POSIX ACLs, pathname, encryption,
3301 * large read/write, and locking capability. */
3303 SBIG_UINT(pdata,4,((uint64_t)(
3304 CIFS_UNIX_POSIX_ACLS_CAP|
3305 CIFS_UNIX_POSIX_PATHNAMES_CAP|
3306 CIFS_UNIX_FCNTL_LOCKS_CAP|
3307 CIFS_UNIX_EXTATTR_CAP|
3308 CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
3310 (large_read ? CIFS_UNIX_LARGE_READ_CAP : 0) |
3312 CIFS_UNIX_LARGE_WRITE_CAP : 0))));
3316 case SMB_QUERY_POSIX_FS_INFO:
3319 vfs_statvfs_struct svfs;
3321 if (!lp_unix_extensions()) {
3322 return NT_STATUS_INVALID_LEVEL;
3325 rc = SMB_VFS_STATVFS(conn, ".", &svfs);
3329 SIVAL(pdata,0,svfs.OptimalTransferSize);
3330 SIVAL(pdata,4,svfs.BlockSize);
3331 SBIG_UINT(pdata,8,svfs.TotalBlocks);
3332 SBIG_UINT(pdata,16,svfs.BlocksAvail);
3333 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
3334 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
3335 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
3336 SBIG_UINT(pdata,48,svfs.FsIdentifier);
3337 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
3339 } else if (rc == EOPNOTSUPP) {
3340 return NT_STATUS_INVALID_LEVEL;
3341 #endif /* EOPNOTSUPP */
3343 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3344 return NT_STATUS_DOS(ERRSRV, ERRerror);
3349 case SMB_QUERY_POSIX_WHOAMI:
3355 if (!lp_unix_extensions()) {
3356 return NT_STATUS_INVALID_LEVEL;
3359 if (max_data_bytes < 40) {
3360 return NT_STATUS_BUFFER_TOO_SMALL;
3363 /* We ARE guest if global_sid_Builtin_Guests is
3364 * in our list of SIDs.
3366 if (nt_token_check_sid(&global_sid_Builtin_Guests,
3367 conn->session_info->security_token)) {
3368 flags |= SMB_WHOAMI_GUEST;
3371 /* We are NOT guest if global_sid_Authenticated_Users
3372 * is in our list of SIDs.
3374 if (nt_token_check_sid(&global_sid_Authenticated_Users,
3375 conn->session_info->security_token)) {
3376 flags &= ~SMB_WHOAMI_GUEST;
3379 /* NOTE: 8 bytes for UID/GID, irrespective of native
3380 * platform size. This matches
3381 * SMB_QUERY_FILE_UNIX_BASIC and friends.
3383 data_len = 4 /* flags */
3390 + 4 /* pad/reserved */
3391 + (conn->session_info->unix_token->ngroups * 8)
3393 + (conn->session_info->security_token->num_sids *
3397 SIVAL(pdata, 0, flags);
3398 SIVAL(pdata, 4, SMB_WHOAMI_MASK);
3400 (uint64_t)conn->session_info->unix_token->uid);
3401 SBIG_UINT(pdata, 16,
3402 (uint64_t)conn->session_info->unix_token->gid);
3405 if (data_len >= max_data_bytes) {
3406 /* Potential overflow, skip the GIDs and SIDs. */
3408 SIVAL(pdata, 24, 0); /* num_groups */
3409 SIVAL(pdata, 28, 0); /* num_sids */
3410 SIVAL(pdata, 32, 0); /* num_sid_bytes */
3411 SIVAL(pdata, 36, 0); /* reserved */
3417 SIVAL(pdata, 24, conn->session_info->unix_token->ngroups);
3418 SIVAL(pdata, 28, conn->session_info->security_token->num_sids);
3420 /* We walk the SID list twice, but this call is fairly
3421 * infrequent, and I don't expect that it's performance
3422 * sensitive -- jpeach
3424 for (i = 0, sid_bytes = 0;
3425 i < conn->session_info->security_token->num_sids; ++i) {
3426 sid_bytes += ndr_size_dom_sid(
3427 &conn->session_info->security_token->sids[i],
3431 /* SID list byte count */
3432 SIVAL(pdata, 32, sid_bytes);
3434 /* 4 bytes pad/reserved - must be zero */
3435 SIVAL(pdata, 36, 0);
3439 for (i = 0; i < conn->session_info->unix_token->ngroups; ++i) {
3440 SBIG_UINT(pdata, data_len,
3441 (uint64_t)conn->session_info->unix_token->groups[i]);
3447 i < conn->session_info->security_token->num_sids; ++i) {
3448 int sid_len = ndr_size_dom_sid(
3449 &conn->session_info->security_token->sids[i],
3452 sid_linearize(pdata + data_len, sid_len,
3453 &conn->session_info->security_token->sids[i]);
3454 data_len += sid_len;
3460 case SMB_MAC_QUERY_FS_INFO:
3462 * Thursby MAC extension... ONLY on NTFS filesystems
3463 * once we do streams then we don't need this
3465 if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
3467 SIVAL(pdata,84,0x100); /* Don't support mac... */
3472 return NT_STATUS_INVALID_LEVEL;
3475 *ret_data_len = data_len;
3476 return NT_STATUS_OK;
3479 /****************************************************************************
3480 Reply to a TRANS2_QFSINFO (query filesystem info).
3481 ****************************************************************************/
3483 static void call_trans2qfsinfo(connection_struct *conn,
3484 struct smb_request *req,
3485 char **pparams, int total_params,
3486 char **ppdata, int total_data,
3487 unsigned int max_data_bytes)
3489 char *params = *pparams;
3490 uint16_t info_level;
3494 if (total_params < 2) {
3495 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3499 info_level = SVAL(params,0);
3501 if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3502 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
3503 DEBUG(0,("call_trans2qfsinfo: encryption required "
3504 "and info level 0x%x sent.\n",
3505 (unsigned int)info_level));
3506 exit_server_cleanly("encryption required "
3512 DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
3514 status = smbd_do_qfsinfo(conn, req,
3519 if (!NT_STATUS_IS_OK(status)) {
3520 reply_nterror(req, status);
3524 send_trans2_replies(conn, req, params, 0, *ppdata, data_len,
3527 DEBUG( 4, ( "%s info_level = %d\n",
3528 smb_fn_name(req->cmd), info_level) );
3533 /****************************************************************************
3534 Reply to a TRANS2_SETFSINFO (set filesystem info).
3535 ****************************************************************************/
3537 static void call_trans2setfsinfo(connection_struct *conn,
3538 struct smb_request *req,
3539 char **pparams, int total_params,
3540 char **ppdata, int total_data,
3541 unsigned int max_data_bytes)
3543 struct smbd_server_connection *sconn = req->sconn;
3544 char *pdata = *ppdata;
3545 char *params = *pparams;
3548 DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn))));
3551 if (total_params < 4) {
3552 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
3554 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3558 info_level = SVAL(params,2);
3561 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION &&
3562 info_level != SMB_SET_CIFS_UNIX_INFO) {
3563 DEBUG(0,("call_trans2setfsinfo: not an allowed "
3564 "info level (0x%x) on IPC$.\n",
3565 (unsigned int)info_level));
3566 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
3571 if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3572 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION) {
3573 DEBUG(0,("call_trans2setfsinfo: encryption required "
3574 "and info level 0x%x sent.\n",
3575 (unsigned int)info_level));
3576 exit_server_cleanly("encryption required "
3582 switch(info_level) {
3583 case SMB_SET_CIFS_UNIX_INFO:
3584 if (!lp_unix_extensions()) {
3586 NT_STATUS_INVALID_LEVEL);
3590 /* There should be 12 bytes of capabilities set. */
3591 if (total_data < 8) {
3594 NT_STATUS_INVALID_PARAMETER);
3597 sconn->smb1.unix_info.client_major = SVAL(pdata,0);
3598 sconn->smb1.unix_info.client_minor = SVAL(pdata,2);
3599 sconn->smb1.unix_info.client_cap_low = IVAL(pdata,4);
3600 sconn->smb1.unix_info.client_cap_high = IVAL(pdata,8);
3601 /* Just print these values for now. */
3602 DEBUG(10, ("call_trans2setfsinfo: set unix_info info. "
3603 "major = %u, minor = %u cap_low = 0x%x, "
3605 (unsigned int)sconn->
3606 smb1.unix_info.client_major,
3607 (unsigned int)sconn->
3608 smb1.unix_info.client_minor,
3609 (unsigned int)sconn->
3610 smb1.unix_info.client_cap_low,
3611 (unsigned int)sconn->
3612 smb1.unix_info.client_cap_high));
3614 /* Here is where we must switch to posix pathname processing... */
3615 if (sconn->smb1.unix_info.client_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3616 lp_set_posix_pathnames();
3617 mangle_change_to_posix();
3620 if ((sconn->smb1.unix_info.client_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
3621 !(sconn->smb1.unix_info.client_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
3622 /* Client that knows how to do posix locks,
3623 * but not posix open/mkdir operations. Set a
3624 * default type for read/write checks. */
3626 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
3631 case SMB_REQUEST_TRANSPORT_ENCRYPTION:
3634 size_t param_len = 0;
3635 size_t data_len = total_data;
3637 if (!lp_unix_extensions()) {
3640 NT_STATUS_INVALID_LEVEL);
3644 if (lp_smb_encrypt(SNUM(conn)) == false) {
3647 NT_STATUS_NOT_SUPPORTED);
3651 if (req->sconn->smb1.echo_handler.trusted_fde) {
3652 DEBUG( 2,("call_trans2setfsinfo: "
3653 "request transport encryption disabled"
3654 "with 'fork echo handler = yes'\n"));
3657 NT_STATUS_NOT_SUPPORTED);
3661 DEBUG( 4,("call_trans2setfsinfo: "
3662 "request transport encryption.\n"));
3664 status = srv_request_encryption_setup(conn,
3665 (unsigned char **)ppdata,
3667 (unsigned char **)pparams,
3670 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
3671 !NT_STATUS_IS_OK(status)) {
3672 reply_nterror(req, status);
3676 send_trans2_replies(conn, req,
3683 if (NT_STATUS_IS_OK(status)) {
3684 /* Server-side transport
3685 * encryption is now *on*. */
3686 status = srv_encryption_start(conn);
3687 if (!NT_STATUS_IS_OK(status)) {
3688 char *reason = talloc_asprintf(talloc_tos(),
3689 "Failure in setting "
3690 "up encrypted transport: %s",
3692 exit_server_cleanly(reason);
3698 case SMB_FS_QUOTA_INFORMATION:
3700 files_struct *fsp = NULL;
3701 SMB_NTQUOTA_STRUCT quotas;
3703 ZERO_STRUCT(quotas);
3706 if ((get_current_uid(conn) != 0) || !CAN_WRITE(conn)) {
3707 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
3708 lp_servicename(SNUM(conn)),
3709 conn->session_info->unix_info->unix_name));
3710 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
3714 /* note: normaly there're 48 bytes,
3715 * but we didn't use the last 6 bytes for now
3718 fsp = file_fsp(req, SVAL(params,0));
3720 if (!check_fsp_ntquota_handle(conn, req,
3722 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
3724 req, NT_STATUS_INVALID_HANDLE);
3728 if (total_data < 42) {
3729 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
3733 NT_STATUS_INVALID_PARAMETER);
3737 /* unknown_1 24 NULL bytes in pdata*/
3739 /* the soft quotas 8 bytes (uint64_t)*/
3740 quotas.softlim = BVAL(pdata,24);
3742 /* the hard quotas 8 bytes (uint64_t)*/
3743 quotas.hardlim = BVAL(pdata,32);
3745 /* quota_flags 2 bytes **/
3746 quotas.qflags = SVAL(pdata,40);
3748 /* unknown_2 6 NULL bytes follow*/
3750 /* now set the quotas */
3751 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, "as)!=0) {
3752 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3753 reply_nterror(req, map_nt_error_from_unix(errno));
3760 DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
3762 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3768 * sending this reply works fine,
3769 * but I'm not sure it's the same
3770 * like windows do...
3773 reply_outbuf(req, 10, 0);
3776 #if defined(HAVE_POSIX_ACLS)
3777 /****************************************************************************
3778 Utility function to count the number of entries in a POSIX acl.
3779 ****************************************************************************/
3781 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
3783 unsigned int ace_count = 0;
3784 int entry_id = SMB_ACL_FIRST_ENTRY;
3785 SMB_ACL_ENTRY_T entry;
3787 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3789 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3790 entry_id = SMB_ACL_NEXT_ENTRY;
3797 /****************************************************************************
3798 Utility function to marshall a POSIX acl into wire format.
3799 ****************************************************************************/
3801 static bool marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
3803 int entry_id = SMB_ACL_FIRST_ENTRY;
3804 SMB_ACL_ENTRY_T entry;
3806 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3807 SMB_ACL_TAG_T tagtype;
3808 SMB_ACL_PERMSET_T permset;
3809 unsigned char perms = 0;
3810 unsigned int own_grp;
3813 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3814 entry_id = SMB_ACL_NEXT_ENTRY;
3817 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
3818 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
3822 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
3823 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
3827 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
3828 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
3829 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
3831 SCVAL(pdata,1,perms);
3834 case SMB_ACL_USER_OBJ:
3835 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
3836 own_grp = (unsigned int)pst->st_ex_uid;
3837 SIVAL(pdata,2,own_grp);
3842 uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3844 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3847 own_grp = (unsigned int)*puid;
3848 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
3849 SCVAL(pdata,0,SMB_POSIX_ACL_USER);
3850 SIVAL(pdata,2,own_grp);
3854 case SMB_ACL_GROUP_OBJ:
3855 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
3856 own_grp = (unsigned int)pst->st_ex_gid;
3857 SIVAL(pdata,2,own_grp);
3862 gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3864 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3867 own_grp = (unsigned int)*pgid;
3868 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
3869 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
3870 SIVAL(pdata,2,own_grp);
3875 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
3876 SIVAL(pdata,2,0xFFFFFFFF);
3877 SIVAL(pdata,6,0xFFFFFFFF);
3880 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
3881 SIVAL(pdata,2,0xFFFFFFFF);
3882 SIVAL(pdata,6,0xFFFFFFFF);
3885 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
3888 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
3895 /****************************************************************************
3896 Store the FILE_UNIX_BASIC info.
3897 ****************************************************************************/
3899 static char *store_file_unix_basic(connection_struct *conn,
3902 const SMB_STRUCT_STAT *psbuf)
3904 uint64_t file_index = get_FileIndex(conn, psbuf);
3906 DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
3907 DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf->st_ex_mode));
3909 SOFF_T(pdata,0,get_file_size_stat(psbuf)); /* File size 64 Bit */
3912 SOFF_T(pdata,0,SMB_VFS_GET_ALLOC_SIZE(conn,fsp,psbuf)); /* Number of bytes used on disk - 64 Bit */
3915 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata, psbuf->st_ex_ctime); /* Change Time 64 Bit */
3916 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER ,pdata+8, psbuf->st_ex_atime); /* Last access time 64 Bit */
3917 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, pdata+16, psbuf->st_ex_mtime); /* Last modification time 64 Bit */
3920 SIVAL(pdata,0,psbuf->st_ex_uid); /* user id for the owner */
3924 SIVAL(pdata,0,psbuf->st_ex_gid); /* group id of owner */
3928 SIVAL(pdata,0,unix_filetype(psbuf->st_ex_mode));
3931 SIVAL(pdata,0,unix_dev_major(psbuf->st_ex_rdev)); /* Major device number if type is device */
3935 SIVAL(pdata,0,unix_dev_minor(psbuf->st_ex_rdev)); /* Minor device number if type is device */
3939 SINO_T_VAL(pdata,0,(SMB_INO_T)file_index); /* inode number */
3942 SIVAL(pdata,0, unix_perms_to_wire(psbuf->st_ex_mode)); /* Standard UNIX file permissions */
3946 SIVAL(pdata,0,psbuf->st_ex_nlink); /* number of hard links */
3953 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
3954 * the chflags(2) (or equivalent) flags.
3956 * XXX: this really should be behind the VFS interface. To do this, we would
3957 * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
3958 * Each VFS module could then implement its own mapping as appropriate for the
3959 * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
3961 static const struct {unsigned stat_fflag; unsigned smb_fflag;}
3965 { UF_NODUMP, EXT_DO_NOT_BACKUP },
3969 { UF_IMMUTABLE, EXT_IMMUTABLE },
3973 { UF_APPEND, EXT_OPEN_APPEND_ONLY },
3977 { UF_HIDDEN, EXT_HIDDEN },
3980 /* Do not remove. We need to guarantee that this array has at least one
3981 * entry to build on HP-UX.
3987 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT *psbuf,
3988 uint32 *smb_fflags, uint32 *smb_fmask)
3992 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
3993 *smb_fmask |= info2_flags_map[i].smb_fflag;
3994 if (psbuf->st_ex_flags & info2_flags_map[i].stat_fflag) {
3995 *smb_fflags |= info2_flags_map[i].smb_fflag;
4000 static bool map_info2_flags_to_sbuf(const SMB_STRUCT_STAT *psbuf,
4001 const uint32 smb_fflags,
4002 const uint32 smb_fmask,
4005 uint32 max_fmask = 0;
4008 *stat_fflags = psbuf->st_ex_flags;
4010 /* For each flags requested in smb_fmask, check the state of the
4011 * corresponding flag in smb_fflags and set or clear the matching
4015 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
4016 max_fmask |= info2_flags_map[i].smb_fflag;
4017 if (smb_fmask & info2_flags_map[i].smb_fflag) {
4018 if (smb_fflags & info2_flags_map[i].smb_fflag) {
4019 *stat_fflags |= info2_flags_map[i].stat_fflag;
4021 *stat_fflags &= ~info2_flags_map[i].stat_fflag;
4026 /* If smb_fmask is asking to set any bits that are not supported by
4027 * our flag mappings, we should fail.
4029 if ((smb_fmask & max_fmask) != smb_fmask) {
4037 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
4038 * of file flags and birth (create) time.
4040 static char *store_file_unix_basic_info2(connection_struct *conn,
4043 const SMB_STRUCT_STAT *psbuf)
4045 uint32 file_flags = 0;
4046 uint32 flags_mask = 0;
4048 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
4050 /* Create (birth) time 64 bit */
4051 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER,pdata, psbuf->st_ex_btime);
4054 map_info2_flags_from_sbuf(psbuf, &file_flags, &flags_mask);
4055 SIVAL(pdata, 0, file_flags); /* flags */
4056 SIVAL(pdata, 4, flags_mask); /* mask */
4062 static NTSTATUS marshall_stream_info(unsigned int num_streams,
4063 const struct stream_struct *streams,
4065 unsigned int max_data_bytes,
4066 unsigned int *data_size)
4069 unsigned int ofs = 0;
4071 for (i = 0; i < num_streams && ofs <= max_data_bytes; i++) {
4072 unsigned int next_offset;
4074 smb_ucs2_t *namebuf;
4076 if (!push_ucs2_talloc(talloc_tos(), &namebuf,
4077 streams[i].name, &namelen) ||
4080 return NT_STATUS_INVALID_PARAMETER;
4084 * name_buf is now null-terminated, we need to marshall as not
4090 SIVAL(data, ofs+4, namelen);
4091 SOFF_T(data, ofs+8, streams[i].size);
4092 SOFF_T(data, ofs+16, streams[i].alloc_size);
4093 memcpy(data+ofs+24, namebuf, namelen);
4094 TALLOC_FREE(namebuf);
4096 next_offset = ofs + 24 + namelen;
4098 if (i == num_streams-1) {
4099 SIVAL(data, ofs, 0);
4102 unsigned int align = ndr_align_size(next_offset, 8);
4104 memset(data+next_offset, 0, align);
4105 next_offset += align;
4107 SIVAL(data, ofs, next_offset - ofs);
4116 return NT_STATUS_OK;
4119 /****************************************************************************
4120 Reply to a TRANSACT2_QFILEINFO on a PIPE !
4121 ****************************************************************************/
4123 static void call_trans2qpipeinfo(connection_struct *conn,
4124 struct smb_request *req,
4125 unsigned int tran_call,
4126 char **pparams, int total_params,
4127 char **ppdata, int total_data,
4128 unsigned int max_data_bytes)
4130 char *params = *pparams;
4131 char *pdata = *ppdata;
4132 unsigned int data_size = 0;
4133 unsigned int param_size = 2;
4138 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4142 if (total_params < 4) {
4143 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4147 fsp = file_fsp(req, SVAL(params,0));
4148 if (!fsp_is_np(fsp)) {
4149 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
4153 info_level = SVAL(params,2);
4155 *pparams = (char *)SMB_REALLOC(*pparams,2);
4156 if (*pparams == NULL) {
4157 reply_nterror(req, NT_STATUS_NO_MEMORY);
4162 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4163 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4164 if (*ppdata == NULL ) {
4165 reply_nterror(req, NT_STATUS_NO_MEMORY);
4170 switch (info_level) {
4171 case SMB_FILE_STANDARD_INFORMATION:
4173 SOFF_T(pdata,0,4096LL);
4180 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4184 send_trans2_replies(conn, req, params, param_size, *ppdata, data_size,
4190 NTSTATUS smbd_do_qfilepathinfo(connection_struct *conn,
4191 TALLOC_CTX *mem_ctx,
4192 uint16_t info_level,
4194 struct smb_filename *smb_fname,
4195 bool delete_pending,
4196 struct timespec write_time_ts,
4197 struct ea_list *ea_list,
4198 int lock_data_count,
4201 unsigned int max_data_bytes,
4203 unsigned int *pdata_size)
4205 char *pdata = *ppdata;
4206 char *dstart, *dend;
4207 unsigned int data_size;
4208 struct timespec create_time_ts, mtime_ts, atime_ts, ctime_ts;
4209 time_t create_time, mtime, atime, c_time;
4210 SMB_STRUCT_STAT *psbuf = &smb_fname->st;
4217 uint64_t file_size = 0;
4219 uint64_t allocation_size = 0;
4220 uint64_t file_index = 0;
4221 uint32_t access_mask = 0;
4223 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
4224 return NT_STATUS_INVALID_LEVEL;
4227 DEBUG(5,("smbd_do_qfilepathinfo: %s (fnum = %d) level=%d max_data=%u\n",
4228 smb_fname_str_dbg(smb_fname), fsp ? fsp->fnum : -1,
4229 info_level, max_data_bytes));
4231 mode = dos_mode(conn, smb_fname);
4232 nlink = psbuf->st_ex_nlink;
4234 if (nlink && (mode&FILE_ATTRIBUTE_DIRECTORY)) {
4238 if ((nlink > 0) && delete_pending) {
4242 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4243 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4244 if (*ppdata == NULL) {
4245 return NT_STATUS_NO_MEMORY;
4249 dend = dstart + data_size - 1;
4251 if (!null_timespec(write_time_ts) && !INFO_LEVEL_IS_UNIX(info_level)) {
4252 update_stat_ex_mtime(psbuf, write_time_ts);
4255 create_time_ts = get_create_timespec(conn, fsp, smb_fname);
4256 mtime_ts = psbuf->st_ex_mtime;
4257 atime_ts = psbuf->st_ex_atime;
4258 ctime_ts = get_change_timespec(conn, fsp, smb_fname);
4260 if (lp_dos_filetime_resolution(SNUM(conn))) {
4261 dos_filetime_timespec(&create_time_ts);
4262 dos_filetime_timespec(&mtime_ts);
4263 dos_filetime_timespec(&atime_ts);
4264 dos_filetime_timespec(&ctime_ts);
4267 create_time = convert_timespec_to_time_t(create_time_ts);
4268 mtime = convert_timespec_to_time_t(mtime_ts);
4269 atime = convert_timespec_to_time_t(atime_ts);
4270 c_time = convert_timespec_to_time_t(ctime_ts);
4272 p = strrchr_m(smb_fname->base_name,'/');
4274 base_name = smb_fname->base_name;
4278 /* NT expects the name to be in an exact form of the *full*
4279 filename. See the trans2 torture test */
4280 if (ISDOT(base_name)) {
4281 dos_fname = talloc_strdup(mem_ctx, "\\");
4283 return NT_STATUS_NO_MEMORY;
4286 dos_fname = talloc_asprintf(mem_ctx,
4288 smb_fname->base_name);
4290 return NT_STATUS_NO_MEMORY;
4292 if (is_ntfs_stream_smb_fname(smb_fname)) {
4293 dos_fname = talloc_asprintf(dos_fname, "%s",
4294 smb_fname->stream_name);
4296 return NT_STATUS_NO_MEMORY;
4300 string_replace(dos_fname, '/', '\\');
4303 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp, psbuf);
4306 /* Do we have this path open ? */
4308 struct file_id fileid = vfs_file_id_from_sbuf(conn, psbuf);
4309 fsp1 = file_find_di_first(conn->sconn, fileid);
4310 if (fsp1 && fsp1->initial_allocation_size) {
4311 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp1, psbuf);
4315 if (!(mode & FILE_ATTRIBUTE_DIRECTORY)) {
4316 file_size = get_file_size_stat(psbuf);
4320 pos = fsp->fh->position_information;
4324 access_mask = fsp->access_mask;
4326 /* GENERIC_EXECUTE mapping from Windows */
4327 access_mask = 0x12019F;
4330 /* This should be an index number - looks like
4333 I think this causes us to fail the IFSKIT
4334 BasicFileInformationTest. -tpot */
4335 file_index = get_FileIndex(conn, psbuf);
4337 switch (info_level) {
4338 case SMB_INFO_STANDARD:
4339 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_STANDARD\n"));
4341 srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
4342 srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
4343 srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
4344 SIVAL(pdata,l1_cbFile,(uint32)file_size);
4345 SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
4346 SSVAL(pdata,l1_attrFile,mode);
4349 case SMB_INFO_QUERY_EA_SIZE:
4351 unsigned int ea_size =
4352 estimate_ea_size(conn, fsp,
4353 smb_fname->base_name);
4354 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
4356 srv_put_dos_date2(pdata,0,create_time);
4357 srv_put_dos_date2(pdata,4,atime);
4358 srv_put_dos_date2(pdata,8,mtime); /* write time */
4359 SIVAL(pdata,12,(uint32)file_size);
4360 SIVAL(pdata,16,(uint32)allocation_size);
4361 SSVAL(pdata,20,mode);
4362 SIVAL(pdata,22,ea_size);
4366 case SMB_INFO_IS_NAME_VALID:
4367 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
4369 /* os/2 needs this ? really ?*/
4370 return NT_STATUS_DOS(ERRDOS, ERRbadfunc);
4372 /* This is only reached for qpathinfo */
4376 case SMB_INFO_QUERY_EAS_FROM_LIST:
4378 size_t total_ea_len = 0;
4379 struct ea_list *ea_file_list = NULL;
4381 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
4384 get_ea_list_from_file(mem_ctx, conn, fsp,
4385 smb_fname->base_name,
4387 ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
4389 if (!ea_list || (total_ea_len > data_size)) {
4391 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
4395 data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
4399 case SMB_INFO_QUERY_ALL_EAS:
4401 /* We have data_size bytes to put EA's into. */
4402 size_t total_ea_len = 0;
4404 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
4406 ea_list = get_ea_list_from_file(mem_ctx, conn, fsp,
4407 smb_fname->base_name,
4409 if (!ea_list || (total_ea_len > data_size)) {
4411 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
4415 data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
4419 case 0xFF0F:/*SMB2_INFO_QUERY_ALL_EAS*/
4421 /* This is FileFullEaInformation - 0xF which maps to
4422 * 1015 (decimal) in smbd_do_setfilepathinfo. */
4424 /* We have data_size bytes to put EA's into. */
4425 size_t total_ea_len = 0;
4426 struct ea_list *ea_file_list = NULL;
4428 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_INFO_QUERY_ALL_EAS\n"));
4430 /*TODO: add filtering and index handling */
4433 get_ea_list_from_file(mem_ctx, conn, fsp,
4434 smb_fname->base_name,
4436 if (!ea_file_list) {
4437 return NT_STATUS_NO_EAS_ON_FILE;
4440 status = fill_ea_chained_buffer(mem_ctx,
4444 conn, ea_file_list);
4445 if (!NT_STATUS_IS_OK(status)) {
4451 case SMB_FILE_BASIC_INFORMATION:
4452 case SMB_QUERY_FILE_BASIC_INFO:
4454 if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
4455 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
4456 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
4458 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
4462 put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
4463 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4464 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4465 put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
4466 SIVAL(pdata,32,mode);
4468 DEBUG(5,("SMB_QFBI - "));
4469 DEBUG(5,("create: %s ", ctime(&create_time)));
4470 DEBUG(5,("access: %s ", ctime(&atime)));
4471 DEBUG(5,("write: %s ", ctime(&mtime)));
4472 DEBUG(5,("change: %s ", ctime(&c_time)));
4473 DEBUG(5,("mode: %x\n", mode));
4476 case SMB_FILE_STANDARD_INFORMATION:
4477 case SMB_QUERY_FILE_STANDARD_INFO:
4479 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
4481 SOFF_T(pdata,0,allocation_size);
4482 SOFF_T(pdata,8,file_size);
4483 SIVAL(pdata,16,nlink);
4484 SCVAL(pdata,20,delete_pending?1:0);
4485 SCVAL(pdata,21,(mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
4486 SSVAL(pdata,22,0); /* Padding. */
4489 case SMB_FILE_EA_INFORMATION:
4490 case SMB_QUERY_FILE_EA_INFO:
4492 unsigned int ea_size =
4493 estimate_ea_size(conn, fsp, smb_fname->base_name);
4494 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
4496 SIVAL(pdata,0,ea_size);
4500 /* Get the 8.3 name - used if NT SMB was negotiated. */
4501 case SMB_QUERY_FILE_ALT_NAME_INFO:
4502 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
4505 char mangled_name[13];
4506 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
4507 if (!name_to_8_3(base_name,mangled_name,
4508 True,conn->params)) {
4509 return NT_STATUS_NO_MEMORY;
4511 len = srvstr_push(dstart, flags2,
4512 pdata+4, mangled_name,
4513 PTR_DIFF(dend, pdata+4),
4515 data_size = 4 + len;
4520 case SMB_QUERY_FILE_NAME_INFO:
4524 this must be *exactly* right for ACLs on mapped drives to work
4526 len = srvstr_push(dstart, flags2,
4528 PTR_DIFF(dend, pdata+4),
4530 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
4531 data_size = 4 + len;
4536 case SMB_FILE_ALLOCATION_INFORMATION:
4537 case SMB_QUERY_FILE_ALLOCATION_INFO:
4538 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
4540 SOFF_T(pdata,0,allocation_size);
4543 case SMB_FILE_END_OF_FILE_INFORMATION:
4544 case SMB_QUERY_FILE_END_OF_FILEINFO:
4545 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
4547 SOFF_T(pdata,0,file_size);
4550 case SMB_QUERY_FILE_ALL_INFO:
4551 case SMB_FILE_ALL_INFORMATION:
4554 unsigned int ea_size =
4555 estimate_ea_size(conn, fsp, smb_fname->base_name);
4556 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
4557 put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
4558 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4559 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4560 put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
4561 SIVAL(pdata,32,mode);
4562 SIVAL(pdata,36,0); /* padding. */
4564 SOFF_T(pdata,0,allocation_size);
4565 SOFF_T(pdata,8,file_size);
4566 SIVAL(pdata,16,nlink);
4567 SCVAL(pdata,20,delete_pending);
4568 SCVAL(pdata,21,(mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
4571 SIVAL(pdata,0,ea_size);
4572 pdata += 4; /* EA info */
4573 len = srvstr_push(dstart, flags2,
4575 PTR_DIFF(dend, pdata+4),
4579 data_size = PTR_DIFF(pdata,(*ppdata));
4583 case 0xFF12:/*SMB2_FILE_ALL_INFORMATION*/
4586 unsigned int ea_size =
4587 estimate_ea_size(conn, fsp, smb_fname->base_name);
4588 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_FILE_ALL_INFORMATION\n"));
4589 put_long_date_timespec(conn->ts_res,pdata+0x00,create_time_ts);
4590 put_long_date_timespec(conn->ts_res,pdata+0x08,atime_ts);
4591 put_long_date_timespec(conn->ts_res,pdata+0x10,mtime_ts); /* write time */
4592 put_long_date_timespec(conn->ts_res,pdata+0x18,ctime_ts); /* change time */
4593 SIVAL(pdata, 0x20, mode);
4594 SIVAL(pdata, 0x24, 0); /* padding. */
4595 SBVAL(pdata, 0x28, allocation_size);
4596 SBVAL(pdata, 0x30, file_size);
4597 SIVAL(pdata, 0x38, nlink);
4598 SCVAL(pdata, 0x3C, delete_pending);
4599 SCVAL(pdata, 0x3D, (mode&FILE_ATTRIBUTE_DIRECTORY)?1:0);
4600 SSVAL(pdata, 0x3E, 0); /* padding */
4601 SBVAL(pdata, 0x40, file_index);
4602 SIVAL(pdata, 0x48, ea_size);
4603 SIVAL(pdata, 0x4C, access_mask);
4604 SBVAL(pdata, 0x50, pos);
4605 SIVAL(pdata, 0x58, mode); /*TODO: mode != mode fix this!!! */
4606 SIVAL(pdata, 0x5C, 0); /* No alignment needed. */
4610 len = srvstr_push(dstart, flags2,
4612 PTR_DIFF(dend, pdata+4),
4616 data_size = PTR_DIFF(pdata,(*ppdata));
4619 case SMB_FILE_INTERNAL_INFORMATION:
4621 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
4622 SBVAL(pdata, 0, file_index);
4626 case SMB_FILE_ACCESS_INFORMATION:
4627 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
4628 SIVAL(pdata, 0, access_mask);
4632 case SMB_FILE_NAME_INFORMATION:
4633 /* Pathname with leading '\'. */
4636 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
4637 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
4638 SIVAL(pdata,0,byte_len);
4639 data_size = 4 + byte_len;
4643 case SMB_FILE_DISPOSITION_INFORMATION:
4644 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
4646 SCVAL(pdata,0,delete_pending);
4649 case SMB_FILE_POSITION_INFORMATION:
4650 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
4652 SOFF_T(pdata,0,pos);
4655 case SMB_FILE_MODE_INFORMATION:
4656 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
4657 SIVAL(pdata,0,mode);
4661 case SMB_FILE_ALIGNMENT_INFORMATION:
4662 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
4663 SIVAL(pdata,0,0); /* No alignment needed. */
4668 * NT4 server just returns "invalid query" to this - if we try
4669 * to answer it then NTws gets a BSOD! (tridge). W2K seems to
4672 /* The first statement above is false - verified using Thursby
4673 * client against NT4 -- gcolley.
4675 case SMB_QUERY_FILE_STREAM_INFO:
4676 case SMB_FILE_STREAM_INFORMATION: {
4677 unsigned int num_streams = 0;
4678 struct stream_struct *streams = NULL;
4680 DEBUG(10,("smbd_do_qfilepathinfo: "
4681 "SMB_FILE_STREAM_INFORMATION\n"));
4683 if (is_ntfs_stream_smb_fname(smb_fname)) {
4684 return NT_STATUS_INVALID_PARAMETER;
4687 status = vfs_streaminfo(conn, fsp, smb_fname->base_name,
4688 talloc_tos(), &num_streams, &streams);
4690 if (!NT_STATUS_IS_OK(status)) {
4691 DEBUG(10, ("could not get stream info: %s\n",
4692 nt_errstr(status)));
4696 status = marshall_stream_info(num_streams, streams,
4697 pdata, max_data_bytes,
4700 if (!NT_STATUS_IS_OK(status)) {
4701 DEBUG(10, ("marshall_stream_info failed: %s\n",
4702 nt_errstr(status)));
4706 TALLOC_FREE(streams);
4710 case SMB_QUERY_COMPRESSION_INFO:
4711 case SMB_FILE_COMPRESSION_INFORMATION:
4712 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
4713 SOFF_T(pdata,0,file_size);
4714 SIVAL(pdata,8,0); /* ??? */
4715 SIVAL(pdata,12,0); /* ??? */
4719 case SMB_FILE_NETWORK_OPEN_INFORMATION:
4720 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
4721 put_long_date_timespec(conn->ts_res,pdata,create_time_ts);
4722 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4723 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4724 put_long_date_timespec(conn->ts_res,pdata+24,ctime_ts); /* change time */
4725 SOFF_T(pdata,32,allocation_size);
4726 SOFF_T(pdata,40,file_size);
4727 SIVAL(pdata,48,mode);
4728 SIVAL(pdata,52,0); /* ??? */
4732 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
4733 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
4734 SIVAL(pdata,0,mode);
4740 * CIFS UNIX Extensions.
4743 case SMB_QUERY_FILE_UNIX_BASIC:
4745 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
4746 data_size = PTR_DIFF(pdata,(*ppdata));
4748 DEBUG(4,("smbd_do_qfilepathinfo: "
4749 "SMB_QUERY_FILE_UNIX_BASIC\n"));
4750 dump_data(4, (uint8_t *)(*ppdata), data_size);
4754 case SMB_QUERY_FILE_UNIX_INFO2:
4756 pdata = store_file_unix_basic_info2(conn, pdata, fsp, psbuf);
4757 data_size = PTR_DIFF(pdata,(*ppdata));
4761 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
4763 for (i=0; i<100; i++)
4764 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
4770 case SMB_QUERY_FILE_UNIX_LINK:
4773 char *buffer = talloc_array(mem_ctx, char, PATH_MAX+1);
4776 return NT_STATUS_NO_MEMORY;
4779 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
4781 if(!S_ISLNK(psbuf->st_ex_mode)) {
4782 return NT_STATUS_DOS(ERRSRV, ERRbadlink);
4785 return NT_STATUS_DOS(ERRDOS, ERRbadlink);
4787 len = SMB_VFS_READLINK(conn,
4788 smb_fname->base_name,
4791 return map_nt_error_from_unix(errno);
4794 len = srvstr_push(dstart, flags2,
4796 PTR_DIFF(dend, pdata),
4799 data_size = PTR_DIFF(pdata,(*ppdata));
4804 #if defined(HAVE_POSIX_ACLS)
4805 case SMB_QUERY_POSIX_ACL:
4807 SMB_ACL_T file_acl = NULL;
4808 SMB_ACL_T def_acl = NULL;
4809 uint16 num_file_acls = 0;
4810 uint16 num_def_acls = 0;
4812 if (fsp && fsp->fh->fd != -1) {
4813 file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp);
4816 SMB_VFS_SYS_ACL_GET_FILE(conn,
4817 smb_fname->base_name,
4818 SMB_ACL_TYPE_ACCESS);
4821 if (file_acl == NULL && no_acl_syscall_error(errno)) {
4822 DEBUG(5,("smbd_do_qfilepathinfo: ACLs "
4823 "not implemented on "
4824 "filesystem containing %s\n",
4825 smb_fname->base_name));
4826 return NT_STATUS_NOT_IMPLEMENTED;
4829 if (S_ISDIR(psbuf->st_ex_mode)) {
4830 if (fsp && fsp->is_directory) {
4832 SMB_VFS_SYS_ACL_GET_FILE(
4834 fsp->fsp_name->base_name,
4835 SMB_ACL_TYPE_DEFAULT);
4838 SMB_VFS_SYS_ACL_GET_FILE(
4840 smb_fname->base_name,
4841 SMB_ACL_TYPE_DEFAULT);
4843 def_acl = free_empty_sys_acl(conn, def_acl);
4846 num_file_acls = count_acl_entries(conn, file_acl);
4847 num_def_acls = count_acl_entries(conn, def_acl);
4849 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
4850 DEBUG(5,("smbd_do_qfilepathinfo: data_size too small (%u) need %u\n",
4852 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
4853 SMB_POSIX_ACL_HEADER_SIZE) ));
4855 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4858 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4860 return NT_STATUS_BUFFER_TOO_SMALL;
4863 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
4864 SSVAL(pdata,2,num_file_acls);
4865 SSVAL(pdata,4,num_def_acls);
4866 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, psbuf, file_acl)) {
4868 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4871 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4873 return NT_STATUS_INTERNAL_ERROR;
4875 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), psbuf, def_acl)) {
4877 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4880 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4882 return NT_STATUS_INTERNAL_ERROR;
4886 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4889 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4891 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
4897 case SMB_QUERY_POSIX_LOCK:
4902 enum brl_type lock_type;
4904 /* We need an open file with a real fd for this. */
4905 if (!fsp || fsp->fh->fd == -1) {
4906 return NT_STATUS_INVALID_LEVEL;
4909 if (lock_data_count != POSIX_LOCK_DATA_SIZE) {
4910 return NT_STATUS_INVALID_PARAMETER;
4913 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4914 case POSIX_LOCK_TYPE_READ:
4915 lock_type = READ_LOCK;
4917 case POSIX_LOCK_TYPE_WRITE:
4918 lock_type = WRITE_LOCK;
4920 case POSIX_LOCK_TYPE_UNLOCK:
4922 /* There's no point in asking for an unlock... */
4923 return NT_STATUS_INVALID_PARAMETER;
4926 smblctx = (uint64_t)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4927 #if defined(HAVE_LONGLONG)
4928 offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4929 ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4930 count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4931 ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4932 #else /* HAVE_LONGLONG */
4933 offset = (uint64_t)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4934 count = (uint64_t)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4935 #endif /* HAVE_LONGLONG */
4937 status = query_lock(fsp,
4944 if (ERROR_WAS_LOCK_DENIED(status)) {
4945 /* Here we need to report who has it locked... */
4946 data_size = POSIX_LOCK_DATA_SIZE;
4948 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
4949 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
4950 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, (uint32_t)smblctx);
4951 #if defined(HAVE_LONGLONG)
4952 SIVAL(pdata, POSIX_LOCK_START_OFFSET, (uint32)(offset & 0xFFFFFFFF));
4953 SIVAL(pdata, POSIX_LOCK_START_OFFSET + 4, (uint32)((offset >> 32) & 0xFFFFFFFF));
4954 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, (uint32)(count & 0xFFFFFFFF));
4955 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET + 4, (uint32)((count >> 32) & 0xFFFFFFFF));
4956 #else /* HAVE_LONGLONG */
4957 SIVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
4958 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
4959 #endif /* HAVE_LONGLONG */
4961 } else if (NT_STATUS_IS_OK(status)) {
4962 /* For success we just return a copy of what we sent
4963 with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
4964 data_size = POSIX_LOCK_DATA_SIZE;
4965 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
4966 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
4974 return NT_STATUS_INVALID_LEVEL;
4977 *pdata_size = data_size;
4978 return NT_STATUS_OK;
4981 /****************************************************************************
4982 Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
4983 file name or file id).
4984 ****************************************************************************/
4986 static void call_trans2qfilepathinfo(connection_struct *conn,
4987 struct smb_request *req,
4988 unsigned int tran_call,
4989 char **pparams, int total_params,
4990 char **ppdata, int total_data,
4991 unsigned int max_data_bytes)
4993 char *params = *pparams;
4994 char *pdata = *ppdata;
4996 unsigned int data_size = 0;
4997 unsigned int param_size = 2;
4998 struct smb_filename *smb_fname = NULL;
4999 bool delete_pending = False;
5000 struct timespec write_time_ts;
5001 files_struct *fsp = NULL;
5002 struct file_id fileid;
5003 struct ea_list *ea_list = NULL;
5004 int lock_data_count = 0;
5005 char *lock_data = NULL;
5006 NTSTATUS status = NT_STATUS_OK;
5009 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5013 ZERO_STRUCT(write_time_ts);
5015 if (tran_call == TRANSACT2_QFILEINFO) {
5016 if (total_params < 4) {
5017 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5022 call_trans2qpipeinfo(conn, req, tran_call,
5023 pparams, total_params,
5029 fsp = file_fsp(req, SVAL(params,0));
5030 info_level = SVAL(params,2);
5032 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
5034 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
5035 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5039 /* Initial check for valid fsp ptr. */
5040 if (!check_fsp_open(conn, req, fsp)) {
5044 status = copy_smb_filename(talloc_tos(), fsp->fsp_name,
5046 if (!NT_STATUS_IS_OK(status)) {
5047 reply_nterror(req, status);
5051 if(fsp->fake_file_handle) {
5053 * This is actually for the QUOTA_FAKE_FILE --metze
5056 /* We know this name is ok, it's already passed the checks. */
5058 } else if(fsp->fh->fd == -1) {
5060 * This is actually a QFILEINFO on a directory
5061 * handle (returned from an NT SMB). NT5.0 seems
5062 * to do this call. JRA.
5065 if (INFO_LEVEL_IS_UNIX(info_level)) {
5066 /* Always do lstat for UNIX calls. */
5067 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5068 DEBUG(3,("call_trans2qfilepathinfo: "
5069 "SMB_VFS_LSTAT of %s failed "
5071 smb_fname_str_dbg(smb_fname),
5074 map_nt_error_from_unix(errno));
5077 } else if (SMB_VFS_STAT(conn, smb_fname)) {
5078 DEBUG(3,("call_trans2qfilepathinfo: "
5079 "SMB_VFS_STAT of %s failed (%s)\n",
5080 smb_fname_str_dbg(smb_fname),
5083 map_nt_error_from_unix(errno));
5087 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5088 get_file_infos(fileid, fsp->name_hash, &delete_pending, &write_time_ts);
5091 * Original code - this is an open file.
5093 if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
5094 DEBUG(3, ("fstat of fnum %d failed (%s)\n",
5095 fsp->fnum, strerror(errno)));
5097 map_nt_error_from_unix(errno));
5100 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5101 get_file_infos(fileid, fsp->name_hash, &delete_pending, &write_time_ts);
5107 uint32_t ucf_flags = 0;
5110 if (total_params < 7) {
5111 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5115 info_level = SVAL(params,0);
5117 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
5119 if (INFO_LEVEL_IS_UNIX(info_level)) {
5120 if (!lp_unix_extensions()) {
5121 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5124 if (info_level == SMB_QUERY_FILE_UNIX_BASIC ||
5125 info_level == SMB_QUERY_FILE_UNIX_INFO2 ||
5126 info_level == SMB_QUERY_FILE_UNIX_LINK) {
5127 ucf_flags |= UCF_UNIX_NAME_LOOKUP;
5131 srvstr_get_path(req, params, req->flags2, &fname, ¶ms[6],
5133 STR_TERMINATE, &status);
5134 if (!NT_STATUS_IS_OK(status)) {
5135 reply_nterror(req, status);
5139 status = filename_convert(req,
5141 req->flags2 & FLAGS2_DFS_PATHNAMES,
5146 if (!NT_STATUS_IS_OK(status)) {
5147 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5148 reply_botherror(req,
5149 NT_STATUS_PATH_NOT_COVERED,
5150 ERRSRV, ERRbadpath);
5153 reply_nterror(req, status);
5157 /* If this is a stream, check if there is a delete_pending. */
5158 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
5159 && is_ntfs_stream_smb_fname(smb_fname)) {
5160 struct smb_filename *smb_fname_base = NULL;
5162 /* Create an smb_filename with stream_name == NULL. */
5164 create_synthetic_smb_fname(talloc_tos(),
5165 smb_fname->base_name,
5168 if (!NT_STATUS_IS_OK(status)) {
5169 reply_nterror(req, status);
5173 if (INFO_LEVEL_IS_UNIX(info_level)) {
5174 /* Always do lstat for UNIX calls. */
5175 if (SMB_VFS_LSTAT(conn, smb_fname_base) != 0) {
5176 DEBUG(3,("call_trans2qfilepathinfo: "
5177 "SMB_VFS_LSTAT of %s failed "
5179 smb_fname_str_dbg(smb_fname_base),
5181 TALLOC_FREE(smb_fname_base);
5183 map_nt_error_from_unix(errno));
5187 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
5188 DEBUG(3,("call_trans2qfilepathinfo: "
5189 "fileinfo of %s failed "
5191 smb_fname_str_dbg(smb_fname_base),
5193 TALLOC_FREE(smb_fname_base);
5195 map_nt_error_from_unix(errno));
5200 status = file_name_hash(conn,
5201 smb_fname_str_dbg(smb_fname_base),
5203 if (!NT_STATUS_IS_OK(status)) {
5204 TALLOC_FREE(smb_fname_base);
5205 reply_nterror(req, status);
5209 fileid = vfs_file_id_from_sbuf(conn,
5210 &smb_fname_base->st);
5211 TALLOC_FREE(smb_fname_base);
5212 get_file_infos(fileid, name_hash, &delete_pending, NULL);
5213 if (delete_pending) {
5214 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5219 if (INFO_LEVEL_IS_UNIX(info_level)) {
5220 /* Always do lstat for UNIX calls. */
5221 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5222 DEBUG(3,("call_trans2qfilepathinfo: "
5223 "SMB_VFS_LSTAT of %s failed (%s)\n",
5224 smb_fname_str_dbg(smb_fname),
5227 map_nt_error_from_unix(errno));
5232 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
5233 DEBUG(3,("call_trans2qfilepathinfo: "
5234 "SMB_VFS_STAT of %s failed (%s)\n",
5235 smb_fname_str_dbg(smb_fname),
5238 map_nt_error_from_unix(errno));
5243 status = file_name_hash(conn,
5244 smb_fname_str_dbg(smb_fname),
5246 if (!NT_STATUS_IS_OK(status)) {
5247 reply_nterror(req, status);
5251 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5252 get_file_infos(fileid, name_hash, &delete_pending, &write_time_ts);
5253 if (delete_pending) {
5254 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5259 DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d "
5260 "total_data=%d\n", smb_fname_str_dbg(smb_fname),
5261 fsp ? fsp->fnum : -1, info_level,tran_call,total_data));
5263 /* Pull out any data sent here before we realloc. */
5264 switch (info_level) {
5265 case SMB_INFO_QUERY_EAS_FROM_LIST:
5267 /* Pull any EA list from the data portion. */
5270 if (total_data < 4) {
5272 req, NT_STATUS_INVALID_PARAMETER);
5275 ea_size = IVAL(pdata,0);
5277 if (total_data > 0 && ea_size != total_data) {
5278 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
5279 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
5281 req, NT_STATUS_INVALID_PARAMETER);
5285 if (!lp_ea_support(SNUM(conn))) {
5286 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
5290 /* Pull out the list of names. */
5291 ea_list = read_ea_name_list(req, pdata + 4, ea_size - 4);
5294 req, NT_STATUS_INVALID_PARAMETER);
5300 case SMB_QUERY_POSIX_LOCK:
5302 if (fsp == NULL || fsp->fh->fd == -1) {
5303 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
5307 if (total_data != POSIX_LOCK_DATA_SIZE) {
5309 req, NT_STATUS_INVALID_PARAMETER);
5313 /* Copy the lock range data. */
5314 lock_data = (char *)talloc_memdup(
5315 req, pdata, total_data);
5317 reply_nterror(req, NT_STATUS_NO_MEMORY);
5320 lock_data_count = total_data;
5326 *pparams = (char *)SMB_REALLOC(*pparams,2);
5327 if (*pparams == NULL) {
5328 reply_nterror(req, NT_STATUS_NO_MEMORY);
5335 * draft-leach-cifs-v1-spec-02.txt
5336 * 4.2.14 TRANS2_QUERY_PATH_INFORMATION: Get File Attributes given Path
5339 * The requested information is placed in the Data portion of the
5340 * transaction response. For the information levels greater than 0x100,
5341 * the transaction response has 1 parameter word which should be
5342 * ignored by the client.
5344 * However Windows only follows this rule for the IS_NAME_VALID call.
5346 switch (info_level) {
5347 case SMB_INFO_IS_NAME_VALID:
5352 if ((info_level & 0xFF00) == 0xFF00) {
5354 * We use levels that start with 0xFF00
5355 * internally to represent SMB2 specific levels
5357 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5361 status = smbd_do_qfilepathinfo(conn, req, info_level,
5363 delete_pending, write_time_ts,
5365 lock_data_count, lock_data,
5366 req->flags2, max_data_bytes,
5367 ppdata, &data_size);
5368 if (!NT_STATUS_IS_OK(status)) {
5369 reply_nterror(req, status);
5373 send_trans2_replies(conn, req, params, param_size, *ppdata, data_size,
5379 /****************************************************************************
5380 Set a hard link (called by UNIX extensions and by NT rename with HARD link
5382 ****************************************************************************/
5384 NTSTATUS hardlink_internals(TALLOC_CTX *ctx,
5385 connection_struct *conn,
5386 struct smb_request *req,
5387 bool overwrite_if_exists,
5388 const struct smb_filename *smb_fname_old,
5389 struct smb_filename *smb_fname_new)
5391 NTSTATUS status = NT_STATUS_OK;
5393 /* source must already exist. */
5394 if (!VALID_STAT(smb_fname_old->st)) {
5395 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5398 if (VALID_STAT(smb_fname_new->st)) {
5399 if (overwrite_if_exists) {
5400 if (S_ISDIR(smb_fname_new->st.st_ex_mode)) {
5401 return NT_STATUS_FILE_IS_A_DIRECTORY;
5403 status = unlink_internals(conn,
5405 FILE_ATTRIBUTE_NORMAL,
5408 if (!NT_STATUS_IS_OK(status)) {
5412 /* Disallow if newname already exists. */
5413 return NT_STATUS_OBJECT_NAME_COLLISION;
5417 /* No links from a directory. */
5418 if (S_ISDIR(smb_fname_old->st.st_ex_mode)) {
5419 return NT_STATUS_FILE_IS_A_DIRECTORY;
5422 /* Setting a hardlink to/from a stream isn't currently supported. */
5423 if (is_ntfs_stream_smb_fname(smb_fname_old) ||
5424 is_ntfs_stream_smb_fname(smb_fname_new)) {
5425 return NT_STATUS_INVALID_PARAMETER;
5428 DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n",
5429 smb_fname_old->base_name, smb_fname_new->base_name));
5431 if (SMB_VFS_LINK(conn, smb_fname_old->base_name,
5432 smb_fname_new->base_name) != 0) {
5433 status = map_nt_error_from_unix(errno);
5434 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
5435 nt_errstr(status), smb_fname_old->base_name,
5436 smb_fname_new->base_name));
5441 /****************************************************************************
5442 Deal with setting the time from any of the setfilepathinfo functions.
5443 ****************************************************************************/
5445 NTSTATUS smb_set_file_time(connection_struct *conn,
5447 const struct smb_filename *smb_fname,
5448 struct smb_file_time *ft,
5449 bool setting_write_time)
5451 struct smb_filename smb_fname_base;
5453 FILE_NOTIFY_CHANGE_LAST_ACCESS
5454 |FILE_NOTIFY_CHANGE_LAST_WRITE
5455 |FILE_NOTIFY_CHANGE_CREATION;
5457 if (!VALID_STAT(smb_fname->st)) {
5458 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5461 if (fsp && !(fsp->access_mask & FILE_WRITE_ATTRIBUTES)) {
5462 return NT_STATUS_ACCESS_DENIED;
5465 /* get some defaults (no modifications) if any info is zero or -1. */
5466 if (null_timespec(ft->create_time)) {
5467 action &= ~FILE_NOTIFY_CHANGE_CREATION;
5470 if (null_timespec(ft->atime)) {
5471 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
5474 if (null_timespec(ft->mtime)) {
5475 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
5478 if (!setting_write_time) {
5479 /* ft->mtime comes from change time, not write time. */
5480 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
5483 /* Ensure the resolution is the correct for
5484 * what we can store on this filesystem. */
5486 round_timespec(conn->ts_res, &ft->create_time);
5487 round_timespec(conn->ts_res, &ft->ctime);
5488 round_timespec(conn->ts_res, &ft->atime);
5489 round_timespec(conn->ts_res, &ft->mtime);
5491 DEBUG(5,("smb_set_filetime: actime: %s\n ",
5492 time_to_asc(convert_timespec_to_time_t(ft->atime))));
5493 DEBUG(5,("smb_set_filetime: modtime: %s\n ",
5494 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5495 DEBUG(5,("smb_set_filetime: ctime: %s\n ",
5496 time_to_asc(convert_timespec_to_time_t(ft->ctime))));
5497 DEBUG(5,("smb_set_file_time: createtime: %s\n ",
5498 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
5500 if (setting_write_time) {
5502 * This was a Windows setfileinfo on an open file.
5503 * NT does this a lot. We also need to
5504 * set the time here, as it can be read by
5505 * FindFirst/FindNext and with the patch for bug #2045
5506 * in smbd/fileio.c it ensures that this timestamp is
5507 * kept sticky even after a write. We save the request
5508 * away and will set it on file close and after a write. JRA.
5511 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
5512 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5515 if (fsp->base_fsp) {
5516 set_sticky_write_time_fsp(fsp->base_fsp,
5519 set_sticky_write_time_fsp(fsp, ft->mtime);
5522 set_sticky_write_time_path(
5523 vfs_file_id_from_sbuf(conn, &smb_fname->st),
5528 DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
5530 /* Always call ntimes on the base, even if a stream was passed in. */
5531 smb_fname_base = *smb_fname;
5532 smb_fname_base.stream_name = NULL;
5534 if(file_ntimes(conn, &smb_fname_base, ft)!=0) {
5535 return map_nt_error_from_unix(errno);
5538 notify_fname(conn, NOTIFY_ACTION_MODIFIED, action,
5539 smb_fname->base_name);
5540 return NT_STATUS_OK;
5543 /****************************************************************************
5544 Deal with setting the dosmode from any of the setfilepathinfo functions.
5545 ****************************************************************************/
5547 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
5548 const struct smb_filename *smb_fname,
5551 struct smb_filename *smb_fname_base = NULL;
5554 if (!VALID_STAT(smb_fname->st)) {
5555 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5558 /* Always operate on the base_name, even if a stream was passed in. */
5559 status = create_synthetic_smb_fname(talloc_tos(), smb_fname->base_name,
5560 NULL, &smb_fname->st,
5562 if (!NT_STATUS_IS_OK(status)) {
5567 if (S_ISDIR(smb_fname_base->st.st_ex_mode)) {
5568 dosmode |= FILE_ATTRIBUTE_DIRECTORY;
5570 dosmode &= ~FILE_ATTRIBUTE_DIRECTORY;
5574 DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
5576 /* check the mode isn't different, before changing it */
5577 if ((dosmode != 0) && (dosmode != dos_mode(conn, smb_fname_base))) {
5578 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode "
5579 "0x%x\n", smb_fname_str_dbg(smb_fname_base),
5580 (unsigned int)dosmode));
5582 if(file_set_dosmode(conn, smb_fname_base, dosmode, NULL,
5584 DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of "
5586 smb_fname_str_dbg(smb_fname_base),
5588 status = map_nt_error_from_unix(errno);
5592 status = NT_STATUS_OK;
5594 TALLOC_FREE(smb_fname_base);
5598 /****************************************************************************
5599 Deal with setting the size from any of the setfilepathinfo functions.
5600 ****************************************************************************/
5602 static NTSTATUS smb_set_file_size(connection_struct *conn,
5603 struct smb_request *req,
5605 const struct smb_filename *smb_fname,
5606 const SMB_STRUCT_STAT *psbuf,
5608 bool fail_after_createfile)
5610 NTSTATUS status = NT_STATUS_OK;
5611 struct smb_filename *smb_fname_tmp = NULL;
5612 files_struct *new_fsp = NULL;
5614 if (!VALID_STAT(*psbuf)) {
5615 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5618 if (fsp && !(fsp->access_mask & FILE_WRITE_DATA)) {
5619 return NT_STATUS_ACCESS_DENIED;
5622 DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
5624 if (size == get_file_size_stat(psbuf)) {
5625 return NT_STATUS_OK;
5628 DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
5629 smb_fname_str_dbg(smb_fname), (double)size));
5631 if (fsp && fsp->fh->fd != -1) {
5632 /* Handle based call. */
5633 if (vfs_set_filelen(fsp, size) == -1) {
5634 return map_nt_error_from_unix(errno);
5636 trigger_write_time_update_immediate(fsp);
5637 return NT_STATUS_OK;
5640 status = copy_smb_filename(talloc_tos(), smb_fname, &smb_fname_tmp);
5641 if (!NT_STATUS_IS_OK(status)) {
5645 smb_fname_tmp->st = *psbuf;
5647 status = SMB_VFS_CREATE_FILE(
5650 0, /* root_dir_fid */
5651 smb_fname_tmp, /* fname */
5652 FILE_WRITE_DATA, /* access_mask */
5653 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
5655 FILE_OPEN, /* create_disposition*/
5656 0, /* create_options */
5657 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
5658 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
5659 0, /* allocation_size */
5660 0, /* private_flags */
5663 &new_fsp, /* result */
5666 TALLOC_FREE(smb_fname_tmp);
5668 if (!NT_STATUS_IS_OK(status)) {
5669 /* NB. We check for open_was_deferred in the caller. */
5673 /* See RAW-SFILEINFO-END-OF-FILE */
5674 if (fail_after_createfile) {
5675 close_file(req, new_fsp,NORMAL_CLOSE);
5676 return NT_STATUS_INVALID_LEVEL;
5679 if (vfs_set_filelen(new_fsp, size) == -1) {
5680 status = map_nt_error_from_unix(errno);
5681 close_file(req, new_fsp,NORMAL_CLOSE);
5685 trigger_write_time_update_immediate(new_fsp);
5686 close_file(req, new_fsp,NORMAL_CLOSE);
5687 return NT_STATUS_OK;
5690 /****************************************************************************
5691 Deal with SMB_INFO_SET_EA.
5692 ****************************************************************************/
5694 static NTSTATUS smb_info_set_ea(connection_struct *conn,
5698 const struct smb_filename *smb_fname)
5700 struct ea_list *ea_list = NULL;
5701 TALLOC_CTX *ctx = NULL;
5702 NTSTATUS status = NT_STATUS_OK;
5704 if (total_data < 10) {
5706 /* OS/2 workplace shell seems to send SET_EA requests of "null"
5707 length. They seem to have no effect. Bug #3212. JRA */
5709 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
5710 /* We're done. We only get EA info in this call. */
5711 return NT_STATUS_OK;
5714 return NT_STATUS_INVALID_PARAMETER;
5717 if (IVAL(pdata,0) > total_data) {
5718 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
5719 IVAL(pdata,0), (unsigned int)total_data));
5720 return NT_STATUS_INVALID_PARAMETER;
5724 ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
5726 return NT_STATUS_INVALID_PARAMETER;
5729 if (fsp && !(fsp->access_mask & FILE_WRITE_EA)) {
5730 return NT_STATUS_ACCESS_DENIED;
5733 status = set_ea(conn, fsp, smb_fname, ea_list);
5738 /****************************************************************************
5739 Deal with SMB_FILE_FULL_EA_INFORMATION set.
5740 ****************************************************************************/
5742 static NTSTATUS smb_set_file_full_ea_info(connection_struct *conn,
5747 struct ea_list *ea_list = NULL;
5751 return NT_STATUS_INVALID_HANDLE;
5754 if (!lp_ea_support(SNUM(conn))) {
5755 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u but "
5756 "EA's not supported.\n",
5757 (unsigned int)total_data));
5758 return NT_STATUS_EAS_NOT_SUPPORTED;
5761 if (total_data < 10) {
5762 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u "
5764 (unsigned int)total_data));
5765 return NT_STATUS_INVALID_PARAMETER;
5768 ea_list = read_nttrans_ea_list(talloc_tos(),
5773 return NT_STATUS_INVALID_PARAMETER;
5776 if (fsp && !(fsp->access_mask & FILE_WRITE_EA)) {
5777 return NT_STATUS_ACCESS_DENIED;
5780 status = set_ea(conn, fsp, fsp->fsp_name, ea_list);
5782 DEBUG(10, ("smb_set_file_full_ea_info on file %s returned %s\n",
5783 smb_fname_str_dbg(fsp->fsp_name),
5784 nt_errstr(status) ));
5790 /****************************************************************************
5791 Deal with SMB_SET_FILE_DISPOSITION_INFO.
5792 ****************************************************************************/
5794 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
5798 struct smb_filename *smb_fname)
5800 NTSTATUS status = NT_STATUS_OK;
5801 bool delete_on_close;
5804 if (total_data < 1) {
5805 return NT_STATUS_INVALID_PARAMETER;
5809 return NT_STATUS_INVALID_HANDLE;
5812 delete_on_close = (CVAL(pdata,0) ? True : False);
5813 dosmode = dos_mode(conn, smb_fname);
5815 DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
5816 "delete_on_close = %u\n",
5817 smb_fname_str_dbg(smb_fname),
5818 (unsigned int)dosmode,
5819 (unsigned int)delete_on_close ));
5821 if (delete_on_close) {
5822 status = can_set_delete_on_close(fsp, dosmode);
5823 if (!NT_STATUS_IS_OK(status)) {
5828 /* The set is across all open files on this dev/inode pair. */
5829 if (!set_delete_on_close(fsp, delete_on_close,
5830 conn->session_info->unix_token)) {
5831 return NT_STATUS_ACCESS_DENIED;
5833 return NT_STATUS_OK;
5836 /****************************************************************************
5837 Deal with SMB_FILE_POSITION_INFORMATION.
5838 ****************************************************************************/
5840 static NTSTATUS smb_file_position_information(connection_struct *conn,
5845 uint64_t position_information;
5847 if (total_data < 8) {
5848 return NT_STATUS_INVALID_PARAMETER;
5852 /* Ignore on pathname based set. */
5853 return NT_STATUS_OK;
5856 position_information = (uint64_t)IVAL(pdata,0);
5857 #ifdef LARGE_SMB_OFF_T
5858 position_information |= (((uint64_t)IVAL(pdata,4)) << 32);
5859 #else /* LARGE_SMB_OFF_T */
5860 if (IVAL(pdata,4) != 0) {
5861 /* more than 32 bits? */
5862 return NT_STATUS_INVALID_PARAMETER;
5864 #endif /* LARGE_SMB_OFF_T */
5866 DEBUG(10,("smb_file_position_information: Set file position "
5867 "information for file %s to %.0f\n", fsp_str_dbg(fsp),
5868 (double)position_information));
5869 fsp->fh->position_information = position_information;
5870 return NT_STATUS_OK;
5873 /****************************************************************************
5874 Deal with SMB_FILE_MODE_INFORMATION.
5875 ****************************************************************************/
5877 static NTSTATUS smb_file_mode_information(connection_struct *conn,
5883 if (total_data < 4) {
5884 return NT_STATUS_INVALID_PARAMETER;
5886 mode = IVAL(pdata,0);
5887 if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
5888 return NT_STATUS_INVALID_PARAMETER;
5890 return NT_STATUS_OK;
5893 /****************************************************************************
5894 Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
5895 ****************************************************************************/
5897 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
5898 struct smb_request *req,
5901 const struct smb_filename *smb_fname)
5903 char *link_target = NULL;
5904 const char *newname = smb_fname->base_name;
5905 TALLOC_CTX *ctx = talloc_tos();
5907 /* Set a symbolic link. */
5908 /* Don't allow this if follow links is false. */
5910 if (total_data == 0) {
5911 return NT_STATUS_INVALID_PARAMETER;
5914 if (!lp_symlinks(SNUM(conn))) {
5915 return NT_STATUS_ACCESS_DENIED;
5918 srvstr_pull_talloc(ctx, pdata, req->flags2, &link_target, pdata,
5919 total_data, STR_TERMINATE);
5922 return NT_STATUS_INVALID_PARAMETER;
5925 DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
5926 newname, link_target ));
5928 if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
5929 return map_nt_error_from_unix(errno);
5932 return NT_STATUS_OK;
5935 /****************************************************************************
5936 Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
5937 ****************************************************************************/
5939 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
5940 struct smb_request *req,
5941 const char *pdata, int total_data,
5942 struct smb_filename *smb_fname_new)
5944 char *oldname = NULL;
5945 struct smb_filename *smb_fname_old = NULL;
5946 TALLOC_CTX *ctx = talloc_tos();
5947 NTSTATUS status = NT_STATUS_OK;
5949 /* Set a hard link. */
5950 if (total_data == 0) {
5951 return NT_STATUS_INVALID_PARAMETER;
5954 srvstr_get_path(ctx, pdata, req->flags2, &oldname, pdata,
5955 total_data, STR_TERMINATE, &status);
5956 if (!NT_STATUS_IS_OK(status)) {
5960 DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
5961 smb_fname_str_dbg(smb_fname_new), oldname));
5963 status = filename_convert(ctx,
5965 req->flags2 & FLAGS2_DFS_PATHNAMES,
5970 if (!NT_STATUS_IS_OK(status)) {
5974 return hardlink_internals(ctx, conn, req, false,
5975 smb_fname_old, smb_fname_new);
5978 /****************************************************************************
5979 Deal with SMB2_FILE_RENAME_INFORMATION_INTERNAL
5980 ****************************************************************************/
5982 static NTSTATUS smb2_file_rename_information(connection_struct *conn,
5983 struct smb_request *req,
5987 struct smb_filename *smb_fname_src)
5991 char *newname = NULL;
5992 struct smb_filename *smb_fname_dst = NULL;
5993 NTSTATUS status = NT_STATUS_OK;
5994 TALLOC_CTX *ctx = talloc_tos();
5997 return NT_STATUS_INVALID_HANDLE;
6000 if (total_data < 20) {
6001 return NT_STATUS_INVALID_PARAMETER;
6004 overwrite = (CVAL(pdata,0) ? True : False);
6005 len = IVAL(pdata,16);
6007 if (len > (total_data - 20) || (len == 0)) {
6008 return NT_STATUS_INVALID_PARAMETER;
6011 srvstr_get_path(ctx, pdata, req->flags2, &newname,
6012 &pdata[20], len, STR_TERMINATE,
6014 if (!NT_STATUS_IS_OK(status)) {
6018 DEBUG(10,("smb2_file_rename_information: got name |%s|\n",
6021 status = filename_convert(ctx,
6023 req->flags2 & FLAGS2_DFS_PATHNAMES,
6028 if (!NT_STATUS_IS_OK(status)) {
6032 if (fsp->base_fsp) {
6033 /* newname must be a stream name. */
6034 if (newname[0] != ':') {
6035 return NT_STATUS_NOT_SUPPORTED;
6038 /* Create an smb_fname to call rename_internals_fsp() with. */
6039 status = create_synthetic_smb_fname(talloc_tos(),
6040 fsp->base_fsp->fsp_name->base_name, newname, NULL,
6042 if (!NT_STATUS_IS_OK(status)) {
6047 * Set the original last component, since
6048 * rename_internals_fsp() requires it.
6050 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
6052 if (smb_fname_dst->original_lcomp == NULL) {
6053 status = NT_STATUS_NO_MEMORY;
6059 DEBUG(10,("smb2_file_rename_information: "
6060 "SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
6061 fsp->fnum, fsp_str_dbg(fsp),
6062 smb_fname_str_dbg(smb_fname_dst)));
6063 status = rename_internals_fsp(conn, fsp, smb_fname_dst,
6064 (FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM),
6068 TALLOC_FREE(smb_fname_dst);
6072 static NTSTATUS smb_file_link_information(connection_struct *conn,
6073 struct smb_request *req,
6077 struct smb_filename *smb_fname_src)
6081 char *newname = NULL;
6082 struct smb_filename *smb_fname_dst = NULL;
6083 NTSTATUS status = NT_STATUS_OK;
6084 TALLOC_CTX *ctx = talloc_tos();
6087 return NT_STATUS_INVALID_HANDLE;
6090 if (total_data < 20) {
6091 return NT_STATUS_INVALID_PARAMETER;
6094 overwrite = (CVAL(pdata,0) ? true : false);
6095 len = IVAL(pdata,16);
6097 if (len > (total_data - 20) || (len == 0)) {
6098 return NT_STATUS_INVALID_PARAMETER;
6101 srvstr_get_path(ctx, pdata, req->flags2, &newname,
6102 &pdata[20], len, STR_TERMINATE,
6104 if (!NT_STATUS_IS_OK(status)) {
6108 DEBUG(10,("smb_file_link_information: got name |%s|\n",
6111 status = filename_convert(ctx,
6113 req->flags2 & FLAGS2_DFS_PATHNAMES,
6118 if (!NT_STATUS_IS_OK(status)) {
6122 if (fsp->base_fsp) {
6123 /* No stream names. */
6124 return NT_STATUS_NOT_SUPPORTED;
6127 DEBUG(10,("smb_file_link_information: "
6128 "SMB_FILE_LINK_INFORMATION (fnum %d) %s -> %s\n",
6129 fsp->fnum, fsp_str_dbg(fsp),
6130 smb_fname_str_dbg(smb_fname_dst)));
6131 status = hardlink_internals(ctx,
6138 TALLOC_FREE(smb_fname_dst);
6142 /****************************************************************************
6143 Deal with SMB_FILE_RENAME_INFORMATION.
6144 ****************************************************************************/
6146 static NTSTATUS smb_file_rename_information(connection_struct *conn,
6147 struct smb_request *req,
6151 struct smb_filename *smb_fname_src)
6156 char *newname = NULL;
6157 struct smb_filename *smb_fname_dst = NULL;
6158 bool dest_has_wcard = False;
6159 NTSTATUS status = NT_STATUS_OK;
6161 TALLOC_CTX *ctx = talloc_tos();
6163 if (total_data < 13) {
6164 return NT_STATUS_INVALID_PARAMETER;
6167 overwrite = (CVAL(pdata,0) ? True : False);
6168 root_fid = IVAL(pdata,4);
6169 len = IVAL(pdata,8);
6171 if (len > (total_data - 12) || (len == 0) || (root_fid != 0)) {
6172 return NT_STATUS_INVALID_PARAMETER;
6175 srvstr_get_path_wcard(ctx, pdata, req->flags2, &newname, &pdata[12],
6178 if (!NT_STATUS_IS_OK(status)) {
6182 DEBUG(10,("smb_file_rename_information: got name |%s|\n",
6185 status = resolve_dfspath_wcard(ctx, conn,
6186 req->flags2 & FLAGS2_DFS_PATHNAMES,
6191 if (!NT_STATUS_IS_OK(status)) {
6195 /* Check the new name has no '/' characters. */
6196 if (strchr_m(newname, '/')) {
6197 return NT_STATUS_NOT_SUPPORTED;
6200 if (fsp && fsp->base_fsp) {
6201 /* newname must be a stream name. */
6202 if (newname[0] != ':') {
6203 return NT_STATUS_NOT_SUPPORTED;
6206 /* Create an smb_fname to call rename_internals_fsp() with. */
6207 status = create_synthetic_smb_fname(talloc_tos(),
6208 fsp->base_fsp->fsp_name->base_name, newname, NULL,
6210 if (!NT_STATUS_IS_OK(status)) {
6215 * Set the original last component, since
6216 * rename_internals_fsp() requires it.
6218 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
6220 if (smb_fname_dst->original_lcomp == NULL) {
6221 status = NT_STATUS_NO_MEMORY;
6227 * Build up an smb_fname_dst based on the filename passed in.
6228 * We basically just strip off the last component, and put on
6229 * the newname instead.
6231 char *base_name = NULL;
6233 /* newname must *not* be a stream name. */
6234 if (newname[0] == ':') {
6235 return NT_STATUS_NOT_SUPPORTED;
6239 * Strip off the last component (filename) of the path passed
6242 base_name = talloc_strdup(ctx, smb_fname_src->base_name);
6244 return NT_STATUS_NO_MEMORY;
6246 p = strrchr_m(base_name, '/');
6250 base_name = talloc_strdup(ctx, "");
6252 return NT_STATUS_NO_MEMORY;
6255 /* Append the new name. */
6256 base_name = talloc_asprintf_append(base_name,
6260 return NT_STATUS_NO_MEMORY;
6263 status = unix_convert(ctx, conn, base_name, &smb_fname_dst,
6266 UCF_ALWAYS_ALLOW_WCARD_LCOMP :
6269 /* If an error we expect this to be
6270 * NT_STATUS_OBJECT_PATH_NOT_FOUND */
6272 if (!NT_STATUS_IS_OK(status)) {
6273 if(!NT_STATUS_EQUAL(NT_STATUS_OBJECT_PATH_NOT_FOUND,
6277 /* Create an smb_fname to call rename_internals_fsp() */
6278 status = create_synthetic_smb_fname(ctx,
6282 if (!NT_STATUS_IS_OK(status)) {
6289 DEBUG(10,("smb_file_rename_information: "
6290 "SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
6291 fsp->fnum, fsp_str_dbg(fsp),
6292 smb_fname_str_dbg(smb_fname_dst)));
6293 status = rename_internals_fsp(conn, fsp, smb_fname_dst, 0,
6296 DEBUG(10,("smb_file_rename_information: "
6297 "SMB_FILE_RENAME_INFORMATION %s -> %s\n",
6298 smb_fname_str_dbg(smb_fname_src),
6299 smb_fname_str_dbg(smb_fname_dst)));
6300 status = rename_internals(ctx, conn, req, smb_fname_src,
6301 smb_fname_dst, 0, overwrite, false,
6303 FILE_WRITE_ATTRIBUTES);
6306 TALLOC_FREE(smb_fname_dst);
6310 /****************************************************************************
6311 Deal with SMB_SET_POSIX_ACL.
6312 ****************************************************************************/
6314 #if defined(HAVE_POSIX_ACLS)
6315 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
6319 const struct smb_filename *smb_fname)
6321 uint16 posix_acl_version;
6322 uint16 num_file_acls;
6323 uint16 num_def_acls;
6324 bool valid_file_acls = True;
6325 bool valid_def_acls = True;
6327 if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
6328 return NT_STATUS_INVALID_PARAMETER;
6330 posix_acl_version = SVAL(pdata,0);
6331 num_file_acls = SVAL(pdata,2);
6332 num_def_acls = SVAL(pdata,4);
6334 if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6335 valid_file_acls = False;
6339 if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6340 valid_def_acls = False;
6344 if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
6345 return NT_STATUS_INVALID_PARAMETER;
6348 if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
6349 (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
6350 return NT_STATUS_INVALID_PARAMETER;
6353 DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
6354 smb_fname ? smb_fname_str_dbg(smb_fname) : fsp_str_dbg(fsp),
6355 (unsigned int)num_file_acls,
6356 (unsigned int)num_def_acls));
6358 if (valid_file_acls && !set_unix_posix_acl(conn, fsp,
6359 smb_fname->base_name, num_file_acls,
6360 pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
6361 return map_nt_error_from_unix(errno);
6364 if (valid_def_acls && !set_unix_posix_default_acl(conn,
6365 smb_fname->base_name, &smb_fname->st, num_def_acls,
6366 pdata + SMB_POSIX_ACL_HEADER_SIZE +
6367 (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
6368 return map_nt_error_from_unix(errno);
6370 return NT_STATUS_OK;
6374 /****************************************************************************
6375 Deal with SMB_SET_POSIX_LOCK.
6376 ****************************************************************************/
6378 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
6379 struct smb_request *req,
6387 bool blocking_lock = False;
6388 enum brl_type lock_type;
6390 NTSTATUS status = NT_STATUS_OK;
6392 if (fsp == NULL || fsp->fh->fd == -1) {
6393 return NT_STATUS_INVALID_HANDLE;
6396 if (total_data != POSIX_LOCK_DATA_SIZE) {
6397 return NT_STATUS_INVALID_PARAMETER;
6400 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
6401 case POSIX_LOCK_TYPE_READ:
6402 lock_type = READ_LOCK;
6404 case POSIX_LOCK_TYPE_WRITE:
6405 /* Return the right POSIX-mappable error code for files opened read-only. */
6406 if (!fsp->can_write) {
6407 return NT_STATUS_INVALID_HANDLE;
6409 lock_type = WRITE_LOCK;
6411 case POSIX_LOCK_TYPE_UNLOCK:
6412 lock_type = UNLOCK_LOCK;
6415 return NT_STATUS_INVALID_PARAMETER;
6418 if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
6419 blocking_lock = False;
6420 } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
6421 blocking_lock = True;
6423 return NT_STATUS_INVALID_PARAMETER;
6426 if (!lp_blocking_locks(SNUM(conn))) {
6427 blocking_lock = False;
6430 smblctx = (uint64_t)IVAL(pdata, POSIX_LOCK_PID_OFFSET);
6431 #if defined(HAVE_LONGLONG)
6432 offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
6433 ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
6434 count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
6435 ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
6436 #else /* HAVE_LONGLONG */
6437 offset = (uint64_t)IVAL(pdata,POSIX_LOCK_START_OFFSET);
6438 count = (uint64_t)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
6439 #endif /* HAVE_LONGLONG */
6441 DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
6442 "smblctx = %llu, count = %.0f, offset = %.0f\n",
6444 (unsigned int)lock_type,
6445 (unsigned long long)smblctx,
6449 if (lock_type == UNLOCK_LOCK) {
6450 status = do_unlock(req->sconn->msg_ctx,
6457 uint64_t block_smblctx;
6459 struct byte_range_lock *br_lck = do_lock(req->sconn->msg_ctx,
6471 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
6473 * A blocking lock was requested. Package up
6474 * this smb into a queued request and push it
6475 * onto the blocking lock queue.
6477 if(push_blocking_lock_request(br_lck,
6480 -1, /* infinite timeout. */
6488 TALLOC_FREE(br_lck);
6492 TALLOC_FREE(br_lck);
6498 /****************************************************************************
6499 Deal with SMB_SET_FILE_BASIC_INFO.
6500 ****************************************************************************/
6502 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
6506 const struct smb_filename *smb_fname)
6508 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
6509 struct smb_file_time ft;
6511 NTSTATUS status = NT_STATUS_OK;
6515 if (total_data < 36) {
6516 return NT_STATUS_INVALID_PARAMETER;
6519 if (fsp && !(fsp->access_mask & FILE_WRITE_ATTRIBUTES)) {
6520 return NT_STATUS_ACCESS_DENIED;
6523 /* Set the attributes */
6524 dosmode = IVAL(pdata,32);
6525 status = smb_set_file_dosmode(conn, smb_fname, dosmode);
6526 if (!NT_STATUS_IS_OK(status)) {
6531 ft.create_time = interpret_long_date(pdata);
6534 ft.atime = interpret_long_date(pdata+8);
6537 ft.mtime = interpret_long_date(pdata+16);
6540 ft.ctime = interpret_long_date(pdata+24);
6542 DEBUG(10, ("smb_set_file_basic_info: file %s\n",
6543 smb_fname_str_dbg(smb_fname)));
6545 return smb_set_file_time(conn, fsp, smb_fname, &ft,
6549 /****************************************************************************
6550 Deal with SMB_INFO_STANDARD.
6551 ****************************************************************************/
6553 static NTSTATUS smb_set_info_standard(connection_struct *conn,
6557 const struct smb_filename *smb_fname)
6559 struct smb_file_time ft;
6563 if (total_data < 12) {
6564 return NT_STATUS_INVALID_PARAMETER;
6567 if (fsp && !(fsp->access_mask & FILE_WRITE_ATTRIBUTES)) {
6568 return NT_STATUS_ACCESS_DENIED;
6572 ft.create_time = convert_time_t_to_timespec(srv_make_unix_date2(pdata));
6574 ft.atime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+4));
6576 ft.mtime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+8));
6578 DEBUG(10,("smb_set_info_standard: file %s\n",
6579 smb_fname_str_dbg(smb_fname)));
6581 return smb_set_file_time(conn,
6588 /****************************************************************************
6589 Deal with SMB_SET_FILE_ALLOCATION_INFO.
6590 ****************************************************************************/
6592 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
6593 struct smb_request *req,
6597 struct smb_filename *smb_fname)
6599 uint64_t allocation_size = 0;
6600 NTSTATUS status = NT_STATUS_OK;
6601 files_struct *new_fsp = NULL;
6603 if (!VALID_STAT(smb_fname->st)) {
6604 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6607 if (total_data < 8) {
6608 return NT_STATUS_INVALID_PARAMETER;
6611 allocation_size = (uint64_t)IVAL(pdata,0);
6612 #ifdef LARGE_SMB_OFF_T
6613 allocation_size |= (((uint64_t)IVAL(pdata,4)) << 32);
6614 #else /* LARGE_SMB_OFF_T */
6615 if (IVAL(pdata,4) != 0) {
6616 /* more than 32 bits? */
6617 return NT_STATUS_INVALID_PARAMETER;
6619 #endif /* LARGE_SMB_OFF_T */
6621 DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for "
6622 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6623 (double)allocation_size));
6625 if (allocation_size) {
6626 allocation_size = smb_roundup(conn, allocation_size);
6629 DEBUG(10,("smb_set_file_allocation_info: file %s : setting new "
6630 "allocation size to %.0f\n", smb_fname_str_dbg(smb_fname),
6631 (double)allocation_size));
6633 if (fsp && fsp->fh->fd != -1) {
6634 /* Open file handle. */
6635 if (!(fsp->access_mask & FILE_WRITE_DATA)) {
6636 return NT_STATUS_ACCESS_DENIED;
6639 /* Only change if needed. */
6640 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6641 if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
6642 return map_nt_error_from_unix(errno);
6645 /* But always update the time. */
6647 * This is equivalent to a write. Ensure it's seen immediately
6648 * if there are no pending writes.
6650 trigger_write_time_update_immediate(fsp);
6651 return NT_STATUS_OK;
6654 /* Pathname or stat or directory file. */
6655 status = SMB_VFS_CREATE_FILE(
6658 0, /* root_dir_fid */
6659 smb_fname, /* fname */
6660 FILE_WRITE_DATA, /* access_mask */
6661 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
6663 FILE_OPEN, /* create_disposition*/
6664 0, /* create_options */
6665 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
6666 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
6667 0, /* allocation_size */
6668 0, /* private_flags */
6671 &new_fsp, /* result */
6674 if (!NT_STATUS_IS_OK(status)) {
6675 /* NB. We check for open_was_deferred in the caller. */
6679 /* Only change if needed. */
6680 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6681 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
6682 status = map_nt_error_from_unix(errno);
6683 close_file(req, new_fsp, NORMAL_CLOSE);
6688 /* Changing the allocation size should set the last mod time. */
6690 * This is equivalent to a write. Ensure it's seen immediately
6691 * if there are no pending writes.
6693 trigger_write_time_update_immediate(new_fsp);
6695 close_file(req, new_fsp, NORMAL_CLOSE);
6696 return NT_STATUS_OK;
6699 /****************************************************************************
6700 Deal with SMB_SET_FILE_END_OF_FILE_INFO.
6701 ****************************************************************************/
6703 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
6704 struct smb_request *req,
6708 const struct smb_filename *smb_fname,
6709 bool fail_after_createfile)
6713 if (total_data < 8) {
6714 return NT_STATUS_INVALID_PARAMETER;
6717 size = IVAL(pdata,0);
6718 #ifdef LARGE_SMB_OFF_T
6719 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
6720 #else /* LARGE_SMB_OFF_T */
6721 if (IVAL(pdata,4) != 0) {
6722 /* more than 32 bits? */
6723 return NT_STATUS_INVALID_PARAMETER;
6725 #endif /* LARGE_SMB_OFF_T */
6726 DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
6727 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6730 return smb_set_file_size(conn, req,
6735 fail_after_createfile);
6738 /****************************************************************************
6739 Allow a UNIX info mknod.
6740 ****************************************************************************/
6742 static NTSTATUS smb_unix_mknod(connection_struct *conn,
6745 const struct smb_filename *smb_fname)
6747 uint32 file_type = IVAL(pdata,56);
6748 #if defined(HAVE_MAKEDEV)
6749 uint32 dev_major = IVAL(pdata,60);
6750 uint32 dev_minor = IVAL(pdata,68);
6752 SMB_DEV_T dev = (SMB_DEV_T)0;
6753 uint32 raw_unixmode = IVAL(pdata,84);
6757 if (total_data < 100) {
6758 return NT_STATUS_INVALID_PARAMETER;
6761 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6762 PERM_NEW_FILE, &unixmode);
6763 if (!NT_STATUS_IS_OK(status)) {
6767 #if defined(HAVE_MAKEDEV)
6768 dev = makedev(dev_major, dev_minor);
6771 switch (file_type) {
6772 #if defined(S_IFIFO)
6773 case UNIX_TYPE_FIFO:
6774 unixmode |= S_IFIFO;
6777 #if defined(S_IFSOCK)
6778 case UNIX_TYPE_SOCKET:
6779 unixmode |= S_IFSOCK;
6782 #if defined(S_IFCHR)
6783 case UNIX_TYPE_CHARDEV:
6784 unixmode |= S_IFCHR;
6787 #if defined(S_IFBLK)
6788 case UNIX_TYPE_BLKDEV:
6789 unixmode |= S_IFBLK;
6793 return NT_STATUS_INVALID_PARAMETER;
6796 DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev "
6797 "%.0f mode 0%o for file %s\n", (double)dev,
6798 (unsigned int)unixmode, smb_fname_str_dbg(smb_fname)));
6800 /* Ok - do the mknod. */
6801 if (SMB_VFS_MKNOD(conn, smb_fname->base_name, unixmode, dev) != 0) {
6802 return map_nt_error_from_unix(errno);
6805 /* If any of the other "set" calls fail we
6806 * don't want to end up with a half-constructed mknod.
6809 if (lp_inherit_perms(SNUM(conn))) {
6811 if (!parent_dirname(talloc_tos(), smb_fname->base_name,
6813 return NT_STATUS_NO_MEMORY;
6815 inherit_access_posix_acl(conn, parent, smb_fname->base_name,
6817 TALLOC_FREE(parent);
6820 return NT_STATUS_OK;
6823 /****************************************************************************
6824 Deal with SMB_SET_FILE_UNIX_BASIC.
6825 ****************************************************************************/
6827 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
6828 struct smb_request *req,
6832 const struct smb_filename *smb_fname)
6834 struct smb_file_time ft;
6835 uint32 raw_unixmode;
6838 uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
6839 gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
6840 NTSTATUS status = NT_STATUS_OK;
6841 bool delete_on_fail = False;
6842 enum perm_type ptype;
6843 files_struct *all_fsps = NULL;
6844 bool modify_mtime = true;
6846 struct smb_filename *smb_fname_tmp = NULL;
6847 SMB_STRUCT_STAT sbuf;
6851 if (total_data < 100) {
6852 return NT_STATUS_INVALID_PARAMETER;
6855 if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
6856 IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
6857 size=IVAL(pdata,0); /* first 8 Bytes are size */
6858 #ifdef LARGE_SMB_OFF_T
6859 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
6860 #else /* LARGE_SMB_OFF_T */
6861 if (IVAL(pdata,4) != 0) {
6862 /* more than 32 bits? */
6863 return NT_STATUS_INVALID_PARAMETER;
6865 #endif /* LARGE_SMB_OFF_T */
6868 ft.atime = interpret_long_date(pdata+24); /* access_time */
6869 ft.mtime = interpret_long_date(pdata+32); /* modification_time */
6870 set_owner = (uid_t)IVAL(pdata,40);
6871 set_grp = (gid_t)IVAL(pdata,48);
6872 raw_unixmode = IVAL(pdata,84);
6874 if (VALID_STAT(smb_fname->st)) {
6875 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
6876 ptype = PERM_EXISTING_DIR;
6878 ptype = PERM_EXISTING_FILE;
6881 ptype = PERM_NEW_FILE;
6884 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6886 if (!NT_STATUS_IS_OK(status)) {
6890 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = "
6891 "%s size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
6892 smb_fname_str_dbg(smb_fname), (double)size,
6893 (unsigned int)set_owner, (unsigned int)set_grp,
6894 (int)raw_unixmode));
6896 sbuf = smb_fname->st;
6898 if (!VALID_STAT(sbuf)) {
6900 * The only valid use of this is to create character and block
6901 * devices, and named pipes. This is deprecated (IMHO) and
6902 * a new info level should be used for mknod. JRA.
6905 status = smb_unix_mknod(conn,
6909 if (!NT_STATUS_IS_OK(status)) {
6913 status = copy_smb_filename(talloc_tos(), smb_fname,
6915 if (!NT_STATUS_IS_OK(status)) {
6919 if (SMB_VFS_STAT(conn, smb_fname_tmp) != 0) {
6920 status = map_nt_error_from_unix(errno);
6921 TALLOC_FREE(smb_fname_tmp);
6922 SMB_VFS_UNLINK(conn, smb_fname);
6926 sbuf = smb_fname_tmp->st;
6927 smb_fname = smb_fname_tmp;
6929 /* Ensure we don't try and change anything else. */
6930 raw_unixmode = SMB_MODE_NO_CHANGE;
6931 size = get_file_size_stat(&sbuf);
6932 ft.atime = sbuf.st_ex_atime;
6933 ft.mtime = sbuf.st_ex_mtime;
6935 * We continue here as we might want to change the
6938 delete_on_fail = True;
6942 /* Horrible backwards compatibility hack as an old server bug
6943 * allowed a CIFS client bug to remain unnoticed :-(. JRA.
6947 size = get_file_size_stat(&sbuf);
6952 * Deal with the UNIX specific mode set.
6955 if (raw_unixmode != SMB_MODE_NO_CHANGE) {
6956 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6957 "setting mode 0%o for file %s\n",
6958 (unsigned int)unixmode,
6959 smb_fname_str_dbg(smb_fname)));
6960 if (SMB_VFS_CHMOD(conn, smb_fname->base_name, unixmode) != 0) {
6961 return map_nt_error_from_unix(errno);
6966 * Deal with the UNIX specific uid set.
6969 if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) &&
6970 (sbuf.st_ex_uid != set_owner)) {
6973 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6974 "changing owner %u for path %s\n",
6975 (unsigned int)set_owner,
6976 smb_fname_str_dbg(smb_fname)));
6978 if (S_ISLNK(sbuf.st_ex_mode)) {
6979 ret = SMB_VFS_LCHOWN(conn, smb_fname->base_name,
6980 set_owner, (gid_t)-1);
6982 ret = SMB_VFS_CHOWN(conn, smb_fname->base_name,
6983 set_owner, (gid_t)-1);
6987 status = map_nt_error_from_unix(errno);
6988 if (delete_on_fail) {
6989 SMB_VFS_UNLINK(conn, smb_fname);
6996 * Deal with the UNIX specific gid set.
6999 if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) &&
7000 (sbuf.st_ex_gid != set_grp)) {
7001 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
7002 "changing group %u for file %s\n",
7003 (unsigned int)set_owner,
7004 smb_fname_str_dbg(smb_fname)));
7005 if (SMB_VFS_CHOWN(conn, smb_fname->base_name, (uid_t)-1,
7007 status = map_nt_error_from_unix(errno);
7008 if (delete_on_fail) {
7009 SMB_VFS_UNLINK(conn, smb_fname);
7015 /* Deal with any size changes. */
7017 status = smb_set_file_size(conn, req,
7023 if (!NT_STATUS_IS_OK(status)) {
7027 /* Deal with any time changes. */
7028 if (null_timespec(ft.mtime) && null_timespec(ft.atime)) {
7029 /* No change, don't cancel anything. */
7033 id = vfs_file_id_from_sbuf(conn, &sbuf);
7034 for(all_fsps = file_find_di_first(conn->sconn, id); all_fsps;
7035 all_fsps = file_find_di_next(all_fsps)) {
7037 * We're setting the time explicitly for UNIX.
7038 * Cancel any pending changes over all handles.
7040 all_fsps->update_write_time_on_close = false;
7041 TALLOC_FREE(all_fsps->update_write_time_event);
7045 * Override the "setting_write_time"
7046 * parameter here as it almost does what
7047 * we need. Just remember if we modified
7048 * mtime and send the notify ourselves.
7050 if (null_timespec(ft.mtime)) {
7051 modify_mtime = false;
7054 status = smb_set_file_time(conn,
7060 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
7061 FILE_NOTIFY_CHANGE_LAST_WRITE, smb_fname->base_name);
7066 /****************************************************************************
7067 Deal with SMB_SET_FILE_UNIX_INFO2.
7068 ****************************************************************************/
7070 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
7071 struct smb_request *req,
7075 const struct smb_filename *smb_fname)
7081 if (total_data < 116) {
7082 return NT_STATUS_INVALID_PARAMETER;
7085 /* Start by setting all the fields that are common between UNIX_BASIC
7088 status = smb_set_file_unix_basic(conn, req, pdata, total_data,
7090 if (!NT_STATUS_IS_OK(status)) {
7094 smb_fflags = IVAL(pdata, 108);
7095 smb_fmask = IVAL(pdata, 112);
7097 /* NB: We should only attempt to alter the file flags if the client
7098 * sends a non-zero mask.
7100 if (smb_fmask != 0) {
7101 int stat_fflags = 0;
7103 if (!map_info2_flags_to_sbuf(&smb_fname->st, smb_fflags,
7104 smb_fmask, &stat_fflags)) {
7105 /* Client asked to alter a flag we don't understand. */
7106 return NT_STATUS_INVALID_PARAMETER;
7109 if (fsp && fsp->fh->fd != -1) {
7110 /* XXX: we should be using SMB_VFS_FCHFLAGS here. */
7111 return NT_STATUS_NOT_SUPPORTED;
7113 if (SMB_VFS_CHFLAGS(conn, smb_fname->base_name,
7114 stat_fflags) != 0) {
7115 return map_nt_error_from_unix(errno);
7120 /* XXX: need to add support for changing the create_time here. You
7121 * can do this for paths on Darwin with setattrlist(2). The right way
7122 * to hook this up is probably by extending the VFS utimes interface.
7125 return NT_STATUS_OK;
7128 /****************************************************************************
7129 Create a directory with POSIX semantics.
7130 ****************************************************************************/
7132 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
7133 struct smb_request *req,
7136 struct smb_filename *smb_fname,
7137 int *pdata_return_size)
7139 NTSTATUS status = NT_STATUS_OK;
7140 uint32 raw_unixmode = 0;
7141 uint32 mod_unixmode = 0;
7142 mode_t unixmode = (mode_t)0;
7143 files_struct *fsp = NULL;
7144 uint16 info_level_return = 0;
7146 char *pdata = *ppdata;
7148 if (total_data < 18) {
7149 return NT_STATUS_INVALID_PARAMETER;
7152 raw_unixmode = IVAL(pdata,8);
7153 /* Next 4 bytes are not yet defined. */
7155 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7156 PERM_NEW_DIR, &unixmode);
7157 if (!NT_STATUS_IS_OK(status)) {
7161 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
7163 DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
7164 smb_fname_str_dbg(smb_fname), (unsigned int)unixmode));
7166 status = SMB_VFS_CREATE_FILE(
7169 0, /* root_dir_fid */
7170 smb_fname, /* fname */
7171 FILE_READ_ATTRIBUTES, /* access_mask */
7172 FILE_SHARE_NONE, /* share_access */
7173 FILE_CREATE, /* create_disposition*/
7174 FILE_DIRECTORY_FILE, /* create_options */
7175 mod_unixmode, /* file_attributes */
7176 0, /* oplock_request */
7177 0, /* allocation_size */
7178 0, /* private_flags */
7184 if (NT_STATUS_IS_OK(status)) {
7185 close_file(req, fsp, NORMAL_CLOSE);
7188 info_level_return = SVAL(pdata,16);
7190 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
7191 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
7192 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
7193 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
7195 *pdata_return_size = 12;
7198 /* Realloc the data size */
7199 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
7200 if (*ppdata == NULL) {
7201 *pdata_return_size = 0;
7202 return NT_STATUS_NO_MEMORY;
7206 SSVAL(pdata,0,NO_OPLOCK_RETURN);
7207 SSVAL(pdata,2,0); /* No fnum. */
7208 SIVAL(pdata,4,info); /* Was directory created. */
7210 switch (info_level_return) {
7211 case SMB_QUERY_FILE_UNIX_BASIC:
7212 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
7213 SSVAL(pdata,10,0); /* Padding. */
7214 store_file_unix_basic(conn, pdata + 12, fsp,
7217 case SMB_QUERY_FILE_UNIX_INFO2:
7218 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
7219 SSVAL(pdata,10,0); /* Padding. */
7220 store_file_unix_basic_info2(conn, pdata + 12, fsp,
7224 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
7225 SSVAL(pdata,10,0); /* Padding. */
7232 /****************************************************************************
7233 Open/Create a file with POSIX semantics.
7234 ****************************************************************************/
7236 #define SMB_O_RDONLY_MAPPING (FILE_READ_DATA|FILE_READ_ATTRIBUTES|FILE_READ_EA)
7237 #define SMB_O_WRONLY_MAPPING (FILE_WRITE_DATA|FILE_WRITE_ATTRIBUTES|FILE_WRITE_EA)
7239 static NTSTATUS smb_posix_open(connection_struct *conn,
7240 struct smb_request *req,
7243 struct smb_filename *smb_fname,
7244 int *pdata_return_size)
7246 bool extended_oplock_granted = False;
7247 char *pdata = *ppdata;
7249 uint32 wire_open_mode = 0;
7250 uint32 raw_unixmode = 0;
7251 uint32 mod_unixmode = 0;
7252 uint32 create_disp = 0;
7253 uint32 access_mask = 0;
7254 uint32 create_options = FILE_NON_DIRECTORY_FILE;
7255 NTSTATUS status = NT_STATUS_OK;
7256 mode_t unixmode = (mode_t)0;
7257 files_struct *fsp = NULL;
7258 int oplock_request = 0;
7260 uint16 info_level_return = 0;
7262 if (total_data < 18) {
7263 return NT_STATUS_INVALID_PARAMETER;
7266 flags = IVAL(pdata,0);
7267 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
7268 if (oplock_request) {
7269 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
7272 wire_open_mode = IVAL(pdata,4);
7274 if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
7275 return smb_posix_mkdir(conn, req,
7282 switch (wire_open_mode & SMB_ACCMODE) {
7284 access_mask = SMB_O_RDONLY_MAPPING;
7287 access_mask = SMB_O_WRONLY_MAPPING;
7290 access_mask = (SMB_O_RDONLY_MAPPING|
7291 SMB_O_WRONLY_MAPPING);
7294 DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
7295 (unsigned int)wire_open_mode ));
7296 return NT_STATUS_INVALID_PARAMETER;
7299 wire_open_mode &= ~SMB_ACCMODE;
7301 /* First take care of O_CREAT|O_EXCL interactions. */
7302 switch (wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) {
7303 case (SMB_O_CREAT | SMB_O_EXCL):
7304 /* File exists fail. File not exist create. */
7305 create_disp = FILE_CREATE;
7308 /* File exists open. File not exist create. */
7309 create_disp = FILE_OPEN_IF;
7312 /* File exists open. File not exist fail. */
7313 create_disp = FILE_OPEN;
7316 /* O_EXCL on its own without O_CREAT is undefined. */
7318 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
7319 (unsigned int)wire_open_mode ));
7320 return NT_STATUS_INVALID_PARAMETER;
7323 /* Next factor in the effects of O_TRUNC. */
7324 wire_open_mode &= ~(SMB_O_CREAT | SMB_O_EXCL);
7326 if (wire_open_mode & SMB_O_TRUNC) {
7327 switch (create_disp) {
7329 /* (SMB_O_CREAT | SMB_O_EXCL | O_TRUNC) */
7330 /* Leave create_disp alone as
7331 (O_CREAT|O_EXCL|O_TRUNC) == (O_CREAT|O_EXCL)
7333 /* File exists fail. File not exist create. */
7336 /* SMB_O_CREAT | SMB_O_TRUNC */
7337 /* File exists overwrite. File not exist create. */
7338 create_disp = FILE_OVERWRITE_IF;
7342 /* File exists overwrite. File not exist fail. */
7343 create_disp = FILE_OVERWRITE;
7346 /* Cannot get here. */
7347 smb_panic("smb_posix_open: logic error");
7348 return NT_STATUS_INVALID_PARAMETER;
7352 raw_unixmode = IVAL(pdata,8);
7353 /* Next 4 bytes are not yet defined. */
7355 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7356 (VALID_STAT(smb_fname->st) ?
7357 PERM_EXISTING_FILE : PERM_NEW_FILE),
7360 if (!NT_STATUS_IS_OK(status)) {
7364 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
7366 if (wire_open_mode & SMB_O_SYNC) {
7367 create_options |= FILE_WRITE_THROUGH;
7369 if (wire_open_mode & SMB_O_APPEND) {
7370 access_mask |= FILE_APPEND_DATA;
7372 if (wire_open_mode & SMB_O_DIRECT) {
7373 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
7376 if ((wire_open_mode & SMB_O_DIRECTORY) ||
7377 VALID_STAT_OF_DIR(smb_fname->st)) {
7378 if (access_mask != SMB_O_RDONLY_MAPPING) {
7379 return NT_STATUS_FILE_IS_A_DIRECTORY;
7381 create_options &= ~FILE_NON_DIRECTORY_FILE;
7382 create_options |= FILE_DIRECTORY_FILE;
7385 DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
7386 smb_fname_str_dbg(smb_fname),
7387 (unsigned int)wire_open_mode,
7388 (unsigned int)unixmode ));
7390 status = SMB_VFS_CREATE_FILE(
7393 0, /* root_dir_fid */
7394 smb_fname, /* fname */
7395 access_mask, /* access_mask */
7396 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7398 create_disp, /* create_disposition*/
7399 create_options, /* create_options */
7400 mod_unixmode, /* file_attributes */
7401 oplock_request, /* oplock_request */
7402 0, /* allocation_size */
7403 0, /* private_flags */
7409 if (!NT_STATUS_IS_OK(status)) {
7413 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
7414 extended_oplock_granted = True;
7417 if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
7418 extended_oplock_granted = True;
7421 info_level_return = SVAL(pdata,16);
7423 /* Allocate the correct return size. */
7425 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
7426 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
7427 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
7428 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
7430 *pdata_return_size = 12;
7433 /* Realloc the data size */
7434 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
7435 if (*ppdata == NULL) {
7436 close_file(req, fsp, ERROR_CLOSE);
7437 *pdata_return_size = 0;
7438 return NT_STATUS_NO_MEMORY;
7442 if (extended_oplock_granted) {
7443 if (flags & REQUEST_BATCH_OPLOCK) {
7444 SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
7446 SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
7448 } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
7449 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
7451 SSVAL(pdata,0,NO_OPLOCK_RETURN);
7454 SSVAL(pdata,2,fsp->fnum);
7455 SIVAL(pdata,4,info); /* Was file created etc. */
7457 switch (info_level_return) {
7458 case SMB_QUERY_FILE_UNIX_BASIC:
7459 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
7460 SSVAL(pdata,10,0); /* padding. */
7461 store_file_unix_basic(conn, pdata + 12, fsp,
7464 case SMB_QUERY_FILE_UNIX_INFO2:
7465 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
7466 SSVAL(pdata,10,0); /* padding. */
7467 store_file_unix_basic_info2(conn, pdata + 12, fsp,
7471 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
7472 SSVAL(pdata,10,0); /* padding. */
7475 return NT_STATUS_OK;
7478 /****************************************************************************
7479 Delete a file with POSIX semantics.
7480 ****************************************************************************/
7482 static NTSTATUS smb_posix_unlink(connection_struct *conn,
7483 struct smb_request *req,
7486 struct smb_filename *smb_fname)
7488 NTSTATUS status = NT_STATUS_OK;
7489 files_struct *fsp = NULL;
7493 int create_options = 0;
7495 struct share_mode_lock *lck = NULL;
7497 if (total_data < 2) {
7498 return NT_STATUS_INVALID_PARAMETER;
7501 flags = SVAL(pdata,0);
7503 if (!VALID_STAT(smb_fname->st)) {
7504 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
7507 if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
7508 !VALID_STAT_OF_DIR(smb_fname->st)) {
7509 return NT_STATUS_NOT_A_DIRECTORY;
7512 DEBUG(10,("smb_posix_unlink: %s %s\n",
7513 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
7514 smb_fname_str_dbg(smb_fname)));
7516 if (VALID_STAT_OF_DIR(smb_fname->st)) {
7517 create_options |= FILE_DIRECTORY_FILE;
7520 status = SMB_VFS_CREATE_FILE(
7523 0, /* root_dir_fid */
7524 smb_fname, /* fname */
7525 DELETE_ACCESS, /* access_mask */
7526 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7528 FILE_OPEN, /* create_disposition*/
7529 create_options, /* create_options */
7530 FILE_FLAG_POSIX_SEMANTICS|0777, /* file_attributes */
7531 0, /* oplock_request */
7532 0, /* allocation_size */
7533 0, /* private_flags */
7539 if (!NT_STATUS_IS_OK(status)) {
7544 * Don't lie to client. If we can't really delete due to
7545 * non-POSIX opens return SHARING_VIOLATION.
7548 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
7551 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
7552 "lock for file %s\n", fsp_str_dbg(fsp)));
7553 close_file(req, fsp, NORMAL_CLOSE);
7554 return NT_STATUS_INVALID_PARAMETER;
7558 * See if others still have the file open. If this is the case, then
7559 * don't delete. If all opens are POSIX delete we can set the delete
7560 * on close disposition.
7562 for (i=0; i<lck->num_share_modes; i++) {
7563 struct share_mode_entry *e = &lck->share_modes[i];
7564 if (is_valid_share_mode_entry(e)) {
7565 if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
7568 /* Fail with sharing violation. */
7569 close_file(req, fsp, NORMAL_CLOSE);
7571 return NT_STATUS_SHARING_VIOLATION;
7576 * Set the delete on close.
7578 status = smb_set_file_disposition_info(conn,
7584 if (!NT_STATUS_IS_OK(status)) {
7585 close_file(req, fsp, NORMAL_CLOSE);
7590 return close_file(req, fsp, NORMAL_CLOSE);
7593 NTSTATUS smbd_do_setfilepathinfo(connection_struct *conn,
7594 struct smb_request *req,
7595 TALLOC_CTX *mem_ctx,
7596 uint16_t info_level,
7598 struct smb_filename *smb_fname,
7599 char **ppdata, int total_data,
7602 char *pdata = *ppdata;
7603 NTSTATUS status = NT_STATUS_OK;
7604 int data_return_size = 0;
7608 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
7609 return NT_STATUS_INVALID_LEVEL;
7612 if (!CAN_WRITE(conn)) {
7613 /* Allow POSIX opens. The open path will deny
7614 * any non-readonly opens. */
7615 if (info_level != SMB_POSIX_PATH_OPEN) {
7616 return NT_STATUS_DOS(ERRSRV, ERRaccess);
7620 DEBUG(3,("smbd_do_setfilepathinfo: %s (fnum %d) info_level=%d "
7621 "totdata=%d\n", smb_fname_str_dbg(smb_fname),
7622 fsp ? fsp->fnum : -1, info_level, total_data));
7624 switch (info_level) {
7626 case SMB_INFO_STANDARD:
7628 status = smb_set_info_standard(conn,
7636 case SMB_INFO_SET_EA:
7638 status = smb_info_set_ea(conn,
7646 case SMB_SET_FILE_BASIC_INFO:
7647 case SMB_FILE_BASIC_INFORMATION:
7649 status = smb_set_file_basic_info(conn,
7657 case SMB_FILE_ALLOCATION_INFORMATION:
7658 case SMB_SET_FILE_ALLOCATION_INFO:
7660 status = smb_set_file_allocation_info(conn, req,
7668 case SMB_FILE_END_OF_FILE_INFORMATION:
7669 case SMB_SET_FILE_END_OF_FILE_INFO:
7672 * XP/Win7 both fail after the createfile with
7673 * SMB_SET_FILE_END_OF_FILE_INFO but not
7674 * SMB_FILE_END_OF_FILE_INFORMATION (pass-through).
7675 * The level is known here, so pass it down
7679 (info_level == SMB_SET_FILE_END_OF_FILE_INFO);
7681 status = smb_set_file_end_of_file_info(conn, req,
7690 case SMB_FILE_DISPOSITION_INFORMATION:
7691 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
7694 /* JRA - We used to just ignore this on a path ?
7695 * Shouldn't this be invalid level on a pathname
7698 if (tran_call != TRANSACT2_SETFILEINFO) {
7699 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
7702 status = smb_set_file_disposition_info(conn,
7710 case SMB_FILE_POSITION_INFORMATION:
7712 status = smb_file_position_information(conn,
7719 case SMB_FILE_FULL_EA_INFORMATION:
7721 status = smb_set_file_full_ea_info(conn,
7728 /* From tridge Samba4 :
7729 * MODE_INFORMATION in setfileinfo (I have no
7730 * idea what "mode information" on a file is - it takes a value of 0,
7731 * 2, 4 or 6. What could it be?).
7734 case SMB_FILE_MODE_INFORMATION:
7736 status = smb_file_mode_information(conn,
7743 * CIFS UNIX extensions.
7746 case SMB_SET_FILE_UNIX_BASIC:
7748 status = smb_set_file_unix_basic(conn, req,
7756 case SMB_SET_FILE_UNIX_INFO2:
7758 status = smb_set_file_unix_info2(conn, req,
7766 case SMB_SET_FILE_UNIX_LINK:
7769 /* We must have a pathname for this. */
7770 return NT_STATUS_INVALID_LEVEL;
7772 status = smb_set_file_unix_link(conn, req, pdata,
7773 total_data, smb_fname);
7777 case SMB_SET_FILE_UNIX_HLINK:
7780 /* We must have a pathname for this. */
7781 return NT_STATUS_INVALID_LEVEL;
7783 status = smb_set_file_unix_hlink(conn, req,
7789 case SMB_FILE_RENAME_INFORMATION:
7791 status = smb_file_rename_information(conn, req,
7797 case SMB2_FILE_RENAME_INFORMATION_INTERNAL:
7799 /* SMB2 rename information. */
7800 status = smb2_file_rename_information(conn, req,
7806 case SMB_FILE_LINK_INFORMATION:
7808 status = smb_file_link_information(conn, req,
7814 #if defined(HAVE_POSIX_ACLS)
7815 case SMB_SET_POSIX_ACL:
7817 status = smb_set_posix_acl(conn,
7826 case SMB_SET_POSIX_LOCK:
7829 return NT_STATUS_INVALID_LEVEL;
7831 status = smb_set_posix_lock(conn, req,
7832 pdata, total_data, fsp);
7836 case SMB_POSIX_PATH_OPEN:
7839 /* We must have a pathname for this. */
7840 return NT_STATUS_INVALID_LEVEL;
7843 status = smb_posix_open(conn, req,
7851 case SMB_POSIX_PATH_UNLINK:
7854 /* We must have a pathname for this. */
7855 return NT_STATUS_INVALID_LEVEL;
7858 status = smb_posix_unlink(conn, req,
7866 return NT_STATUS_INVALID_LEVEL;
7869 if (!NT_STATUS_IS_OK(status)) {
7873 *ret_data_size = data_return_size;
7874 return NT_STATUS_OK;
7877 /****************************************************************************
7878 Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
7879 ****************************************************************************/
7881 static void call_trans2setfilepathinfo(connection_struct *conn,
7882 struct smb_request *req,
7883 unsigned int tran_call,
7884 char **pparams, int total_params,
7885 char **ppdata, int total_data,
7886 unsigned int max_data_bytes)
7888 char *params = *pparams;
7889 char *pdata = *ppdata;
7891 struct smb_filename *smb_fname = NULL;
7892 files_struct *fsp = NULL;
7893 NTSTATUS status = NT_STATUS_OK;
7894 int data_return_size = 0;
7897 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7901 if (tran_call == TRANSACT2_SETFILEINFO) {
7902 if (total_params < 4) {
7903 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7907 fsp = file_fsp(req, SVAL(params,0));
7908 /* Basic check for non-null fsp. */
7909 if (!check_fsp_open(conn, req, fsp)) {
7912 info_level = SVAL(params,2);
7914 status = copy_smb_filename(talloc_tos(), fsp->fsp_name,
7916 if (!NT_STATUS_IS_OK(status)) {
7917 reply_nterror(req, status);
7921 if(fsp->fh->fd == -1) {
7923 * This is actually a SETFILEINFO on a directory
7924 * handle (returned from an NT SMB). NT5.0 seems
7925 * to do this call. JRA.
7927 if (INFO_LEVEL_IS_UNIX(info_level)) {
7928 /* Always do lstat for UNIX calls. */
7929 if (SMB_VFS_LSTAT(conn, smb_fname)) {
7930 DEBUG(3,("call_trans2setfilepathinfo: "
7931 "SMB_VFS_LSTAT of %s failed "
7933 smb_fname_str_dbg(smb_fname),
7935 reply_nterror(req, map_nt_error_from_unix(errno));
7939 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
7940 DEBUG(3,("call_trans2setfilepathinfo: "
7941 "fileinfo of %s failed (%s)\n",
7942 smb_fname_str_dbg(smb_fname),
7944 reply_nterror(req, map_nt_error_from_unix(errno));
7948 } else if (fsp->print_file) {
7950 * Doing a DELETE_ON_CLOSE should cancel a print job.
7952 if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
7953 fsp->fh->private_options |= NTCREATEX_OPTIONS_PRIVATE_DELETE_ON_CLOSE;
7955 DEBUG(3,("call_trans2setfilepathinfo: "
7956 "Cancelling print job (%s)\n",
7960 send_trans2_replies(conn, req, params, 2,
7966 NT_STATUS_OBJECT_PATH_NOT_FOUND);
7971 * Original code - this is an open file.
7973 if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
7974 DEBUG(3,("call_trans2setfilepathinfo: fstat "
7975 "of fnum %d failed (%s)\n", fsp->fnum,
7977 reply_nterror(req, map_nt_error_from_unix(errno));
7985 if (total_params < 7) {
7986 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7990 info_level = SVAL(params,0);
7991 srvstr_get_path(req, params, req->flags2, &fname, ¶ms[6],
7992 total_params - 6, STR_TERMINATE,
7994 if (!NT_STATUS_IS_OK(status)) {
7995 reply_nterror(req, status);
7999 status = filename_convert(req, conn,
8000 req->flags2 & FLAGS2_DFS_PATHNAMES,
8005 if (!NT_STATUS_IS_OK(status)) {
8006 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8007 reply_botherror(req,
8008 NT_STATUS_PATH_NOT_COVERED,
8009 ERRSRV, ERRbadpath);
8012 reply_nterror(req, status);
8016 if (INFO_LEVEL_IS_UNIX(info_level)) {
8018 * For CIFS UNIX extensions the target name may not exist.
8021 /* Always do lstat for UNIX calls. */
8022 SMB_VFS_LSTAT(conn, smb_fname);
8024 } else if (!VALID_STAT(smb_fname->st) &&
8025 SMB_VFS_STAT(conn, smb_fname)) {
8026 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of "
8028 smb_fname_str_dbg(smb_fname),
8030 reply_nterror(req, map_nt_error_from_unix(errno));
8035 DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d "
8036 "totdata=%d\n", tran_call, smb_fname_str_dbg(smb_fname),
8037 fsp ? fsp->fnum : -1, info_level,total_data));
8039 /* Realloc the parameter size */
8040 *pparams = (char *)SMB_REALLOC(*pparams,2);
8041 if (*pparams == NULL) {
8042 reply_nterror(req, NT_STATUS_NO_MEMORY);
8049 status = smbd_do_setfilepathinfo(conn, req, req,
8055 if (!NT_STATUS_IS_OK(status)) {
8056 if (open_was_deferred(req->sconn, req->mid)) {
8057 /* We have re-scheduled this call. */
8060 if (blocking_lock_was_deferred_smb1(req->sconn, req->mid)) {
8061 /* We have re-scheduled this call. */
8064 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8065 reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
8066 ERRSRV, ERRbadpath);
8069 if (info_level == SMB_POSIX_PATH_OPEN) {
8070 reply_openerror(req, status);
8074 reply_nterror(req, status);
8078 send_trans2_replies(conn, req, params, 2, *ppdata, data_return_size,
8084 /****************************************************************************
8085 Reply to a TRANS2_MKDIR (make directory with extended attributes).
8086 ****************************************************************************/
8088 static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
8089 char **pparams, int total_params,
8090 char **ppdata, int total_data,
8091 unsigned int max_data_bytes)
8093 struct smb_filename *smb_dname = NULL;
8094 char *params = *pparams;
8095 char *pdata = *ppdata;
8096 char *directory = NULL;
8097 NTSTATUS status = NT_STATUS_OK;
8098 struct ea_list *ea_list = NULL;
8099 TALLOC_CTX *ctx = talloc_tos();
8101 if (!CAN_WRITE(conn)) {
8102 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8106 if (total_params < 5) {
8107 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8111 srvstr_get_path(ctx, params, req->flags2, &directory, ¶ms[4],
8112 total_params - 4, STR_TERMINATE,
8114 if (!NT_STATUS_IS_OK(status)) {
8115 reply_nterror(req, status);
8119 DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
8121 status = filename_convert(ctx,
8123 req->flags2 & FLAGS2_DFS_PATHNAMES,
8129 if (!NT_STATUS_IS_OK(status)) {
8130 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
8131 reply_botherror(req,
8132 NT_STATUS_PATH_NOT_COVERED,
8133 ERRSRV, ERRbadpath);
8136 reply_nterror(req, status);
8141 * OS/2 workplace shell seems to send SET_EA requests of "null"
8142 * length (4 bytes containing IVAL 4).
8143 * They seem to have no effect. Bug #3212. JRA.
8146 if (total_data && (total_data != 4)) {
8147 /* Any data in this call is an EA list. */
8148 if (total_data < 10) {
8149 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8153 if (IVAL(pdata,0) > total_data) {
8154 DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
8155 IVAL(pdata,0), (unsigned int)total_data));
8156 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8160 ea_list = read_ea_list(talloc_tos(), pdata + 4,
8163 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8167 if (!lp_ea_support(SNUM(conn))) {
8168 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
8172 /* If total_data == 4 Windows doesn't care what values
8173 * are placed in that field, it just ignores them.
8174 * The System i QNTC IBM SMB client puts bad values here,
8175 * so ignore them. */
8177 status = create_directory(conn, req, smb_dname);
8179 if (!NT_STATUS_IS_OK(status)) {
8180 reply_nterror(req, status);
8184 /* Try and set any given EA. */
8186 status = set_ea(conn, NULL, smb_dname, ea_list);
8187 if (!NT_STATUS_IS_OK(status)) {
8188 reply_nterror(req, status);
8193 /* Realloc the parameter and data sizes */
8194 *pparams = (char *)SMB_REALLOC(*pparams,2);
8195 if(*pparams == NULL) {
8196 reply_nterror(req, NT_STATUS_NO_MEMORY);
8203 send_trans2_replies(conn, req, params, 2, *ppdata, 0, max_data_bytes);
8206 TALLOC_FREE(smb_dname);
8210 /****************************************************************************
8211 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
8212 We don't actually do this - we just send a null response.
8213 ****************************************************************************/
8215 static void call_trans2findnotifyfirst(connection_struct *conn,
8216 struct smb_request *req,
8217 char **pparams, int total_params,
8218 char **ppdata, int total_data,
8219 unsigned int max_data_bytes)
8221 char *params = *pparams;
8224 if (total_params < 6) {
8225 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8229 info_level = SVAL(params,4);
8230 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
8232 switch (info_level) {
8237 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
8241 /* Realloc the parameter and data sizes */
8242 *pparams = (char *)SMB_REALLOC(*pparams,6);
8243 if (*pparams == NULL) {
8244 reply_nterror(req, NT_STATUS_NO_MEMORY);
8249 SSVAL(params,0,fnf_handle);
8250 SSVAL(params,2,0); /* No changes */
8251 SSVAL(params,4,0); /* No EA errors */
8258 send_trans2_replies(conn, req, params, 6, *ppdata, 0, max_data_bytes);
8263 /****************************************************************************
8264 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
8265 changes). Currently this does nothing.
8266 ****************************************************************************/
8268 static void call_trans2findnotifynext(connection_struct *conn,
8269 struct smb_request *req,
8270 char **pparams, int total_params,
8271 char **ppdata, int total_data,
8272 unsigned int max_data_bytes)
8274 char *params = *pparams;
8276 DEBUG(3,("call_trans2findnotifynext\n"));
8278 /* Realloc the parameter and data sizes */
8279 *pparams = (char *)SMB_REALLOC(*pparams,4);
8280 if (*pparams == NULL) {
8281 reply_nterror(req, NT_STATUS_NO_MEMORY);
8286 SSVAL(params,0,0); /* No changes */
8287 SSVAL(params,2,0); /* No EA errors */
8289 send_trans2_replies(conn, req, params, 4, *ppdata, 0, max_data_bytes);
8294 /****************************************************************************
8295 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
8296 ****************************************************************************/
8298 static void call_trans2getdfsreferral(connection_struct *conn,
8299 struct smb_request *req,
8300 char **pparams, int total_params,
8301 char **ppdata, int total_data,
8302 unsigned int max_data_bytes)
8304 char *params = *pparams;
8305 char *pathname = NULL;
8307 int max_referral_level;
8308 NTSTATUS status = NT_STATUS_OK;
8309 TALLOC_CTX *ctx = talloc_tos();
8311 DEBUG(10,("call_trans2getdfsreferral\n"));
8313 if (total_params < 3) {
8314 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8318 max_referral_level = SVAL(params,0);
8320 if(!lp_host_msdfs()) {
8321 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
8325 srvstr_pull_talloc(ctx, params, req->flags2, &pathname, ¶ms[2],
8326 total_params - 2, STR_TERMINATE);
8328 reply_nterror(req, NT_STATUS_NOT_FOUND);
8331 if((reply_size = setup_dfs_referral(conn, pathname, max_referral_level,
8332 ppdata,&status)) < 0) {
8333 reply_nterror(req, status);
8337 SSVAL((discard_const_p(uint8_t, req->inbuf)), smb_flg2,
8338 SVAL(req->inbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
8339 send_trans2_replies(conn, req,0,0,*ppdata,reply_size, max_data_bytes);
8344 #define LMCAT_SPL 0x53
8345 #define LMFUNC_GETJOBID 0x60
8347 /****************************************************************************
8348 Reply to a TRANS2_IOCTL - used for OS/2 printing.
8349 ****************************************************************************/
8351 static void call_trans2ioctl(connection_struct *conn,
8352 struct smb_request *req,
8353 char **pparams, int total_params,
8354 char **ppdata, int total_data,
8355 unsigned int max_data_bytes)
8357 char *pdata = *ppdata;
8358 files_struct *fsp = file_fsp(req, SVAL(req->vwv+15, 0));
8360 /* check for an invalid fid before proceeding */
8363 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
8367 if ((SVAL(req->vwv+16, 0) == LMCAT_SPL)
8368 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
8369 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
8370 if (*ppdata == NULL) {
8371 reply_nterror(req, NT_STATUS_NO_MEMORY);
8376 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
8377 CAN ACCEPT THIS IN UNICODE. JRA. */
8380 if (fsp->print_file) {
8381 SSVAL(pdata, 0, fsp->print_file->rap_jobid);
8385 srvstr_push(pdata, req->flags2, pdata + 2,
8386 lp_netbios_name(), 15,
8387 STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
8388 srvstr_push(pdata, req->flags2, pdata+18,
8389 lp_servicename(SNUM(conn)), 13,
8390 STR_ASCII|STR_TERMINATE); /* Service name */
8391 send_trans2_replies(conn, req, *pparams, 0, *ppdata, 32,
8396 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
8397 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
8400 /****************************************************************************
8401 Reply to a SMBfindclose (stop trans2 directory search).
8402 ****************************************************************************/
8404 void reply_findclose(struct smb_request *req)
8407 struct smbd_server_connection *sconn = req->sconn;
8409 START_PROFILE(SMBfindclose);
8412 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8413 END_PROFILE(SMBfindclose);
8417 dptr_num = SVALS(req->vwv+0, 0);
8419 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
8421 dptr_close(sconn, &dptr_num);
8423 reply_outbuf(req, 0, 0);
8425 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
8427 END_PROFILE(SMBfindclose);
8431 /****************************************************************************
8432 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
8433 ****************************************************************************/
8435 void reply_findnclose(struct smb_request *req)
8439 START_PROFILE(SMBfindnclose);
8442 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8443 END_PROFILE(SMBfindnclose);
8447 dptr_num = SVAL(req->vwv+0, 0);
8449 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
8451 /* We never give out valid handles for a
8452 findnotifyfirst - so any dptr_num is ok here.
8455 reply_outbuf(req, 0, 0);
8457 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
8459 END_PROFILE(SMBfindnclose);
8463 static void handle_trans2(connection_struct *conn, struct smb_request *req,
8464 struct trans_state *state)
8466 if (get_Protocol() >= PROTOCOL_NT1) {
8467 req->flags2 |= 0x40; /* IS_LONG_NAME */
8468 SSVAL((discard_const_p(uint8_t, req->inbuf)),smb_flg2,req->flags2);
8471 if (conn->encrypt_level == Required && !req->encrypted) {
8472 if (state->call != TRANSACT2_QFSINFO &&
8473 state->call != TRANSACT2_SETFSINFO) {
8474 DEBUG(0,("handle_trans2: encryption required "
8476 (unsigned int)state->call));
8477 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8482 SMB_PERFCOUNT_SET_SUBOP(&req->pcd, state->call);
8484 /* Now we must call the relevant TRANS2 function */
8485 switch(state->call) {
8486 case TRANSACT2_OPEN:
8488 START_PROFILE(Trans2_open);
8489 call_trans2open(conn, req,
8490 &state->param, state->total_param,
8491 &state->data, state->total_data,
8492 state->max_data_return);
8493 END_PROFILE(Trans2_open);
8497 case TRANSACT2_FINDFIRST:
8499 START_PROFILE(Trans2_findfirst);
8500 call_trans2findfirst(conn, req,
8501 &state->param, state->total_param,
8502 &state->data, state->total_data,
8503 state->max_data_return);
8504 END_PROFILE(Trans2_findfirst);
8508 case TRANSACT2_FINDNEXT:
8510 START_PROFILE(Trans2_findnext);
8511 call_trans2findnext(conn, req,
8512 &state->param, state->total_param,
8513 &state->data, state->total_data,
8514 state->max_data_return);
8515 END_PROFILE(Trans2_findnext);
8519 case TRANSACT2_QFSINFO:
8521 START_PROFILE(Trans2_qfsinfo);
8522 call_trans2qfsinfo(conn, req,
8523 &state->param, state->total_param,
8524 &state->data, state->total_data,
8525 state->max_data_return);
8526 END_PROFILE(Trans2_qfsinfo);
8530 case TRANSACT2_SETFSINFO:
8532 START_PROFILE(Trans2_setfsinfo);
8533 call_trans2setfsinfo(conn, req,
8534 &state->param, state->total_param,
8535 &state->data, state->total_data,
8536 state->max_data_return);
8537 END_PROFILE(Trans2_setfsinfo);
8541 case TRANSACT2_QPATHINFO:
8542 case TRANSACT2_QFILEINFO:
8544 START_PROFILE(Trans2_qpathinfo);
8545 call_trans2qfilepathinfo(conn, req, state->call,
8546 &state->param, state->total_param,
8547 &state->data, state->total_data,
8548 state->max_data_return);
8549 END_PROFILE(Trans2_qpathinfo);
8553 case TRANSACT2_SETPATHINFO:
8554 case TRANSACT2_SETFILEINFO:
8556 START_PROFILE(Trans2_setpathinfo);
8557 call_trans2setfilepathinfo(conn, req, state->call,
8558 &state->param, state->total_param,
8559 &state->data, state->total_data,
8560 state->max_data_return);
8561 END_PROFILE(Trans2_setpathinfo);
8565 case TRANSACT2_FINDNOTIFYFIRST:
8567 START_PROFILE(Trans2_findnotifyfirst);
8568 call_trans2findnotifyfirst(conn, req,
8569 &state->param, state->total_param,
8570 &state->data, state->total_data,
8571 state->max_data_return);
8572 END_PROFILE(Trans2_findnotifyfirst);
8576 case TRANSACT2_FINDNOTIFYNEXT:
8578 START_PROFILE(Trans2_findnotifynext);
8579 call_trans2findnotifynext(conn, req,
8580 &state->param, state->total_param,
8581 &state->data, state->total_data,
8582 state->max_data_return);
8583 END_PROFILE(Trans2_findnotifynext);
8587 case TRANSACT2_MKDIR:
8589 START_PROFILE(Trans2_mkdir);
8590 call_trans2mkdir(conn, req,
8591 &state->param, state->total_param,
8592 &state->data, state->total_data,
8593 state->max_data_return);
8594 END_PROFILE(Trans2_mkdir);
8598 case TRANSACT2_GET_DFS_REFERRAL:
8600 START_PROFILE(Trans2_get_dfs_referral);
8601 call_trans2getdfsreferral(conn, req,
8602 &state->param, state->total_param,
8603 &state->data, state->total_data,
8604 state->max_data_return);
8605 END_PROFILE(Trans2_get_dfs_referral);
8609 case TRANSACT2_IOCTL:
8611 START_PROFILE(Trans2_ioctl);
8612 call_trans2ioctl(conn, req,
8613 &state->param, state->total_param,
8614 &state->data, state->total_data,
8615 state->max_data_return);
8616 END_PROFILE(Trans2_ioctl);
8621 /* Error in request */
8622 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
8623 reply_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
8627 /****************************************************************************
8628 Reply to a SMBtrans2.
8629 ****************************************************************************/
8631 void reply_trans2(struct smb_request *req)
8633 connection_struct *conn = req->conn;
8638 unsigned int tran_call;
8639 struct trans_state *state;
8642 START_PROFILE(SMBtrans2);
8644 if (req->wct < 14) {
8645 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8646 END_PROFILE(SMBtrans2);
8650 dsoff = SVAL(req->vwv+12, 0);
8651 dscnt = SVAL(req->vwv+11, 0);
8652 psoff = SVAL(req->vwv+10, 0);
8653 pscnt = SVAL(req->vwv+9, 0);
8654 tran_call = SVAL(req->vwv+14, 0);
8656 result = allow_new_trans(conn->pending_trans, req->mid);
8657 if (!NT_STATUS_IS_OK(result)) {
8658 DEBUG(2, ("Got invalid trans2 request: %s\n",
8659 nt_errstr(result)));
8660 reply_nterror(req, result);
8661 END_PROFILE(SMBtrans2);
8666 switch (tran_call) {
8667 /* List the allowed trans2 calls on IPC$ */
8668 case TRANSACT2_OPEN:
8669 case TRANSACT2_GET_DFS_REFERRAL:
8670 case TRANSACT2_QFILEINFO:
8671 case TRANSACT2_QFSINFO:
8672 case TRANSACT2_SETFSINFO:
8675 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8676 END_PROFILE(SMBtrans2);
8681 if ((state = talloc(conn, struct trans_state)) == NULL) {
8682 DEBUG(0, ("talloc failed\n"));
8683 reply_nterror(req, NT_STATUS_NO_MEMORY);
8684 END_PROFILE(SMBtrans2);
8688 state->cmd = SMBtrans2;
8690 state->mid = req->mid;
8691 state->vuid = req->vuid;
8692 state->setup_count = SVAL(req->vwv+13, 0);
8693 state->setup = NULL;
8694 state->total_param = SVAL(req->vwv+0, 0);
8695 state->param = NULL;
8696 state->total_data = SVAL(req->vwv+1, 0);
8698 state->max_param_return = SVAL(req->vwv+2, 0);
8699 state->max_data_return = SVAL(req->vwv+3, 0);
8700 state->max_setup_return = SVAL(req->vwv+4, 0);
8701 state->close_on_completion = BITSETW(req->vwv+5, 0);
8702 state->one_way = BITSETW(req->vwv+5, 1);
8704 state->call = tran_call;
8706 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
8707 is so as a sanity check */
8708 if (state->setup_count != 1) {
8710 * Need to have rc=0 for ioctl to get job id for OS/2.
8711 * Network printing will fail if function is not successful.
8712 * Similar function in reply.c will be used if protocol
8713 * is LANMAN1.0 instead of LM1.2X002.
8714 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
8715 * outbuf doesn't have to be set(only job id is used).
8717 if ( (state->setup_count == 4)
8718 && (tran_call == TRANSACT2_IOCTL)
8719 && (SVAL(req->vwv+16, 0) == LMCAT_SPL)
8720 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
8721 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
8723 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
8724 DEBUG(2,("Transaction is %d\n",tran_call));
8726 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8727 END_PROFILE(SMBtrans2);
8732 if ((dscnt > state->total_data) || (pscnt > state->total_param))
8735 if (state->total_data) {
8737 if (trans_oob(state->total_data, 0, dscnt)
8738 || trans_oob(smb_len(req->inbuf), dsoff, dscnt)) {
8742 /* Can't use talloc here, the core routines do realloc on the
8743 * params and data. */
8744 state->data = (char *)SMB_MALLOC(state->total_data);
8745 if (state->data == NULL) {
8746 DEBUG(0,("reply_trans2: data malloc fail for %u "
8747 "bytes !\n", (unsigned int)state->total_data));
8749 reply_nterror(req, NT_STATUS_NO_MEMORY);
8750 END_PROFILE(SMBtrans2);
8754 memcpy(state->data,smb_base(req->inbuf)+dsoff,dscnt);
8757 if (state->total_param) {
8759 if (trans_oob(state->total_param, 0, pscnt)
8760 || trans_oob(smb_len(req->inbuf), psoff, pscnt)) {
8764 /* Can't use talloc here, the core routines do realloc on the
8765 * params and data. */
8766 state->param = (char *)SMB_MALLOC(state->total_param);
8767 if (state->param == NULL) {
8768 DEBUG(0,("reply_trans: param malloc fail for %u "
8769 "bytes !\n", (unsigned int)state->total_param));
8770 SAFE_FREE(state->data);
8772 reply_nterror(req, NT_STATUS_NO_MEMORY);
8773 END_PROFILE(SMBtrans2);
8777 memcpy(state->param,smb_base(req->inbuf)+psoff,pscnt);
8780 state->received_data = dscnt;
8781 state->received_param = pscnt;
8783 if ((state->received_param == state->total_param) &&
8784 (state->received_data == state->total_data)) {
8786 handle_trans2(conn, req, state);
8788 SAFE_FREE(state->data);
8789 SAFE_FREE(state->param);
8791 END_PROFILE(SMBtrans2);
8795 DLIST_ADD(conn->pending_trans, state);
8797 /* We need to send an interim response then receive the rest
8798 of the parameter/data bytes */
8799 reply_outbuf(req, 0, 0);
8800 show_msg((char *)req->outbuf);
8801 END_PROFILE(SMBtrans2);
8806 DEBUG(0,("reply_trans2: invalid trans parameters\n"));
8807 SAFE_FREE(state->data);
8808 SAFE_FREE(state->param);
8810 END_PROFILE(SMBtrans2);
8811 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8815 /****************************************************************************
8816 Reply to a SMBtranss2
8817 ****************************************************************************/
8819 void reply_transs2(struct smb_request *req)
8821 connection_struct *conn = req->conn;
8822 unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
8823 struct trans_state *state;
8825 START_PROFILE(SMBtranss2);
8827 show_msg((const char *)req->inbuf);
8830 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8831 END_PROFILE(SMBtranss2);
8835 for (state = conn->pending_trans; state != NULL;
8836 state = state->next) {
8837 if (state->mid == req->mid) {
8842 if ((state == NULL) || (state->cmd != SMBtrans2)) {
8843 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8844 END_PROFILE(SMBtranss2);
8848 /* Revise state->total_param and state->total_data in case they have
8849 changed downwards */
8851 if (SVAL(req->vwv+0, 0) < state->total_param)
8852 state->total_param = SVAL(req->vwv+0, 0);
8853 if (SVAL(req->vwv+1, 0) < state->total_data)
8854 state->total_data = SVAL(req->vwv+1, 0);
8856 pcnt = SVAL(req->vwv+2, 0);
8857 poff = SVAL(req->vwv+3, 0);
8858 pdisp = SVAL(req->vwv+4, 0);
8860 dcnt = SVAL(req->vwv+5, 0);
8861 doff = SVAL(req->vwv+6, 0);
8862 ddisp = SVAL(req->vwv+7, 0);
8864 state->received_param += pcnt;
8865 state->received_data += dcnt;
8867 if ((state->received_data > state->total_data) ||
8868 (state->received_param > state->total_param))
8872 if (trans_oob(state->total_param, pdisp, pcnt)
8873 || trans_oob(smb_len(req->inbuf), poff, pcnt)) {
8876 memcpy(state->param+pdisp,smb_base(req->inbuf)+poff,pcnt);
8880 if (trans_oob(state->total_data, ddisp, dcnt)
8881 || trans_oob(smb_len(req->inbuf), doff, dcnt)) {
8884 memcpy(state->data+ddisp, smb_base(req->inbuf)+doff,dcnt);
8887 if ((state->received_param < state->total_param) ||
8888 (state->received_data < state->total_data)) {
8889 END_PROFILE(SMBtranss2);
8893 handle_trans2(conn, req, state);
8895 DLIST_REMOVE(conn->pending_trans, state);
8896 SAFE_FREE(state->data);
8897 SAFE_FREE(state->param);
8900 END_PROFILE(SMBtranss2);
8905 DEBUG(0,("reply_transs2: invalid trans parameters\n"));
8906 DLIST_REMOVE(conn->pending_trans, state);
8907 SAFE_FREE(state->data);
8908 SAFE_FREE(state->param);
8910 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8911 END_PROFILE(SMBtranss2);